Changeset 8120


Ignore:
Timestamp:
May 22, 2019, 11:20:51 PM (3 years ago)
Author:
kopal
Message:

DECODEDatabaseTools:

  • implemented authentication; based on that:

completely rewrote JsonDownloaderAndConverter
rewrote DECODEDownloader
rewrote DECODEViewer

Location:
trunk/CrypPlugins/DECODEDatabaseTools
Files:
4 added
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/DECODEDatabaseTools/DECODEDatabaseTools.csproj

    r8115 r8120  
    33  <PropertyGroup>
    44    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    5     <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
     5    <Platform Condition=" '$(Platform)' == '' ">x64</Platform>
    66    <ProductVersion>9.0.30729</ProductVersion>
    77    <SchemaVersion>2.0</SchemaVersion>
     
    3434    <TargetFrameworkProfile />
    3535  </PropertyGroup>
    36   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    37     <PlatformTarget>x86</PlatformTarget>
     36  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
     37    <PlatformTarget>x64</PlatformTarget>
    3838    <OutputPath>..\..\CrypBuild\Release\CrypPlugins</OutputPath>
    3939    <ErrorReport>prompt</ErrorReport>
     
    4444    <Prefer32Bit>false</Prefer32Bit>
    4545  </PropertyGroup>
    46   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    47     <PlatformTarget>x86</PlatformTarget>
     46  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
     47    <PlatformTarget>x64</PlatformTarget>
    4848    <OutputPath>..\..\CrypBuild\Debug\CrypPlugins</OutputPath>
    4949    <ErrorReport>prompt</ErrorReport>
     
    5555    <Prefer32Bit>false</Prefer32Bit>
    5656  </PropertyGroup>
    57   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Test|x86'">
     57  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Test|x64'">
    5858    <DebugSymbols>true</DebugSymbols>
    5959    <OutputPath>..\..\CrypBuild\Test\</OutputPath>
    60     <DefineConstants>DEBUG;TRACE</DefineConstants>
    61     <DebugType>full</DebugType>
    62     <PlatformTarget>x86</PlatformTarget>
    63     <ErrorReport>prompt</ErrorReport>
    64     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    65   </PropertyGroup>
    66   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
    67     <OutputPath>..\..\CrypBuild\Release\CrypPlugins\</OutputPath>
    68     <DefineConstants>TRACE</DefineConstants>
    69     <Optimize>true</Optimize>
    70     <DebugType>pdbonly</DebugType>
    71     <PlatformTarget>x64</PlatformTarget>
    72     <ErrorReport>prompt</ErrorReport>
    73     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    74   </PropertyGroup>
    75   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
    76     <DebugSymbols>true</DebugSymbols>
    77     <OutputPath>..\..\CrypBuild\Debug\CrypPlugins\</OutputPath>
    7860    <DefineConstants>DEBUG;TRACE</DefineConstants>
    7961    <DebugType>full</DebugType>
     
    8264    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    8365  </PropertyGroup>
    84   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Test|x64'">
    85     <DebugSymbols>true</DebugSymbols>
    86     <OutputPath>bin\x64\Test\</OutputPath>
    87     <DefineConstants>DEBUG;TRACE</DefineConstants>
    88     <DebugType>full</DebugType>
    89     <PlatformTarget>x64</PlatformTarget>
    90     <ErrorReport>prompt</ErrorReport>
    91     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    92   </PropertyGroup>
    9366  <ItemGroup>
    9467    <Reference Include="PresentationCore">
     
    10275      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    10376    </Reference>
     77    <Reference Include="System.Drawing" />
     78    <Reference Include="System.Net.Http" />
    10479    <Reference Include="System.Runtime.Serialization" />
     80    <Reference Include="System.Security" />
    10581    <Reference Include="System.Xaml" />
    10682    <Reference Include="System.Xml" />
     
    11187  <ItemGroup>
    11288    <Compile Include="DataObjects.cs" />
     89    <Compile Include="DECODESettingsTab.xaml.cs">
     90      <DependentUpon>DECODESettingsTab.xaml</DependentUpon>
     91    </Compile>
    11392    <Compile Include="DECODEViewerSettings.cs" />
    11493    <Compile Include="DECODEViewerPresentation.xaml.cs">
     
    137116      <DesignTime>True</DesignTime>
    138117      <DependentUpon>Resources.ru.resx</DependentUpon>
     118    </Compile>
     119    <Compile Include="Properties\Settings.Designer.cs">
     120      <AutoGen>True</AutoGen>
     121      <DesignTimeSharedInput>True</DesignTimeSharedInput>
     122      <DependentUpon>Settings.settings</DependentUpon>
    139123    </Compile>
    140124  </ItemGroup>
     
    184168  </ItemGroup>
    185169  <ItemGroup>
     170    <Page Include="DECODESettingsTab.xaml">
     171      <SubType>Designer</SubType>
     172      <Generator>MSBuild:Compile</Generator>
     173    </Page>
    186174    <Page Include="DECODEViewerPresentation.xaml">
    187175      <Generator>MSBuild:Compile</Generator>
     
    192180      <SubType>Designer</SubType>
    193181    </Page>
     182  </ItemGroup>
     183  <ItemGroup>
     184    <Resource Include="DECODE_message.png" />
     185  </ItemGroup>
     186  <ItemGroup>
     187    <None Include="app.config" />
     188    <None Include="Properties\Settings.settings">
     189      <Generator>SettingsSingleFileGenerator</Generator>
     190      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
     191    </None>
    194192  </ItemGroup>
    195193  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/DECODEDatabaseTools/DECODEDownloader.cs

    r8109 r8120  
    2525using System.Threading;
    2626using System;
     27using System.Text;
    2728
    2829namespace Cryptool.Plugins.DECODEDatabaseTools
     
    3637        private DECODEDownloaderSettings settings;
    3738        private DECODEDownloaderPresentation presentation;
    38         private JsonDownloaderAndConverter jsonDownloaderAndConverter;
    3939        private bool running = false;
     40
     41
    4042        #endregion
    4143
     
    4749            settings = new DECODEDownloaderSettings();
    4850            presentation = new DECODEDownloaderPresentation(this);
    49             jsonDownloaderAndConverter = new JsonDownloaderAndConverter();
    50             jsonDownloaderAndConverter.DownloadDataCompleted += jsonDownloaderAndConverter_DownloadDataCompleted;
    51             jsonDownloaderAndConverter.DownloadStringCompleted += jsonDownloaderAndConverter_DownloadStringCompleted;
    52             jsonDownloaderAndConverter.DownloadProgressChanged += jsonDownloaderAndConverter_DownloadProgressChanged;
    5351        }
    5452
     
    108106            try
    109107            {
    110                jsonDownloaderAndConverter.GetRecordsList(JsonDownloaderAndConverter.DOWNLOAD_URL);
     108               var recordsString = JsonDownloaderAndConverter.GetRecords();
     109               Records records;
     110               DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Records));
     111               using (MemoryStream stream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(recordsString)))
     112               {
     113                   stream.Position = 0;
     114                   try
     115                   {
     116                       records = (Records)serializer.ReadObject(stream);
     117                   }
     118                   catch (Exception ex)
     119                   {
     120                       throw new Exception(String.Format("Could not deserialize json data received from DECODE database: {0}", ex.Message), ex);
     121                   }
     122               }
     123               presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     124               {
     125                   try
     126                   {
     127                       presentation.RecordsList.Clear();
     128                       if (records != null)
     129                       {
     130                           foreach (RecordsRecord record in records.records)
     131                           {
     132                               presentation.RecordsList.Add(record);
     133                           }
     134                       }
     135                   }
     136                   catch (Exception ex)
     137                   {
     138                       GuiLogMessage(String.Format("Exception while adding received data to ListView: {0}", ex.Message), NotificationLevel.Error);
     139                       return;
     140                   }
     141               }, null);
    111142            }
    112143            catch (Exception ex)
     
    117148            running = true;
    118149        }
    119        
    120         /// <summary>
    121         /// Download progess changed; we update the plugin progress accordingly
    122         /// </summary>
    123         /// <param name="sender"></param>
    124         /// <param name="args"></param>
    125        
    126         private void jsonDownloaderAndConverter_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs args)
    127         {
    128             ProgressChanged(args.BytesReceived, args.TotalBytesToReceive);
    129         }       
    130 
    131         /// <summary>
    132         /// Download record list finished
    133         /// </summary>
    134         /// <param name="sender"></param>
    135         /// <param name="args"></param>
    136         private void jsonDownloaderAndConverter_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs args)
    137         {
    138             if (args.UserState.Equals(JsonDownloaderAndConverter.GETRECORDLIST))
    139             {
    140                 HandleDownloadRecordsFinished(args);
    141                 ProgressChanged(1, 1);
    142             }           
    143         }
    144 
    145         /// <summary>
    146         /// Download record finished
    147         /// </summary>
    148         /// <param name="sender"></param>
    149         /// <param name="e"></param>
    150         private void jsonDownloaderAndConverter_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs args)
    151         {
    152             if (args.UserState.Equals(JsonDownloaderAndConverter.GETRECORDSTRING))
    153             {
    154                 HandleDownloadRecordFinished(args);
    155                 ProgressChanged(1, 1);
    156             }
     150
     151        public void Download(RecordsRecord record)
     152        {
     153            if (!running)
     154            {
     155                return;
     156            }
     157            try
     158            {
     159                DECODERecord = JsonDownloaderAndConverter.GetRecord(record.record_id);
     160                OnPropertyChanged("DECODERecord");
     161            }
     162            catch (Exception ex)
     163            {
     164                GuiLogMessage(String.Format("Could not download record from DECODE database: {0}", ex.Message), NotificationLevel.Error);
     165            }
     166            ProgressChanged(0, 1);
    157167           
    158         }     
    159 
    160         /// <summary>
    161         /// We received a records list; now we show it to the user
    162         /// </summary>
    163         /// <param name="args"></param>
    164         private void HandleDownloadRecordsFinished(DownloadDataCompletedEventArgs args)
    165         {
    166             if (args.Error != null)
    167             {
    168                 GuiLogMessage(String.Format("Error during downloading of records list: {0}", args.Error.Message), NotificationLevel.Error);
    169                 return;
    170             }
    171             try
    172             {
    173                 Records records;
    174                 //end of dirty hack
    175                 DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Records));
    176                 using (MemoryStream stream = new MemoryStream(args.Result))
    177                 {
    178                     stream.Position = 0;
    179                     try
    180                     {
    181                         records = (Records)serializer.ReadObject(stream);
    182                     }
    183                     catch (Exception ex)
    184                     {
    185                         throw new Exception(String.Format("Could not deserialize json data received from DECODE database: {0}", ex.Message), ex);
    186                     }
    187                 }
    188                 presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    189                 {
    190                     try
    191                     {
    192                         presentation.RecordsList.Clear();
    193                         if (records != null)
    194                         {
    195                             foreach (RecordsRecord record in records.records)
    196                             {
    197                                 presentation.RecordsList.Add(record);
    198                             }
    199                         }
    200                     }
    201                     catch (Exception ex)
    202                     {
    203                         GuiLogMessage(String.Format("Exception while adding received data to ListView: {0}", ex.Message), NotificationLevel.Error);
    204                         return;
    205                     }
    206                 }, null);
    207             }
    208             catch (Exception ex)
    209             {
    210                 GuiLogMessage(String.Format("Exception while adding received data to ListView: {0}", ex.Message), NotificationLevel.Error);
    211             }     
    212         }
    213 
    214         /// <summary>
    215         /// We downloaded a record json string; now we output it
    216         /// </summary>
    217         /// <param name="args"></param>
    218         private void HandleDownloadRecordFinished(DownloadStringCompletedEventArgs args)
    219         {
    220             if (args.Error == null)
    221             {
    222                 DECODERecord = args.Result;
    223                 OnPropertyChanged("DECODERecord");
    224             }
    225             else
    226             {
    227                 GuiLogMessage(String.Format("Exception while downloading of record: {0}", args.Error.Message), NotificationLevel.Error);
    228             }
    229         }
    230 
    231         public void Download(RecordsRecord record)
    232         {
    233             if (!running)
    234             {
    235                 return;
    236             }
    237             ProgressChanged(0, 1);
    238             jsonDownloaderAndConverter.GetRecordString(record);
    239168        }
    240169
     
    267196        public void Dispose()
    268197        {
    269             jsonDownloaderAndConverter.Dispose();
     198           
    270199        }
    271200
     
    281210
    282211        public event PropertyChangedEventHandler PropertyChanged;
     212       
    283213
    284214        private void GuiLogMessage(string message, NotificationLevel logLevel)
  • trunk/CrypPlugins/DECODEDatabaseTools/DECODEDownloaderPresentation.xaml.cs

    r8109 r8120  
    11/*
    2    Copyright 2018 Nils Kopal <Nils.Kopal<at>CrypTool.org
     2   Copyright 2019 Nils Kopal <Nils.Kopal<at>CrypTool.org
    33
    44   Licensed under the Apache License, Version 2.0 (the "License");
  • trunk/CrypPlugins/DECODEDatabaseTools/DECODEDownloaderSettings.cs

    r8109 r8120  
    11/*
    2    Copyright 2018 Nils Kopal <Nils.Kopal<at>CrypTool.org
     2   Copyright 2019 Nils Kopal <Nils.Kopal<at>CrypTool.org
    33
    44   Licensed under the Apache License, Version 2.0 (the "License");
     
    2323    public class DECODEDownloaderSettings : ISettings
    2424    {
    25 
    2625        public event PropertyChangedEventHandler PropertyChanged;
    2726
     
    3433        {
    3534
    36         }
     35        }       
    3736    }
    3837}
  • trunk/CrypPlugins/DECODEDatabaseTools/DECODEViewer.cs

    r8109 r8120  
    2020using System.Net;
    2121using Cryptool.Plugins.DECODEDatabaseTools.DataObjects;
     22using System.IO;
    2223using System.Windows.Threading;
    2324using System.Threading;
    2425using System;
     26using System.Text;
    2527using Cryptool.PluginBase.IO;
     28using System.Drawing.Imaging;
     29using System.Drawing;
     30using System.Drawing.Drawing2D;
     31using System.Threading.Tasks;
     32using System.Windows.Media.Imaging;
    2633
    2734namespace Cryptool.Plugins.DECODEDatabaseTools
     
    3340    {
    3441        #region Private Variables
    35         private DECODEViewerSettings settings;
    36         private DECODEViewerPresentation presentation;
    37         private JsonDownloaderAndConverter documentDownloader;
    38         private JsonDownloaderAndConverter imageDownloader;
    39         private bool running = false;
    40         private bool isDocumentDownloading = false;
    41         private bool isImageDownloading = false;
     42        private DECODEViewerSettings _settings;
     43        private DECODEViewerPresentation _presentation;
     44        private bool _running = false;
     45
    4246        #endregion
    4347
     
    4751        public DECODEViewer()
    4852        {
    49             settings = new DECODEViewerSettings();
    50             presentation = new DECODEViewerPresentation(this);
    51             documentDownloader = new JsonDownloaderAndConverter();
    52             imageDownloader = new JsonDownloaderAndConverter();
     53            _settings = new DECODEViewerSettings();
     54            _presentation = new DECODEViewerPresentation(this);
    5355        }
    5456
     
    9597        public ISettings Settings
    9698        {
    97             get { return settings; }
     99            get { return _settings; }
    98100        }
    99101
     
    103105        public UserControl Presentation
    104106        {
    105             get { return presentation; }
     107            get { return _presentation; }
    106108        }
    107109
     
    111113        public void PreExecution()
    112114        {
    113             this.presentation.Record = new Record();
    114             presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     115            this._presentation.Record = new Record();
     116            _presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    115117            {
    116118                try
    117119                {
    118                     presentation.ImageList.Items.Clear();
    119                     presentation.DocumentList.Items.Clear();
     120                    _presentation.ImageList.Items.Clear();
     121                    _presentation.DocumentList.Items.Clear();
    120122                }
    121123                catch(Exception)
     
    131133        public void Execute()
    132134        {
    133             running = true;
     135            _running = true;
    134136            ProgressChanged(0, 1);
    135137            Record record;
    136138            try
    137139            {
    138                 record = documentDownloader.GetRecordFromString(DECODERecord);
     140                record = JsonDownloaderAndConverter.ConvertStringToRecord(DECODERecord);
    139141            }
    140142            catch (Exception ex)
     
    143145                return;
    144146            }
    145             presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    146             {
    147                 try
    148                 {
    149                     presentation.Record = record;
    150                     //add all images to the ListView of images
    151                     presentation.ImageList.Items.Clear();
    152                     foreach (DataObjects.Image image in record.images)
     147            try
     148            {
     149                _presentation.Record = record;
     150                //add all images to the ListView of images
     151                _presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     152                {
     153                    _presentation.ImageList.Items.Clear();
     154                }, null);
     155                ProgressChanged(0, 0);
     156                for (int i = 0; i < record.images.Count; i++)
     157                {
     158                    record.images[i].DownloadThumbnail();
     159                    _presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
    153160                    {
    154                         presentation.ImageList.Items.Add(image);
     161                        try
     162                        {
     163                            _presentation.ImageList.Items.Add(record.images[i]);
     164                        }
     165                        catch (Exception ex)
     166                        {
     167                            GuiLogMessage(String.Format("Exception while adding thumbnail to list: {0}", ex.Message), NotificationLevel.Error);
     168                        }
     169                    }, null);
     170                    ProgressChanged(i, record.images.Count);
     171                    if (_running == false)
     172                    {
     173                        return;
    155174                    }
    156                     //add all documents to the ListView of documents
    157                     presentation.DocumentList.Items.Clear();
     175                }
     176                ProgressChanged(1, 1);
     177
     178                //add all documents to the ListView of documents
     179                _presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     180                {
     181                    _presentation.DocumentList.Items.Clear();
    158182                    foreach (DataObjects.Document document in record.documents.AllDocuments)
    159183                    {
    160                         presentation.DocumentList.Items.Add(document);
     184                        _presentation.DocumentList.Items.Add(document);
     185                        if (_running == false)
     186                        {
     187                            return;
     188                        }
    161189                    }
    162190                    //set checkboxes
    163191                    //transcription
    164                     presentation.HasTranscriptionCheckbox.IsChecked = record.documents.transcription.Count > 0;
     192                    _presentation.HasTranscriptionCheckbox.IsChecked = record.documents.transcription.Count > 0;
    165193                    //cryptanalysis_statistics
    166                     presentation.HasStatisticsCheckbox.IsChecked = record.documents.cryptanalysis_statistics.Count > 0;
     194                    _presentation.HasStatisticsCheckbox.IsChecked = record.documents.cryptanalysis_statistics.Count > 0;
    167195                    //deciphered_text
    168                     presentation.HasDeciphermentCheckbox.IsChecked = record.documents.deciphered_text.Count > 0;
    169                     ///translation
    170                     presentation.HasTranslationCheckbox.IsChecked = record.documents.translation.Count > 0;
    171                 }
    172                 catch (Exception ex)
    173                 {
    174                     GuiLogMessage(String.Format("Error while adding data:{0}", ex.Message), NotificationLevel.Error);
    175                     return;
    176                 }
    177             }, null);
     196                    _presentation.HasDeciphermentCheckbox.IsChecked = record.documents.deciphered_text.Count > 0;
     197                    //translation
     198                    _presentation.HasTranslationCheckbox.IsChecked = record.documents.translation.Count > 0;
     199                }, null);
     200            }
     201            catch (Exception ex)
     202            {
     203                GuiLogMessage(String.Format("Error while adding data:{0}", ex.Message), NotificationLevel.Error);
     204                return;
     205            }
     206           
    178207            ProgressChanged(1, 1);
    179208        }
     
    192221        public void Stop()
    193222        {
    194             running = false;
     223            _running = false;
    195224        }
    196225
     
    207236        public void Dispose()
    208237        {
    209             documentDownloader.Dispose();
    210             imageDownloader.Dispose();
    211238        }
    212239
     
    238265        }
    239266
    240         #endregion       
    241    
     267        #endregion
     268
    242269        /// <summary>
    243270        /// Download and output an image
     
    246273        internal void DownloadImage(DataObjects.Image image)
    247274        {
    248             if (!running)
     275            if (!_running)
    249276            {
    250277                return;
    251278            }
    252             lock (this)
    253             {
    254                 if (isImageDownloading || isDocumentDownloading)
    255                 {
    256                     return;
    257                 }
    258                 isImageDownloading = true;
    259             }
     279            Task.Run(() =>
     280            {
     281                byte[] imageBytes = null;
     282                try
     283                {
     284                    imageBytes = image.GetFullImage;
     285                }
     286                catch (Exception ex)
     287                {
     288                    GuiLogMessage(String.Format("Exception occured during downloading of image: {0}", ex.Message), NotificationLevel.Error);
     289                }
     290                if (imageBytes != null)
     291                {
     292                    OutputDownloadedImage(imageBytes);
     293                }
     294            });
     295        }
     296
     297        /// <summary>
     298        /// Checks, if the image bytes are an html document (=> display not allowed) or an actual image and returns
     299        /// this
     300        /// </summary>
     301        /// <param name="imageBytes"></param>
     302        private void OutputDownloadedImage(byte[] imageBytes)
     303        {
    260304            try
    261305            {
    262                 OnPluginProgressChanged(this, new PluginProgressEventArgs(0, 1));
    263                 image.DownloadDataCompleted += image_DownloadDataCompleted;
    264                 image.DownloadProgressChanged += image_DownloadProgressChanged;
    265                 image.DownloadImage();
     306                string text = Encoding.UTF8.GetString(imageBytes);
     307                //this is a hacky check... if the database returns text instead of an image
     308                //the user is not allowed to download the image
     309                //we know, it is text, if it contains html and body texts
     310                if (text.ToLower().Contains("html") && text.ToLower().Contains("body"))
     311                {
     312                    using (MemoryStream stream = new MemoryStream())
     313                    {
     314                        Bitmap bitmap = (Bitmap)Properties.Resources.DECODE_message.Clone();
     315
     316                        RectangleF rectf = new RectangleF(50, 50, 450, 450);
     317                        Graphics graphics = Graphics.FromImage(bitmap);
     318                        graphics.SmoothingMode = SmoothingMode.AntiAlias;
     319                        graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
     320                        graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
     321                        graphics.DrawString(Properties.Resources.image_not_available_for_download, new Font("Tahoma", 12), Brushes.Black, rectf);
     322
     323                        bitmap.Save(stream, ImageFormat.Png);
     324                        bitmap.Dispose();
     325                        OutputImage = new CStreamWriter(stream.ToArray());
     326                        OnPropertyChanged("OutputImage");
     327                    }
     328                }
     329                else
     330                {
     331                    OutputImage = new CStreamWriter(imageBytes);
     332                    OnPropertyChanged("OutputImage");
     333                }
    266334            }
    267335            catch (Exception ex)
    268336            {
    269                 GuiLogMessage(String.Format("Exception occured during downloading of image: {0}", ex.Message), NotificationLevel.Error);
    270             }     
    271         }
    272 
    273         /// <summary>
    274         /// Called, when image download progress changed
    275         /// </summary>
    276         /// <param name="sender"></param>
    277         /// <param name="args"></param>
    278         private void image_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs args)
    279         {
    280             OnPluginProgressChanged(this, new PluginProgressEventArgs(args.BytesReceived, args.TotalBytesToReceive));
    281         }
    282 
    283         /// <summary>
    284         /// Called when image is completely download
    285         /// </summary>
    286         /// <param name="sender"></param>
    287         /// <param name="args"></param>
    288         private void image_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs args)
    289         {
    290             try
    291             {
    292                 if (args.Error == null)
    293                 {
    294                     OutputImage = new CStreamWriter(args.Result);
    295                     OnPropertyChanged("OutputImage");
    296                     OnPluginProgressChanged(this, new PluginProgressEventArgs(1, 1));
    297                 }
    298                 else
    299                 {
    300                     GuiLogMessage(String.Format("Exception occured during downloading of image: {0}", args.Error.Message), NotificationLevel.Error);
    301                 }
    302                 lock (this)
    303                 {
    304                     isImageDownloading = false;
    305                 }
    306             }
    307             catch (Exception ex)
    308             {
    309                 //wtf?
     337                GuiLogMessage(String.Format("Exception occured during creation of image: {0}", ex.Message), NotificationLevel.Error);
    310338            }
    311339        }
     
    317345        internal void DownloadDocument(Document document)
    318346        {
    319             if (!running)
     347            if (!_running)
    320348            {
    321349                return;
    322350            }
    323             lock (this)
    324             {
    325                 if (isDocumentDownloading || isImageDownloading)
    326                 {
    327                     return;
    328                 }
    329                 isDocumentDownloading = true;
    330             }
     351            Task.Run(() => DoDownloadDocument(document));
     352        }
     353
     354        private void DoDownloadDocument(Document document)
     355        {
    331356            try
    332357            {
    333                 OnPluginProgressChanged(this, new PluginProgressEventArgs(0,1));
    334                 document.DownloadDataCompleted += document_DownloadDataCompleted;
    335                 document.DownloadProgressChanged += document_DownloadProgressChanged;
    336                 document.DownloadDocument();                         
     358                OutputDocument = document.DownloadDocument();
     359                OnPropertyChanged("OutputDocument");
    337360            }
    338361            catch (Exception ex)
    339362            {
    340363                GuiLogMessage(String.Format("Exception during downloading of document: {0}", ex.Message), NotificationLevel.Error);
    341             }     
    342         }
    343 
    344         /// <summary>
    345         /// Called when the progress of the downloader changed; changes the progress of the plugin accordingly
    346         /// </summary>
    347         /// <param name="sender"></param>
    348         /// <param name="args"></param>
    349         private void document_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs args)
    350         {
    351             OnPluginProgressChanged(this, new PluginProgressEventArgs(args.BytesReceived, args.TotalBytesToReceive));
    352         }
    353 
    354         /// <summary>
    355         /// Called when the download of the document is completed
    356         /// </summary>
    357         /// <param name="sender"></param>
    358         /// <param name="args"></param>
    359         private void document_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs args)
    360         {
    361             try
    362             {
    363                 if (args.Error == null)
    364                 {
    365                     OutputDocument = args.Result;
    366                     OnPropertyChanged("OutputDocument");
    367                     OnPluginProgressChanged(this, new PluginProgressEventArgs(1, 1));
    368                 }
    369                 else
    370                 {
    371                     GuiLogMessage(String.Format("Exception occured during downloading of data: {0}", args.Error.Message), NotificationLevel.Error);
    372                 }
    373                 lock (this)
    374                 {
    375                     isDocumentDownloading = false;
    376                 }
    377             }
    378             catch (Exception ex)
    379             {
    380                 //wtf?
    381364            }
    382365        }
  • trunk/CrypPlugins/DECODEDatabaseTools/DECODEViewerSettings.cs

    r8109 r8120  
    11/*
    2    Copyright 2018 Nils Kopal <Nils.Kopal<at>CrypTool.org
     2   Copyright 2019 Nils Kopal <Nils.Kopal<at>CrypTool.org
    33
    44   Licensed under the Apache License, Version 2.0 (the "License");
  • trunk/CrypPlugins/DECODEDatabaseTools/DataObjects.cs

    r8109 r8120  
    1 using Cryptool.PluginBase.Miscellaneous;
     1using System;
     2using Cryptool.PluginBase.Miscellaneous;
    23/*
    34   Copyright 2018 Nils Kopal <Nils.Kopal<at>CrypTool.org
     
    1516   limitations under the License.
    1617*/
    17 using System;
    1818using System.Collections.Generic;
    1919using System.ComponentModel;
    2020using System.IO;
    21 using System.Net;
    2221using System.Runtime.Serialization;
     22using System.Threading.Tasks;
     23using System.Windows.Media;
    2324using System.Windows.Media.Imaging;
    2425
     
    122123
    123124    [DataContract]
    124     public class Image : INotifyPropertyChanged
    125     {
    126         private JsonDownloaderAndConverter fullImageDownloader;
    127         private JsonDownloaderAndConverter thumbnailDownloader;
    128 
    129         public event PropertyChangedEventHandler PropertyChanged;
    130         public event DownloadDataCompletedEventHandler DownloadDataCompleted;
    131         public event DownloadProgressChangedEventHandler DownloadProgressChanged;
    132 
    133 
     125    public class Image
     126    {
    134127        [DataMember]
    135128        public int image_id { get; set; }
     
    140133
    141134        private byte[] thumbnail_data;
    142 
    143 
    144         public BitmapFrame GetFullImage
     135        private byte[] full_data;
     136
     137        public byte[] GetFullImage
    145138        {
    146139            get
    147140            {
     141                if (full_data == null)
     142                {
     143                    full_data = JsonDownloaderAndConverter.GetData(full_url);
     144                }
     145                return full_data;
     146            }
     147        }
     148
     149        /// <summary>
     150        /// Downloads a thumbnail
     151        /// </summary>
     152        public void DownloadThumbnail()
     153        {
     154            if (thumbnail_data == null)
     155            {
     156                thumbnail_data = JsonDownloaderAndConverter.GetData(thumbnail_url);
     157            }
     158        }
     159
     160        /// <summary>
     161        /// Returns the thumbnail as BitmapImage
     162        /// </summary>
     163        public ImageSource GetThumbnail
     164        {
     165            get
     166            {
     167                if (thumbnail_data == null)
     168                {
     169                    return null;
     170                }
     171                try
     172                {
     173                    var decoder = BitmapDecoder.Create(new MemoryStream(thumbnail_data),
     174                        BitmapCreateOptions.PreservePixelFormat,
     175                        BitmapCacheOption.None);
     176
     177                    if (decoder.Frames.Count > 0)
     178                    {
     179                        return decoder.Frames[0];
     180                    }
     181                }
     182                catch (Exception ex)
     183                {
     184                    //do nothing
     185                }
    148186                return null;
    149187            }
    150188        }
    151 
    152         public BitmapFrame GetThumbnail
    153         {
    154             get
    155             {
    156                 if (thumbnailDownloader == null)
    157                 {
    158                     thumbnailDownloader = new JsonDownloaderAndConverter();
    159                     thumbnailDownloader.DownloadDataCompleted += thumbnailDownloader_DownloadDataCompleted;
    160                     thumbnailDownloader.GetData(thumbnail_url);
    161                     return null;
    162                 }
    163                 if (thumbnail_data == null)
    164                 {
    165                     return null;
    166                 }
    167                 var decoder = BitmapDecoder.Create(new MemoryStream(thumbnail_data),
    168                               BitmapCreateOptions.PreservePixelFormat,
    169                               BitmapCacheOption.None);
    170                 if (decoder.Frames.Count > 0)
    171                 {
    172                     return decoder.Frames[0];
    173                 }
    174                 else
    175                 {
    176                     return null;
    177                 }
    178             }
    179         }
    180 
    181         /// <summary>
    182         /// Invoked when thumbnail download finished
    183         /// </summary>
    184         /// <param name="sender"></param>
    185         /// <param name="args"></param>
    186         void thumbnailDownloader_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs args)
    187         {
    188             if (args.Error == null)
    189             {
    190                 thumbnail_data = args.Result;
    191             }
    192             OnPropertyChanged("GetThumbnail");
    193         }
    194 
    195      
    196         private void OnPropertyChanged(string propertyName)
    197         {
    198             EventsHelper.PropertyChanged(PropertyChanged, this, propertyName);
    199         }
    200 
    201         /// <summary>
    202         /// download the full image
    203         /// </summary>
    204         internal void DownloadImage()
    205         {
    206             if (fullImageDownloader == null)
    207             {
    208                 fullImageDownloader = new JsonDownloaderAndConverter();
    209                 fullImageDownloader.DownloadDataCompleted += fullImageDownloader_DownloadDataCompleted;
    210                 fullImageDownloader.DownloadProgressChanged += fullImageDownloader_DownloadProgressChanged;
    211                 fullImageDownloader.GetData(full_url);
    212             }         
    213         }
    214 
    215         /// <summary>
    216         /// Called, when the download progress changed
    217         /// </summary>
    218         /// <param name="sender"></param>
    219         /// <param name="args"></param>
    220         void fullImageDownloader_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs args)
    221         {
    222             if (DownloadProgressChanged != null)
    223             {
    224                 DownloadProgressChanged.Invoke(this, args);
    225             }
    226         }
    227 
    228         /// <summary>
    229         /// called when download is finished
    230         /// </summary>
    231         /// <param name="sender"></param>
    232         /// <param name="args"></param>
    233         void fullImageDownloader_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs args)
    234         {
    235             try
    236             {
    237                 if (DownloadDataCompleted != null)
    238                 {
    239                     DownloadDataCompleted.Invoke(this, args);
    240                 }
    241                 fullImageDownloader.DownloadDataCompleted -= fullImageDownloader_DownloadDataCompleted;
    242                 fullImageDownloader.DownloadProgressChanged -= fullImageDownloader_DownloadProgressChanged;
    243                 fullImageDownloader.Dispose();
    244                 fullImageDownloader = null;
    245             }
    246             catch (Exception ex)
    247             {
    248                 //wtf?
    249             }
    250         }
    251189    }
    252190
     
    254192    public class Document
    255193    {
    256         private JsonDownloaderAndConverter jsonDownloaderAndConverter;
    257 
    258         public event DownloadDataCompletedEventHandler DownloadDataCompleted;
    259         public event DownloadProgressChangedEventHandler DownloadProgressChanged;
    260 
     194       
    261195        [DataMember]
    262196        public int document_id { get; set; }
     
    272206        public string download_url { get; set; }
    273207
    274 
     208        private byte[] document_data;
    275209        /// <summary>
    276210        /// Tries to download the document; if it fails, it returns null
    277211        /// </summary>
    278         public void DownloadDocument()
     212        public byte[] DownloadDocument()
    279213        {                   
    280             if (jsonDownloaderAndConverter == null)
    281             {
    282                 jsonDownloaderAndConverter = new JsonDownloaderAndConverter();
    283                 jsonDownloaderAndConverter.DownloadDataCompleted += jsonDownloaderAndConverter_DownloadDataCompleted;
    284                 jsonDownloaderAndConverter.DownloadProgressChanged += jsonDownloaderAndConverter_DownloadProgressChanged;
    285                 jsonDownloaderAndConverter.GetData(download_url);
    286             }         
    287         }
    288 
    289         /// <summary>
    290         /// Called when download progress changed
    291         /// </summary>
    292         /// <param name="sender"></param>
    293         /// <param name="args"></param>
    294         void jsonDownloaderAndConverter_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs args)
    295         {
    296             if (DownloadProgressChanged != null)
    297             {
    298                 DownloadProgressChanged.Invoke(this, args);
    299             }
    300         }
    301 
    302         /// <summary>
    303         /// Called, when download is finished
    304         /// </summary>
    305         /// <param name="sender"></param>
    306         /// <param name="args"></param>
    307         private void jsonDownloaderAndConverter_DownloadDataCompleted(object sender, System.Net.DownloadDataCompletedEventArgs args)
    308         {
    309             try
    310             {
    311                 if (DownloadDataCompleted != null)
    312                 {
    313                     DownloadDataCompleted.Invoke(this, args);
    314                 }
    315                 jsonDownloaderAndConverter.DownloadDataCompleted -= jsonDownloaderAndConverter_DownloadDataCompleted;
    316                 jsonDownloaderAndConverter.DownloadProgressChanged -= jsonDownloaderAndConverter_DownloadProgressChanged;
    317                 jsonDownloaderAndConverter.Dispose();
    318                 jsonDownloaderAndConverter = null;
    319             }
    320             catch (Exception ex)
    321             {
    322                 //wtf?
    323             }
    324         }
    325     }
    326 
     214            if (document_data == null)
     215            {
     216                document_data = JsonDownloaderAndConverter.GetData(download_url);
     217            }
     218            return document_data;
     219        }
     220    }
    327221
    328222    [DataContract]
  • trunk/CrypPlugins/DECODEDatabaseTools/JsonDownloaderAndConverter.cs

    r8109 r8120  
    1 using Cryptool.PluginBase.Miscellaneous;
    2 /*
    3    Copyright 2018 Nils Kopal <Nils.Kopal<at>CrypTool.org
     1/*
     2   Copyright 2019 Nils Kopal <Nils.Kopal<at>CrypTool.org
    43
    54   Licensed under the Apache License, Version 2.0 (the "License");
     
    1918using System.IO;
    2019using System.Net;
     20using System.Net.Http;
     21using System.Net.Http.Headers;
    2122using System.Runtime.Serialization.Json;
    2223using System.Text;
     
    2425namespace Cryptool.Plugins.DECODEDatabaseTools
    2526{
    26     public class JsonDownloaderAndConverter : IDisposable
     27    public class JsonDownloaderAndConverter
    2728    {
    28         public const string DOWNLOAD_URL = "https://stp.lingfil.uu.se/decode/database/records";
    29 
    30         public const string GETRECORDLIST = "GetRecordsList";
    31         public const string GETRECORDSTRING = "GetRecordString";
    32         public const string GETDATA = "GetData";
    33         public const string USER_AGENT = "CrypTool 2";
    34 
    35         public event DownloadDataCompletedEventHandler DownloadDataCompleted;
    36         public event DownloadStringCompletedEventHandler DownloadStringCompleted;
    37         public event DownloadProgressChangedEventHandler DownloadProgressChanged;
    38 
    39         private MyWebClient WebClient = new MyWebClient();
    40         private bool isDownloading = false;
    41 
    42         /// <summary>
    43         /// Inherited WebClient to change timeout
    44         /// </summary>
    45         private class MyWebClient : WebClient
    46         {
    47             private const int TIMEOUT = 5000;
    48 
    49             protected override WebRequest GetWebRequest(Uri uri)
    50             {
    51                 WebRequest w = base.GetWebRequest(uri);
    52                 w.Timeout = TIMEOUT;
    53                 return w;
    54             }
    55         }
    56 
    57         /// <summary>
    58         /// Creates a new JsonDownloaderAndConverter
    59         /// </summary>
    60         public JsonDownloaderAndConverter()
    61         {
    62             WebClient.DownloadDataCompleted += WebClient_DownloadDataCompleted;
    63             WebClient.DownloadStringCompleted += WebClient_DownloadStringCompleted;
    64             WebClient.DownloadProgressChanged += WebClient_DownloadProgressChanged;
    65         }
    66 
    67         /// <summary>
    68         /// Called when the download progress of the webclient changed
    69         /// </summary>
    70         /// <param name="sender"></param>
    71         /// <param name="e"></param>
    72         private void WebClient_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
    73         {
    74             if (DownloadProgressChanged != null)
    75             {
    76                 DownloadProgressChanged.Invoke(this, e);
    77             }
    78         }
    79 
    80         /// <summary>
    81         /// Called when the download of the webclient is completed
    82         /// </summary>
    83         /// <param name="sender"></param>
    84         /// <param name="e"></param>
    85         private void WebClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
    86         {
    87             lock (this)
    88             {             
    89                 isDownloading = false;
    90             }
    91             if (DownloadStringCompleted != null)
    92             {
    93                 DownloadStringCompleted.Invoke(this, e);
    94             }
    95         }
    96 
    97         /// <summary>
    98         /// Called when the download of the webclient is completed
    99         /// </summary>
    100         /// <param name="sender"></param>
    101         /// <param name="e"></param>
    102         private void WebClient_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
    103         {
    104             lock (this)
    105             {
    106                 isDownloading = false;
    107             }
    108             if (DownloadDataCompleted != null)
    109             {
    110                 DownloadDataCompleted.Invoke(this, e);
     29        private const string LoginUrl = "https://cl.lingfil.uu.se/decode/database/api/login";
     30        private const string DownloadRecordsUrl = "https://cl.lingfil.uu.se/decode/database/api/records";
     31        private const string DownloadRecordUrl = "https://cl.lingfil.uu.se/decode/database/api/records/{0}";
     32
     33        private const string UserAgent = "CrypTool 2/DECODE JsonDownloaderAndConverter";
     34        private static CookieContainer _cookieContainer = new CookieContainer();
     35
     36        /// <summary>
     37        /// Login into DECODE database using username and password,
     38        /// also creates a new static CookieContainer, which it uses for storing and using the cookie
     39        /// </summary>
     40        /// <param name="username"></param>
     41        /// <param name="password"></param>
     42        /// <returns></returns>
     43        public static bool Login(string username, string password)
     44        {
     45            try
     46            {
     47                _cookieContainer = new CookieContainer();
     48                var handler = new HttpClientHandler { CookieContainer = _cookieContainer };
     49                using (var client = new HttpClient(handler))
     50                {
     51                    var usernamePasswordJson = new StringContent(String.Format("{{\"username\": \"{0}\", \"password\": \"{1}\"}}", username, password));
     52                    client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
     53                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
     54                    var response = client.PostAsync(LoginUrl, usernamePasswordJson).Result;
     55                    switch (response.StatusCode)
     56                    {
     57                        case HttpStatusCode.OK:
     58                            return true;
     59                        case HttpStatusCode.Forbidden:
     60                            return false;
     61                        default:
     62                            throw new Exception(String.Format("Error: Status code was {0}", response.StatusCode));
     63                    }
     64                }
     65            }
     66            catch (Exception ex)
     67            {
     68                throw new Exception(String.Format("Error while loggin into DECODE database: {0}", ex.Message), ex);
    11169            }
    11270        }
     
    11573        /// Get the list of records of the DECODE database using the json protocol
    11674        /// </summary>
    117         /// <param name="url"></param>
    118         /// <returns></returns>
    119         public void GetRecordsList(string url)
    120         {
    121             lock (this)
    122             {
    123                 if (isDownloading)
    124                 {
    125                     return;
    126                 }
    127                 isDownloading = true;
    128             }
    129             try
    130             {
    131                 WebClient.Headers.Add("Accept", "application/json");
    132                 WebClient.Headers.Add("Accept", "text/plain");
    133                 WebClient.Headers.Add("user-agent", USER_AGENT + ";" + AssemblyHelper.InstallationType.ToString() + ";" + AssemblyHelper.Version);
    134                 WebClient.DownloadDataAsync(new Uri(url), GETRECORDLIST);
    135             }
    136             catch (Exception ex)
    137             {
    138                 throw new Exception(String.Format("Error while downloading records data from DECODE database: {0}", ex.Message), ex);
    139             }               
    140            
    141         }
    142 
    143         /// <summary>
    144         /// Get a single record as string from the DECODE database using the json protocol
    145         /// </summary>
    146         /// <param name="record"></param>
    147         /// <returns></returns>
    148         public void GetRecordString(RecordsRecord record)
    149         {
    150             lock (this)
    151             {
    152                 if (isDownloading)
    153                 {
    154                     return;
    155                 }
    156                 isDownloading = true;
    157             }
    158             try
    159             {
    160                 WebClient.Headers.Add("Accept", "application/json");
    161                 WebClient.Headers.Add("Accept", "text/plain");
    162                 WebClient.Headers.Add("user-agent", USER_AGENT + ";" + AssemblyHelper.InstallationType.ToString() + ";" + AssemblyHelper.Version);
    163                 string url = DOWNLOAD_URL + "/" + record.record_id;
    164                 WebClient.DownloadStringAsync(new Uri(url), "GetRecordString");
    165             }
    166             catch (Exception ex)
    167             {
    168                 throw new Exception(String.Format("Error while downloading record data from DECODE database: {0}", ex.Message), ex);
     75        public static string GetRecords()
     76        {
     77            try
     78            {
     79                if (IsLoggedIn() == false)
     80                {
     81                    throw new Exception("Not logged in!");
     82                }
     83
     84                var handler = new HttpClientHandler { CookieContainer = _cookieContainer };
     85                using (var client = new HttpClient(handler))
     86                {
     87                    client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
     88                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
     89
     90                    var response = client.GetAsync(DownloadRecordsUrl).Result;
     91
     92                    switch (response.StatusCode)
     93                    {
     94                        case HttpStatusCode.OK:
     95                            return response.Content.ReadAsStringAsync().Result;
     96                        default:
     97                            throw new Exception(String.Format("Error: Status code was {0}", response.StatusCode));
     98                    }
     99                }
     100            }
     101            catch (Exception ex)
     102            {
     103                throw new Exception(String.Format("Error while downloading records from DECODE database: {0}", ex.Message), ex);
     104            }
     105        }
     106
     107        /// <summary>
     108        /// Get a single record as string from the DECODE database using the json protocol and http
     109        /// </summary>
     110        public static string GetRecord(int id)
     111        {
     112            try
     113            {
     114                if (IsLoggedIn() == false)
     115                {
     116                    throw new Exception("Not logged in!");
     117                }
     118
     119                var handler = new HttpClientHandler { CookieContainer = _cookieContainer };
     120                using (var client = new HttpClient(handler))
     121                {
     122                    client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
     123                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
     124
     125                    var response = client.GetAsync(String.Format(DownloadRecordUrl, id)).Result;
     126
     127                    switch (response.StatusCode)
     128                    {
     129                        case HttpStatusCode.OK:
     130                            return response.Content.ReadAsStringAsync().Result;
     131                        default:
     132                            throw new Exception(String.Format("Error: Status code was {0}", response.StatusCode));
     133                    }
     134                }
     135            }
     136            catch (Exception ex)
     137            {
     138                throw new Exception(String.Format("Error while downloading record from DECODE database: {0}", ex.Message), ex);
     139            }
     140        }
     141
     142        /// <summary>
     143        /// Get a records object from a string containing Record json data
     144        /// </summary>
     145        /// <param name="data"></param>
     146        public static Records ConvertStringToRecords(string data)
     147        {
     148            try
     149            {
     150                DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Records));
     151                using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(data)))
     152                {
     153                    stream.Position = 0;
     154                    Records records = (Records)serializer.ReadObject(stream);
     155                    return records;
     156                }
     157            }
     158            catch (Exception ex)
     159            {
     160                throw new Exception(String.Format("Could not deserialize json data: {0}", ex.Message), ex);
    169161            }
    170162        }
     
    174166        /// </summary>
    175167        /// <param name="data"></param>
    176         /// <returns></returns>
    177         public Record GetRecordFromString(string data)
     168        public static Record ConvertStringToRecord(string data)
    178169        {
    179170            try
     
    196187        /// Downloads data from the specified URL and returns it as byte array
    197188        /// </summary>
    198         /// <param name="url"></param>
     189        public static byte[] GetData(string url)
     190        {
     191            try
     192            {
     193                if (IsLoggedIn() == false)
     194                {
     195                    throw new Exception("Not logged in!");
     196                }
     197                var handler = new HttpClientHandler { CookieContainer = _cookieContainer };
     198                using (var client = new HttpClient(handler))
     199                {
     200                    client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
     201                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
     202
     203                    var response = client.GetAsync(url).Result;
     204
     205                    switch (response.StatusCode)
     206                    {
     207                        case HttpStatusCode.OK:
     208                            return response.Content.ReadAsByteArrayAsync().Result;
     209                        default:
     210                            throw new Exception(String.Format("Error: Status code was {0}", response.StatusCode));
     211                    }
     212                }
     213            }
     214            catch (Exception ex)
     215            {
     216                throw new Exception(String.Format("Error while downloading data from {0}: {1}", url, ex.Message), ex);
     217            }
     218        }
     219
     220        /// <summary>
     221        /// Checks, if there is a valid cookie
     222        /// </summary>
    199223        /// <returns></returns>
    200         public void GetData(string url)
    201         {
    202             lock (this)
    203             {
    204                 if (isDownloading)
    205                 {
    206                     return;
    207                 }
    208                 isDownloading = true;
    209             }
    210             try
    211             {
    212                 WebClient.DownloadDataAsync(new Uri(url), GETDATA);
    213             }
    214             catch (Exception ex)
    215             {
    216                 throw new Exception(String.Format("Error while downloading data from {0}: {1}", url, ex.Message), ex);
    217             }
    218         }
    219 
    220         /// <summary>
    221         /// Disposes the internal webclient
    222         /// </summary>
    223         public void Dispose()
    224         {
    225             WebClient.Dispose();
     224        public static bool IsLoggedIn()
     225        {
     226            return _cookieContainer.Count == 1;
    226227        }
    227228    }
  • trunk/CrypPlugins/DECODEDatabaseTools/Properties/Resources.Designer.cs

    r7891 r8120  
    2020    // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen
    2121    // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu.
    22     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
     22    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
    2323    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    2424    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     
    179179       
    180180        /// <summary>
     181        ///   Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap.
     182        /// </summary>
     183        internal static System.Drawing.Bitmap DECODE_message {
     184            get {
     185                object obj = ResourceManager.GetObject("DECODE_message", resourceCulture);
     186                return ((System.Drawing.Bitmap)(obj));
     187            }
     188        }
     189       
     190        /// <summary>
    181191        ///   Sucht eine lokalisierte Zeichenfolge, die DECODE Downloader ähnelt.
    182192        /// </summary>
     
    215225       
    216226        /// <summary>
     227        ///   Sucht eine lokalisierte Zeichenfolge, die DECODE ähnelt.
     228        /// </summary>
     229        internal static string DECODESettingsTab {
     230            get {
     231                return ResourceManager.GetString("DECODESettingsTab", resourceCulture);
     232            }
     233        }
     234       
     235        /// <summary>
    217236        ///   Sucht eine lokalisierte Zeichenfolge, die DECODE Viewer ähnelt.
    218237        /// </summary>
     
    278297       
    279298        /// <summary>
     299        ///   Sucht eine lokalisierte Zeichenfolge, die The creator of this record has chosen to not make this image available for download. ähnelt.
     300        /// </summary>
     301        internal static string image_not_available_for_download {
     302            get {
     303                return ResourceManager.GetString("image_not_available_for_download", resourceCulture);
     304            }
     305        }
     306       
     307        /// <summary>
    280308        ///   Sucht eine lokalisierte Zeichenfolge, die Images: ähnelt.
    281309        /// </summary>
     
    404432       
    405433        /// <summary>
     434        ///   Sucht eine lokalisierte Zeichenfolge, die Password: ähnelt.
     435        /// </summary>
     436        internal static string Password {
     437            get {
     438                return ResourceManager.GetString("Password", resourceCulture);
     439            }
     440        }
     441       
     442        /// <summary>
    406443        ///   Sucht eine lokalisierte Zeichenfolge, die Plaintext language: ähnelt.
    407444        /// </summary>
     
    467504       
    468505        /// <summary>
     506        ///   Sucht eine lokalisierte Zeichenfolge, die Test login data ähnelt.
     507        /// </summary>
     508        internal static string TestLoginData {
     509            get {
     510                return ResourceManager.GetString("TestLoginData", resourceCulture);
     511            }
     512        }
     513       
     514        /// <summary>
    469515        ///   Sucht eine lokalisierte Zeichenfolge, die Title ähnelt.
    470516        /// </summary>
     
    508554            get {
    509555                return ResourceManager.GetString("UploadDateHeader", resourceCulture);
     556            }
     557        }
     558       
     559        /// <summary>
     560        ///   Sucht eine lokalisierte Zeichenfolge, die Use login data: ähnelt.
     561        /// </summary>
     562        internal static string UseLoginData {
     563            get {
     564                return ResourceManager.GetString("UseLoginData", resourceCulture);
     565            }
     566        }
     567       
     568        /// <summary>
     569        ///   Sucht eine lokalisierte Zeichenfolge, die Username: ähnelt.
     570        /// </summary>
     571        internal static string Username {
     572            get {
     573                return ResourceManager.GetString("Username", resourceCulture);
    510574            }
    511575        }
  • trunk/CrypPlugins/DECODEDatabaseTools/Properties/Resources.de.resx

    r7891 r8120  
    193193    <value>Bilder:</value>
    194194  </data>
     195  <data name="image_not_available_for_download" xml:space="preserve">
     196    <value>Der Ersteller dieses Datensatzes hat sich entschieden, dieses Bild nicht zum Download zur Verfügung zu stellen.</value>
     197  </data>
    195198  <data name="InkType" xml:space="preserve">
    196199    <value>Art der Tinte:</value>
     
    268271    <value>Hochlade-Datum</value>
    269272  </data>
     273  <data name="DECODESettingsTab" xml:space="preserve">
     274    <value>DECODE</value>
     275  </data>
     276  <data name="Password" xml:space="preserve">
     277    <value>Passwort:</value>
     278  </data>
     279  <data name="Username" xml:space="preserve">
     280    <value>Benutzername:</value>
     281  </data>
     282  <data name="TestLoginData" xml:space="preserve">
     283    <value>Login-Daten testen:</value>
     284  </data>
     285  <data name="UseLoginData" xml:space="preserve">
     286    <value>Anmeldedaten verwenden:</value>
     287  </data>
    270288</root>
  • trunk/CrypPlugins/DECODEDatabaseTools/Properties/Resources.resx

    r7891 r8120  
    169169    <value>DECODE record (data set) in json format</value>
    170170  </data>
     171  <data name="DECODESettingsTab" xml:space="preserve">
     172    <value>DECODE</value>
     173  </data>
    171174  <data name="DecodeViewerPluginCaption" xml:space="preserve">
    172175    <value>DECODE Viewer</value>
     
    175178    <value>Component to view data from the DECODE database</value>
    176179  </data>
     180  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
     181  <data name="DECODE_message" type="System.Resources.ResXFileRef, System.Windows.Forms">
     182    <value>..\decode_message.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
     183  </data>
    177184  <data name="Documents" xml:space="preserve">
    178185    <value>Documents:</value>
     
    193200    <value>Images:</value>
    194201  </data>
     202  <data name="image_not_available_for_download" xml:space="preserve">
     203    <value>The creator of this record has chosen to not make this image available for download.</value>
     204  </data>
    195205  <data name="InkType" xml:space="preserve">
    196206    <value>Ink Type:</value>
     
    268278    <value>Upload date</value>
    269279  </data>
     280  <data name="Password" xml:space="preserve">
     281    <value>Password:</value>
     282  </data>
     283  <data name="Username" xml:space="preserve">
     284    <value>Username:</value>
     285  </data>
     286  <data name="TestLoginData" xml:space="preserve">
     287    <value>Test login data</value>
     288  </data>
     289  <data name="UseLoginData" xml:space="preserve">
     290    <value>Use login data:</value>
     291  </data>
    270292</root>
  • trunk/CrypPlugins/DECODEDatabaseTools/Properties/Resources.ru.resx

    r7891 r8120  
    193193    <value>Изображений:</value>
    194194  </data>
     195  <data name="image_not_available_for_download" xml:space="preserve">
     196    <value>Создатель этой записи решил не делать это изображение доступным для загрузки.</value>
     197  </data>
    195198  <data name="InkType" xml:space="preserve">
    196199    <value>Тип чернил:</value>
     
    268271    <value>Дата загрузки</value>
    269272  </data>
     273  <data name="DECODESettingsTab" xml:space="preserve">
     274    <value>DECODE</value>
     275  </data>
     276  <data name="Password" xml:space="preserve">
     277    <value>пароль:</value>
     278  </data>
     279  <data name="Username" xml:space="preserve">
     280    <value>Имя пользователя:</value>
     281  </data>
     282  <data name="TestLoginData" xml:space="preserve">
     283    <value>Проверьте данные для входа:</value>
     284  </data>
     285  <data name="UseLoginData" xml:space="preserve">
     286    <value>Используйте данные для входа:</value>
     287  </data>
    270288</root>
Note: See TracChangeset for help on using the changeset viewer.