XxnCHmwa

1// Decompiled with JetBrains decompiler
2// Type: KairosPlanet.Properties.Resources
3// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6
7using System.CodeDom.Compiler;
8using System.ComponentModel;
9using System.Diagnostics;
10using System.Globalization;
11using System.Resources;
12using System.Runtime.CompilerServices;
13
14namespace KairosPlanet.Properties
15{
16  [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
17  [DebuggerNonUserCode]
18  [CompilerGenerated]
19  public class Resources
20  {
21    private static ResourceManager resourceMan;
22    private static CultureInfo resourceCulture;
23
24    [EditorBrowsable(EditorBrowsableState.Advanced)]
25    public static ResourceManager ResourceManager
26    {
27      get
28      {
29        if (object.ReferenceEquals((object) Resources.resourceMan, (object) null))
30          Resources.resourceMan = new ResourceManager("KairosPlanet.Properties.Resources", typeof (Resources).Assembly);
31        return Resources.resourceMan;
32      }
33    }
34
35    [EditorBrowsable(EditorBrowsableState.Advanced)]
36    public static CultureInfo Culture
37    {
38      get
39      {
40        return Resources.resourceCulture;
41      }
42      set
43      {
44        Resources.resourceCulture = value;
45      }
46    }
47
48    public static string ActivationError_TryReinstallModule
49    {
50      get
51      {
52        return Resources.ResourceManager.GetString("ActivationError_TryReinstallModule", Resources.resourceCulture);
53      }
54    }
55
56    public static string Cancel
57    {
58      get
59      {
60        return Resources.ResourceManager.GetString("Cancel", Resources.resourceCulture);
61      }
62    }
63
64    public static string ChangePasswordUC_ChangePasswordButtonContent
65    {
66      get
67      {
68        return Resources.ResourceManager.GetString("ChangePasswordUC_ChangePasswordButtonContent", Resources.resourceCulture);
69      }
70    }
71
72    public static string ChangePasswordUC_ConfirmNewPasswordTitle
73    {
74      get
75      {
76        return Resources.ResourceManager.GetString("ChangePasswordUC_ConfirmNewPasswordTitle", Resources.resourceCulture);
77      }
78    }
79
80    public static string ChangePasswordUC_CurrentPasswordTitle
81    {
82      get
83      {
84        return Resources.ResourceManager.GetString("ChangePasswordUC_CurrentPasswordTitle", Resources.resourceCulture);
85      }
86    }
87
88    public static string ChangePasswordUC_NewPasswordTitle
89    {
90      get
91      {
92        return Resources.ResourceManager.GetString("ChangePasswordUC_NewPasswordTitle", Resources.resourceCulture);
93      }
94    }
95
96    public static string ChangePasswordUC_Title
97    {
98      get
99      {
100        return Resources.ResourceManager.GetString("ChangePasswordUC_Title", Resources.resourceCulture);
101      }
102    }
103
104    public static string ContactInformationUC_AddressTitle
105    {
106      get
107      {
108        return Resources.ResourceManager.GetString("ContactInformationUC_AddressTitle", Resources.resourceCulture);
109      }
110    }
111
112    public static string ContactInformationUC_CityTitle
113    {
114      get
115      {
116        return Resources.ResourceManager.GetString("ContactInformationUC_CityTitle", Resources.resourceCulture);
117      }
118    }
119
120    public static string ContactInformationUC_Email1Title
121    {
122      get
123      {
124        return Resources.ResourceManager.GetString("ContactInformationUC_Email1Title", Resources.resourceCulture);
125      }
126    }
127
128    public static string ContactInformationUC_Email2Title
129    {
130      get
131      {
132        return Resources.ResourceManager.GetString("ContactInformationUC_Email2Title", Resources.resourceCulture);
133      }
134    }
135
136    public static string ContactInformationUC_Telephone1Title
137    {
138      get
139      {
140        return Resources.ResourceManager.GetString("ContactInformationUC_Telephone1Title", Resources.resourceCulture);
141      }
142    }
143
144    public static string ContactInformationUC_Telephone2Title
145    {
146      get
147      {
148        return Resources.ResourceManager.GetString("ContactInformationUC_Telephone2Title", Resources.resourceCulture);
149      }
150    }
151
152    public static string ContactInformationUC_Title
153    {
154      get
155      {
156        return Resources.ResourceManager.GetString("ContactInformationUC_Title", Resources.resourceCulture);
157      }
158    }
159
160    public static string ContactInformationUC_ZipCodeTitle
161    {
162      get
163      {
164        return Resources.ResourceManager.GetString("ContactInformationUC_ZipCodeTitle", Resources.resourceCulture);
165      }
166    }
167
168    public static string Error
169    {
170      get
171      {
172        return Resources.ResourceManager.GetString("Error", Resources.resourceCulture);
173      }
174    }
175
176    public static string Error_ConfirmNewPasswordIsEmpty
177    {
178      get
179      {
180        return Resources.ResourceManager.GetString("Error_ConfirmNewPasswordIsEmpty", Resources.resourceCulture);
181      }
182    }
183
184    public static string Error_ConnectionError
185    {
186      get
187      {
188        return Resources.ResourceManager.GetString("Error_ConnectionError", Resources.resourceCulture);
189      }
190    }
191
192    public static string Error_EmailIsEmpty
193    {
194      get
195      {
196        return Resources.ResourceManager.GetString("Error_EmailIsEmpty", Resources.resourceCulture);
197      }
198    }
199
200    public static string Error_EnterCurrentPasswordToChange
201    {
202      get
203      {
204        return Resources.ResourceManager.GetString("Error_EnterCurrentPasswordToChange", Resources.resourceCulture);
205      }
206    }
207
208    public static string Error_NewPasswordIsEmpty
209    {
210      get
211      {
212        return Resources.ResourceManager.GetString("Error_NewPasswordIsEmpty", Resources.resourceCulture);
213      }
214    }
215
216    public static string Error_PasswordIsEmpty
217    {
218      get
219      {
220        return Resources.ResourceManager.GetString("Error_PasswordIsEmpty", Resources.resourceCulture);
221      }
222    }
223
224    public static string Error_PasswordOrEmailInvalid
225    {
226      get
227      {
228        return Resources.ResourceManager.GetString("Error_PasswordOrEmailInvalid", Resources.resourceCulture);
229      }
230    }
231
232    public static string Error_PasswordsNotIdentical
233    {
234      get
235      {
236        return Resources.ResourceManager.GetString("Error_PasswordsNotIdentical", Resources.resourceCulture);
237      }
238    }
239
240    public static string Error_ServerReturnIncorrectData
241    {
242      get
243      {
244        return Resources.ResourceManager.GetString("Error_ServerReturnIncorrectData", Resources.resourceCulture);
245      }
246    }
247
248    public static string Error_UserDeletedError
249    {
250      get
251      {
252        return Resources.ResourceManager.GetString("Error_UserDeletedError", Resources.resourceCulture);
253      }
254    }
255
256    public static string Error_UserPasswordIncorrect
257    {
258      get
259      {
260        return Resources.ResourceManager.GetString("Error_UserPasswordIncorrect", Resources.resourceCulture);
261      }
262    }
263
264    public static string FemaleGender
265    {
266      get
267      {
268        return Resources.ResourceManager.GetString("FemaleGender", Resources.resourceCulture);
269      }
270    }
271
272    public static string InformationNotSpecified
273    {
274      get
275      {
276        return Resources.ResourceManager.GetString("InformationNotSpecified", Resources.resourceCulture);
277      }
278    }
279
280    public static string LoginUC_AutoLoginTitle
281    {
282      get
283      {
284        return Resources.ResourceManager.GetString("LoginUC_AutoLoginTitle", Resources.resourceCulture);
285      }
286    }
287
288    public static string LoginUC_LoginBtn
289    {
290      get
291      {
292        return Resources.ResourceManager.GetString("LoginUC_LoginBtn", Resources.resourceCulture);
293      }
294    }
295
296    public static string LoginUC_RecoverPasswordHyperLink
297    {
298      get
299      {
300        return Resources.ResourceManager.GetString("LoginUC_RecoverPasswordHyperLink", Resources.resourceCulture);
301      }
302    }
303
304    public static string LoginUC_RegisterBtn
305    {
306      get
307      {
308        return Resources.ResourceManager.GetString("LoginUC_RegisterBtn", Resources.resourceCulture);
309      }
310    }
311
312    public static string MainMenu_Profile
313    {
314      get
315      {
316        return Resources.ResourceManager.GetString("MainMenu_Profile", Resources.resourceCulture);
317      }
318    }
319
320    public static string MainMenu_ProfileContact
321    {
322      get
323      {
324        return Resources.ResourceManager.GetString("MainMenu_ProfileContact", Resources.resourceCulture);
325      }
326    }
327
328    public static string MainMenu_ProfilePassword
329    {
330      get
331      {
332        return Resources.ResourceManager.GetString("MainMenu_ProfilePassword", Resources.resourceCulture);
333      }
334    }
335
336    public static string MainMenu_ProfilePersonal
337    {
338      get
339      {
340        return Resources.ResourceManager.GetString("MainMenu_ProfilePersonal", Resources.resourceCulture);
341      }
342    }
343
344    public static string MainMenu_ServiceCategories
345    {
346      get
347      {
348        return Resources.ResourceManager.GetString("MainMenu_ServiceCategories", Resources.resourceCulture);
349      }
350    }
351
352    public static string MainMenu_Services
353    {
354      get
355      {
356        return Resources.ResourceManager.GetString("MainMenu_Services", Resources.resourceCulture);
357      }
358    }
359
360    public static string MainMenu_SessionHistory
361    {
362      get
363      {
364        return Resources.ResourceManager.GetString("MainMenu_SessionHistory", Resources.resourceCulture);
365      }
366    }
367
368    public static string MainMenu_Settings
369    {
370      get
371      {
372        return Resources.ResourceManager.GetString("MainMenu_Settings", Resources.resourceCulture);
373      }
374    }
375
376    public static string MainMenu_Statistics
377    {
378      get
379      {
380        return Resources.ResourceManager.GetString("MainMenu_Statistics", Resources.resourceCulture);
381      }
382    }
383
384    public static string MainMenu_StatisticsSummary
385    {
386      get
387      {
388        return Resources.ResourceManager.GetString("MainMenu_StatisticsSummary", Resources.resourceCulture);
389      }
390    }
391
392    public static string MainWindow_Exit
393    {
394      get
395      {
396        return Resources.ResourceManager.GetString("MainWindow_Exit", Resources.resourceCulture);
397      }
398    }
399
400    public static string MainWindow_LogOut
401    {
402      get
403      {
404        return Resources.ResourceManager.GetString("MainWindow_LogOut", Resources.resourceCulture);
405      }
406    }
407
408    public static string MainWindow_Open
409    {
410      get
411      {
412        return Resources.ResourceManager.GetString("MainWindow_Open", Resources.resourceCulture);
413      }
414    }
415
416    public static string MaleGender
417    {
418      get
419      {
420        return Resources.ResourceManager.GetString("MaleGender", Resources.resourceCulture);
421      }
422    }
423
424    public static string Message_NewPackageIsAvailable
425    {
426      get
427      {
428        return Resources.ResourceManager.GetString("Message_NewPackageIsAvailable", Resources.resourceCulture);
429      }
430    }
431
432    public static string NetworkState_None
433    {
434      get
435      {
436        return Resources.ResourceManager.GetString("NetworkState_None", Resources.resourceCulture);
437      }
438    }
439
440    public static string NetworkState_Offline
441    {
442      get
443      {
444        return Resources.ResourceManager.GetString("NetworkState_Offline", Resources.resourceCulture);
445      }
446    }
447
448    public static string NetworkState_Online
449    {
450      get
451      {
452        return Resources.ResourceManager.GetString("NetworkState_Online", Resources.resourceCulture);
453      }
454    }
455
456    public static string PersonalInformationUC_BirthDateTitle
457    {
458      get
459      {
460        return Resources.ResourceManager.GetString("PersonalInformationUC_BirthDateTitle", Resources.resourceCulture);
461      }
462    }
463
464    public static string PersonalInformationUC_CountryTitle
465    {
466      get
467      {
468        return Resources.ResourceManager.GetString("PersonalInformationUC_CountryTitle", Resources.resourceCulture);
469      }
470    }
471
472    public static string PersonalInformationUC_CreationDateTitle
473    {
474      get
475      {
476        return Resources.ResourceManager.GetString("PersonalInformationUC_CreationDateTitle", Resources.resourceCulture);
477      }
478    }
479
480    public static string PersonalInformationUC_EmailTitle
481    {
482      get
483      {
484        return Resources.ResourceManager.GetString("PersonalInformationUC_EmailTitle", Resources.resourceCulture);
485      }
486    }
487
488    public static string PersonalInformationUC_GenderTitle
489    {
490      get
491      {
492        return Resources.ResourceManager.GetString("PersonalInformationUC_GenderTitle", Resources.resourceCulture);
493      }
494    }
495
496    public static string PersonalInformationUC_NameTitle
497    {
498      get
499      {
500        return Resources.ResourceManager.GetString("PersonalInformationUC_NameTitle", Resources.resourceCulture);
501      }
502    }
503
504    public static string PersonalInformationUC_TelephoneTitle
505    {
506      get
507      {
508        return Resources.ResourceManager.GetString("PersonalInformationUC_TelephoneTitle", Resources.resourceCulture);
509      }
510    }
511
512    public static string PersonalInformationUC_Title
513    {
514      get
515      {
516        return Resources.ResourceManager.GetString("PersonalInformationUC_Title", Resources.resourceCulture);
517      }
518    }
519
520    public static string PersonalInformationUC_UserStatusTitle
521    {
522      get
523      {
524        return Resources.ResourceManager.GetString("PersonalInformationUC_UserStatusTitle", Resources.resourceCulture);
525      }
526    }
527
528    public static string Refresh_NewPackage
529    {
530      get
531      {
532        return Resources.ResourceManager.GetString("Refresh_NewPackage", Resources.resourceCulture);
533      }
534    }
535
536    public static string Save
537    {
538      get
539      {
540        return Resources.ResourceManager.GetString("Save", Resources.resourceCulture);
541      }
542    }
543
544    public static string SaveEditButton_Edit
545    {
546      get
547      {
548        return Resources.ResourceManager.GetString("SaveEditButton_Edit", Resources.resourceCulture);
549      }
550    }
551
552    public static string SaveEditButton_Save
553    {
554      get
555      {
556        return Resources.ResourceManager.GetString("SaveEditButton_Save", Resources.resourceCulture);
557      }
558    }
559
560    public static string ScreenManager_ModuleInstalled
561    {
562      get
563      {
564        return Resources.ResourceManager.GetString("ScreenManager_ModuleInstalled", Resources.resourceCulture);
565      }
566    }
567
568    public static string ScreenManager_Success
569    {
570      get
571      {
572        return Resources.ResourceManager.GetString("ScreenManager_Success", Resources.resourceCulture);
573      }
574    }
575
576    public static string ServicesUC_BackHyperLink
577    {
578      get
579      {
580        return Resources.ResourceManager.GetString("ServicesUC_BackHyperLink", Resources.resourceCulture);
581      }
582    }
583
584    public static string ServicesVM_ProductDescriptionFileName
585    {
586      get
587      {
588        return Resources.ResourceManager.GetString("ServicesVM_ProductDescriptionFileName", Resources.resourceCulture);
589      }
590    }
591
592    public static string ServiceVM_Activate
593    {
594      get
595      {
596        return Resources.ResourceManager.GetString("ServiceVM_Activate", Resources.resourceCulture);
597      }
598    }
599
600    public static string ServiceVM_Buy
601    {
602      get
603      {
604        return Resources.ResourceManager.GetString("ServiceVM_Buy", Resources.resourceCulture);
605      }
606    }
607
608    public static string ServiceVM_Details
609    {
610      get
611      {
612        return Resources.ResourceManager.GetString("ServiceVM_Details", Resources.resourceCulture);
613      }
614    }
615
616    public static string ServiceVM_Install
617    {
618      get
619      {
620        return Resources.ResourceManager.GetString("ServiceVM_Install", Resources.resourceCulture);
621      }
622    }
623
624    public static string ServiceVM_Order
625    {
626      get
627      {
628        return Resources.ResourceManager.GetString("ServiceVM_Order", Resources.resourceCulture);
629      }
630    }
631
632    public static string SessionHistoryUC_Date
633    {
634      get
635      {
636        return Resources.ResourceManager.GetString("SessionHistoryUC_Date", Resources.resourceCulture);
637      }
638    }
639
640    public static string SessionHistoryUC_DateAxis
641    {
642      get
643      {
644        return Resources.ResourceManager.GetString("SessionHistoryUC_DateAxis", Resources.resourceCulture);
645      }
646    }
647
648    public static string SessionHistoryUC_Duration
649    {
650      get
651      {
652        return Resources.ResourceManager.GetString("SessionHistoryUC_Duration", Resources.resourceCulture);
653      }
654    }
655
656    public static string SessionHistoryUC_DurationAxis
657    {
658      get
659      {
660        return Resources.ResourceManager.GetString("SessionHistoryUC_DurationAxis", Resources.resourceCulture);
661      }
662    }
663
664    public static string SessionHistoryUC_EmtyChartMessage
665    {
666      get
667      {
668        return Resources.ResourceManager.GetString("SessionHistoryUC_EmtyChartMessage", Resources.resourceCulture);
669      }
670    }
671
672    public static string SessionHistoryUC_EndTime
673    {
674      get
675      {
676        return Resources.ResourceManager.GetString("SessionHistoryUC_EndTime", Resources.resourceCulture);
677      }
678    }
679
680    public static string SessionHistoryUC_PeriodFrom
681    {
682      get
683      {
684        return Resources.ResourceManager.GetString("SessionHistoryUC_PeriodFrom", Resources.resourceCulture);
685      }
686    }
687
688    public static string SessionHistoryUC_PeriodTo
689    {
690      get
691      {
692        return Resources.ResourceManager.GetString("SessionHistoryUC_PeriodTo", Resources.resourceCulture);
693      }
694    }
695
696    public static string SessionHistoryUC_SessionHistory
697    {
698      get
699      {
700        return Resources.ResourceManager.GetString("SessionHistoryUC_SessionHistory", Resources.resourceCulture);
701      }
702    }
703
704    public static string SessionHistoryUC_ShowPeriod
705    {
706      get
707      {
708        return Resources.ResourceManager.GetString("SessionHistoryUC_ShowPeriod", Resources.resourceCulture);
709      }
710    }
711
712    public static string SessionHistoryUC_StartTime
713    {
714      get
715      {
716        return Resources.ResourceManager.GetString("SessionHistoryUC_StartTime", Resources.resourceCulture);
717      }
718    }
719
720    public static string SessionHistoryUC_Total
721    {
722      get
723      {
724        return Resources.ResourceManager.GetString("SessionHistoryUC_Total", Resources.resourceCulture);
725      }
726    }
727
728    public static string SessionStatisticsUC_CurrentMonthTitle
729    {
730      get
731      {
732        return Resources.ResourceManager.GetString("SessionStatisticsUC_CurrentMonthTitle", Resources.resourceCulture);
733      }
734    }
735
736    public static string SessionStatisticsUC_CurrentSessionNonActive
737    {
738      get
739      {
740        return Resources.ResourceManager.GetString("SessionStatisticsUC_CurrentSessionNonActive", Resources.resourceCulture);
741      }
742    }
743
744    public static string SessionStatisticsUC_CurrentSessionTitle
745    {
746      get
747      {
748        return Resources.ResourceManager.GetString("SessionStatisticsUC_CurrentSessionTitle", Resources.resourceCulture);
749      }
750    }
751
752    public static string SessionStatisticsUC_LastMonthTitle
753    {
754      get
755      {
756        return Resources.ResourceManager.GetString("SessionStatisticsUC_LastMonthTitle", Resources.resourceCulture);
757      }
758    }
759
760    public static string SessionStatisticsUC_RetrievingDataFromServerText
761    {
762      get
763      {
764        return Resources.ResourceManager.GetString("SessionStatisticsUC_RetrievingDataFromServerText", Resources.resourceCulture);
765      }
766    }
767
768    public static string SessionStatisticsUC_TimeLeftToEarnMoney
769    {
770      get
771      {
772        return Resources.ResourceManager.GetString("SessionStatisticsUC_TimeLeftToEarnMoney", Resources.resourceCulture);
773      }
774    }
775
776    public static string SessionStatisticsUC_TimeOnline
777    {
778      get
779      {
780        return Resources.ResourceManager.GetString("SessionStatisticsUC_TimeOnline", Resources.resourceCulture);
781      }
782    }
783
784    public static string SessionStatisticsUC_Title
785    {
786      get
787      {
788        return Resources.ResourceManager.GetString("SessionStatisticsUC_Title", Resources.resourceCulture);
789      }
790    }
791
792    public static string SessionStatisticsUC_TodayTitle
793    {
794      get
795      {
796        return Resources.ResourceManager.GetString("SessionStatisticsUC_TodayTitle", Resources.resourceCulture);
797      }
798    }
799
800    public static string SessionStatisticsUC_TotalTitle
801    {
802      get
803      {
804        return Resources.ResourceManager.GetString("SessionStatisticsUC_TotalTitle", Resources.resourceCulture);
805      }
806    }
807
808    public static string SessionStatisticsUC_YesterdayTitle
809    {
810      get
811      {
812        return Resources.ResourceManager.GetString("SessionStatisticsUC_YesterdayTitle", Resources.resourceCulture);
813      }
814    }
815
816    public static string Settings
817    {
818      get
819      {
820        return Resources.ResourceManager.GetString("Settings", Resources.resourceCulture);
821      }
822    }
823
824    public static string SettingsUC_ConnectionMethod_Title
825    {
826      get
827      {
828        return Resources.ResourceManager.GetString("SettingsUC_ConnectionMethod_Title", Resources.resourceCulture);
829      }
830    }
831
832    public static string SettingsUC_ICMPUsed
833    {
834      get
835      {
836        return Resources.ResourceManager.GetString("SettingsUC_ICMPUsed", Resources.resourceCulture);
837      }
838    }
839
840    public static string SettingsUC_IsAutoLoginTitle
841    {
842      get
843      {
844        return Resources.ResourceManager.GetString("SettingsUC_IsAutoLoginTitle", Resources.resourceCulture);
845      }
846    }
847
848    public static string SettingsUC_IsHttpiPingUsed_Inner
849    {
850      get
851      {
852        return Resources.ResourceManager.GetString("SettingsUC_IsHttpiPingUsed_Inner", Resources.resourceCulture);
853      }
854    }
855
856    public static string SettingsUC_LanguageSelectedText
857    {
858      get
859      {
860        return Resources.ResourceManager.GetString("SettingsUC_LanguageSelectedText", Resources.resourceCulture);
861      }
862    }
863
864    public static string SettingsUC_LanguageTitle
865    {
866      get
867      {
868        return Resources.ResourceManager.GetString("SettingsUC_LanguageTitle", Resources.resourceCulture);
869      }
870    }
871
872    public static string SettingsUC_RestartNow
873    {
874      get
875      {
876        return Resources.ResourceManager.GetString("SettingsUC_RestartNow", Resources.resourceCulture);
877      }
878    }
879
880    public static string SettingsUC_RunOnStartUpTitle
881    {
882      get
883      {
884        return Resources.ResourceManager.GetString("SettingsUC_RunOnStartUpTitle", Resources.resourceCulture);
885      }
886    }
887
888    public static string StatusMessage_CanNotLoadServices
889    {
890      get
891      {
892        return Resources.ResourceManager.GetString("StatusMessage_CanNotLoadServices", Resources.resourceCulture);
893      }
894    }
895
896    public static string StatusMessage_IsRefreshing
897    {
898      get
899      {
900        return Resources.ResourceManager.GetString("StatusMessage_IsRefreshing", Resources.resourceCulture);
901      }
902    }
903
904    public static string StatusMessage_NoNewPurchases
905    {
906      get
907      {
908        return Resources.ResourceManager.GetString("StatusMessage_NoNewPurchases", Resources.resourceCulture);
909      }
910    }
911
912    public static string StatusMessage_ServicesLoading
913    {
914      get
915      {
916        return Resources.ResourceManager.GetString("StatusMessage_ServicesLoading", Resources.resourceCulture);
917      }
918    }
919
920    public static string StatusMessage_TryActivateKeyRefresh
921    {
922      get
923      {
924        return Resources.ResourceManager.GetString("StatusMessage_TryActivateKeyRefresh", Resources.resourceCulture);
925      }
926    }
927
928    public static string Tray_LogIn
929    {
930      get
931      {
932        return Resources.ResourceManager.GetString("Tray_LogIn", Resources.resourceCulture);
933      }
934    }
935
936    public static string Tray_LogOut
937    {
938      get
939      {
940        return Resources.ResourceManager.GetString("Tray_LogOut", Resources.resourceCulture);
941      }
942    }
943
944    public static string Tray_ModuleCrashOrNotFoundMainFiledMessage
945    {
946      get
947      {
948        return Resources.ResourceManager.GetString("Tray_ModuleCrashOrNotFoundMainFiledMessage", Resources.resourceCulture);
949      }
950    }
951
952    public static string Tray_ModuleNotInstalledMessage
953    {
954      get
955      {
956        return Resources.ResourceManager.GetString("Tray_ModuleNotInstalledMessage", Resources.resourceCulture);
957      }
958    }
959
960    public static string Tray_NotificationTitle
961    {
962      get
963      {
964        return Resources.ResourceManager.GetString("Tray_NotificationTitle", Resources.resourceCulture);
965      }
966    }
967
968    public static string User_EmailTitle
969    {
970      get
971      {
972        return Resources.ResourceManager.GetString("User_EmailTitle", Resources.resourceCulture);
973      }
974    }
975
976    public static string User_PasswordTitle
977    {
978      get
979      {
980        return Resources.ResourceManager.GetString("User_PasswordTitle", Resources.resourceCulture);
981      }
982    }
983
984    public static string VersionUC_CurrentVersionCaption
985    {
986      get
987      {
988        return Resources.ResourceManager.GetString("VersionUC_CurrentVersionCaption", Resources.resourceCulture);
989      }
990    }
991
992    public static string VersionUC_DownloadNewAppVersion
993    {
994      get
995      {
996        return Resources.ResourceManager.GetString("VersionUC_DownloadNewAppVersion", Resources.resourceCulture);
997      }
998    }
999
1000    public static string VersionUC_LinkToSiteText
1001    {
1002      get
1003      {
1004        return Resources.ResourceManager.GetString("VersionUC_LinkToSiteText", Resources.resourceCulture);
1005      }
1006    }
1007
1008    public static string VersionUC_NewVersionCaption
1009    {
1010      get
1011      {
1012        return Resources.ResourceManager.GetString("VersionUC_NewVersionCaption", Resources.resourceCulture);
1013      }
1014    }
1015
1016    public static string VersionUC_NewVersionIsAvailable
1017    {
1018      get
1019      {
1020        return Resources.ResourceManager.GetString("VersionUC_NewVersionIsAvailable", Resources.resourceCulture);
1021      }
1022    }
1023
1024    internal Resources()
1025    {
1026    }
1027  }
1028}
1029?// Decompiled with JetBrains decompiler
1030// Type: KairosPlanet.Properties.Settings
1031// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1032// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1033// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1034
1035using System.CodeDom.Compiler;
1036using System.Configuration;
1037using System.Runtime.CompilerServices;
1038
1039namespace KairosPlanet.Properties
1040{
1041  [GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "12.0.0.0")]
1042  [CompilerGenerated]
1043  internal sealed class Settings : ApplicationSettingsBase
1044  {
1045    private static Settings defaultInstance = (Settings) SettingsBase.Synchronized((SettingsBase) new Settings());
1046
1047    public static Settings Default
1048    {
1049      get
1050      {
1051        return Settings.defaultInstance;
1052      }
1053    }
1054  }
1055}
1056?// Decompiled with JetBrains decompiler
1057// Type: KairosPlanet.ModuleErrorState
1058// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1059// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1060// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1061
1062namespace KairosPlanet
1063{
1064  internal enum ModuleErrorState
1065  {
1066    NoError,
1067    CrashOrNotFoundMainFile,
1068    ModuleNotInstalledMessage,
1069  }
1070}
1071?// Decompiled with JetBrains decompiler
1072// Type: KairosPlanet.Managers.Data.PurchaseManager
1073// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1074// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1075// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1076
1077using Inc.Logging;
1078using IncMap;
1079using KairosPlanet.Managers.Interfaces;
1080using KairosPlanet.Properties;
1081using System;
1082using System.Collections.Generic;
1083using System.Collections.ObjectModel;
1084using System.Linq;
1085using WinApp.Data.Model;
1086using WinApp.Managers.Interfaces;
1087using WinApp.Module;
1088using WinApp.Service.Repository.Interface;
1089
1090namespace KairosPlanet.Managers.Data
1091{
1092  public class PurchaseManager : IPurchaseManager
1093  {
1094    private ObservableCollection<Purchase> _currentPurchases;
1095    private bool _needUpdate;
1096
1097    public ObservableCollection<Purchase> Purchases
1098    {
1099      get
1100      {
1101        if (this._currentPurchases == null)
1102          this._currentPurchases = new ObservableCollection<Purchase>();
1103        if (this._needUpdate)
1104          this.UpdatePurchases();
1105        return this._currentPurchases;
1106      }
1107    }
1108
1109    public PurchaseManager()
1110    {
1111      this._needUpdate = true;
1112    }
1113
1114    public void UpdatePurchases()
1115    {
1116      Purchase[] purchases = Map.Get<ISessionManager>().GetPurchases();
1117      if (purchases == null)
1118      {
1119        Logger.WriteWarning((object) this, "UpdatePurchases()", "Purchases is not loaded");
1120      }
1121      else
1122      {
1123        this._needUpdate = false;
1124        Logger.WriteInfo((object) this, "UpdatePurchases()", "Loaded purchases count: " + (object) purchases.Length);
1125        List<Purchase> list = Enumerable.ToList<Purchase>((IEnumerable<Purchase>) purchases);
1126        int count = list.Count;
1127        foreach (Purchase purchase in list)
1128          Logger.WriteInfo((object) this, "UpdatePurchases", string.Format("UpdatePurchases(): purchase: ProductId='{0}', PackageStatus='{1}', Status='{2}'", (object) purchase.ProductId, (object) purchase.PackageStatus, (object) purchase.Status));
1129        foreach (Purchase purchase in list)
1130        {
1131          if (!this.Purchases.Contains(purchase))
1132            this.Purchases.Add(purchase);
1133          else
1134            this.Purchases[this.Purchases.IndexOf(purchase)] = purchase;
1135        }
1136      }
1137    }
1138
1139    [Obsolete]
1140    public Purchase[] GetNewPurchases()
1141    {
1142      Purchase[] purchases = Map.Get<ISessionManager>().GetPurchases();
1143      if (purchases == null)
1144      {
1145        Logger.WriteWarning((object) this, "GetNewPurchases()", "Purchases is not loaded");
1146        return (Purchase[]) null;
1147      }
1148      Logger.WriteInfo((object) this, "GetNewPurchases()", "Loaded purchases count: " + (object) purchases.Length);
1149      Purchase[] purchaseArray = Enumerable.ToArray<Purchase>(Enumerable.Where<Purchase>((IEnumerable<Purchase>) purchases, (Func<Purchase, bool>) (x => !this.Purchases.Contains(x))));
1150      if (purchaseArray.Length <= 0)
1151        return new Purchase[0];
1152      return purchaseArray;
1153    }
1154
1155    public bool ActivateModule(Purchase purchase)
1156    {
1157      try
1158      {
1159        if (purchase == null)
1160        {
1161          Logger.WriteError((object) this, "ActivateInstalledModule", "Exit from action of activation: purchase is null");
1162          return false;
1163        }
1164        Logger.WriteInfo((object) this, "ActivateInstalledModule", "Start action of activation");
1165        IModuleResolver moduleResolver = Map.Get<IModuleResolver>();
1166        ModuleInfo moduleInfo = Map.Get<IModuleResolver>().GetModuleInfo(purchase.ProductId);
1167        IModuleManager moduleManager = moduleResolver.GetModuleManager(moduleInfo);
1168        if (moduleManager == null)
1169        {
1170          Logger.WriteError((object) this, "ActivateInstalledModule", "Exit from action of activation: module manager is empty");
1171          return false;
1172        }
1173        Module moduleByProductId = Map.Get<IModuleRepository>().GetModuleByProductId(purchase.ProductId);
1174        if (moduleByProductId.StateEnum != ModuleState.Installed && moduleByProductId.StateEnum != ModuleState.InstalledAndActivated)
1175        {
1176          Logger.WriteError((object) this, "ActivateInstalledModule", "Exit from action of activation: install for module not executed");
1177          return false;
1178        }
1179        Logger.WriteInfo((object) this, "ActivateInstalledModule", "Start activation on server");
1180        string str = Map.Get<ISessionManager>().Activation(purchase.Id);
1181        if (string.IsNullOrEmpty(str))
1182        {
1183          Logger.WriteError((object) this, "ActivateInstalledModule", "Exit from action of activation: security key is not received");
1184          Map.Get<IScreenManager>().ShowStatusMessage(Resources.ActivationError_TryReinstallModule, 5, false);
1185          return false;
1186        }
1187        moduleManager.SetSecurityKey(str, purchase.ProductId, purchase.Id, (IModuleCallback) moduleResolver);
1188        Logger.WriteInfo((object) this, "ActivateInstalledModule", "Activation on server executed");
1189        moduleByProductId.StateEnum = ModuleState.InstalledAndActivated;
1190        Map.Get<IModuleRepository>().Save(moduleByProductId);
1191        Logger.WriteInfo((object) this, "ActivateInstalledModule", string.Format(Resources.ScreenManager_ModuleInstalled, (object) purchase.ProductId));
1192        return true;
1193      }
1194      catch (Exception ex)
1195      {
1196        Logger.WriteError((object) this, "ModuleInstalled", "Activate module after install for product with Id = '" + (object) purchase.ProductId + "' error:", ex);
1197        throw;
1198      }
1199    }
1200  }
1201}
1202?// Decompiled with JetBrains decompiler
1203// Type: KairosPlanet.Managers.StatisticManager
1204// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1205// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1206// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1207
1208using IncMap;
1209using System;
1210using System.Collections.Generic;
1211using System.Linq;
1212using WinApp.Api.Data;
1213using WinApp.Managers.Interfaces;
1214
1215namespace KairosPlanet.Managers
1216{
1217  public class StatisticManager
1218  {
1219    private static object _lockObject = new object();
1220    private int _refreshStatisticminutsInterval = 10;
1221    private static StatisticManager _instance;
1222    private Statistic[] _cachedStatistics;
1223    private DateTime? _gettedStatisticsDate;
1224
1225    public static StatisticManager Instance
1226    {
1227      get
1228      {
1229        if (StatisticManager._instance == null)
1230        {
1231          lock (StatisticManager._lockObject)
1232          {
1233            if (StatisticManager._instance == null)
1234              StatisticManager._instance = new StatisticManager();
1235          }
1236        }
1237        return StatisticManager._instance;
1238      }
1239    }
1240
1241    private StatisticManager()
1242    {
1243    }
1244
1245    public void SetNeedRefreshStatistics()
1246    {
1247      lock (StatisticManager._lockObject)
1248      {
1249        this._cachedStatistics = (Statistic[]) null;
1250        this._gettedStatisticsDate = new DateTime?();
1251      }
1252    }
1253
1254    public Statistic[] GetStatistics()
1255    {
1256      if (!this._gettedStatisticsDate.HasValue || this._gettedStatisticsDate.Value.Subtract(DateTime.Now).Minutes > this._refreshStatisticminutsInterval)
1257      {
1258        lock (StatisticManager._lockObject)
1259        {
1260          if (this._gettedStatisticsDate.HasValue)
1261          {
1262            if (this._gettedStatisticsDate.Value.Subtract(DateTime.Now).Minutes <= this._refreshStatisticminutsInterval)
1263              goto label_6;
1264          }
1265          this._cachedStatistics = Map.Get<ISessionManager>().GetStatistics();
1266          this._gettedStatisticsDate = this._cachedStatistics == null ? new DateTime?() : new DateTime?(DateTime.Now);
1267        }
1268      }
1269label_6:
1270      return this._cachedStatistics;
1271    }
1272
1273    public Statistic[] GetStatistics(DateTime periodStart, DateTime periodEnd)
1274    {
1275      return Enumerable.ToArray<Statistic>(Enumerable.Where<Statistic>((IEnumerable<Statistic>) this.GetStatistics(), (Func<Statistic, bool>) (s =>
1276      {
1277        if (s.CreatedDate >= periodStart)
1278          return s.CreatedDate.AddSeconds((double) s.Lifetime) <= periodEnd;
1279        return false;
1280      })));
1281    }
1282  }
1283}
1284?// Decompiled with JetBrains decompiler
1285// Type: KairosPlanet.Managers.Interfaces.IPurchaseManager
1286// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1287// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1288// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1289
1290using System;
1291using System.Collections.ObjectModel;
1292using WinApp.Data.Model;
1293
1294namespace KairosPlanet.Managers.Interfaces
1295{
1296  internal interface IPurchaseManager
1297  {
1298    ObservableCollection<Purchase> Purchases { get; }
1299
1300    void UpdatePurchases();
1301
1302    [Obsolete]
1303    Purchase[] GetNewPurchases();
1304
1305    bool ActivateModule(Purchase purchase);
1306  }
1307}
1308?// Decompiled with JetBrains decompiler
1309// Type: KairosPlanet.Managers.Network.SessionMonitor
1310// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1311// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1312// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1313
1314using Inc.Logging;
1315using IncMap;
1316using KairosPlanet;
1317using KairosPlanet.Managers.Interfaces;
1318using KairosPlanet.Properties;
1319using System;
1320using System.Collections.Generic;
1321using System.Linq;
1322using System.Timers;
1323using WinApp;
1324using WinApp.Api;
1325using WinApp.Api.Data;
1326using WinApp.Data.Model;
1327using WinApp.Managers;
1328using WinApp.Managers.Interfaces;
1329using WinApp.Managers.Network;
1330using WinApp.Service.Repository.Interface;
1331using WinApp.Tray.RichNotifyIcon;
1332using WinApp.ViewModel;
1333
1334namespace KairosPlanet.Managers.Network
1335{
1336  public class SessionMonitor
1337  {
1338    private static SessionMonitor _instance = new SessionMonitor();
1339    private static bool _showedTrayMessage = false;
1340    private SessionState _sessionState;
1341    private Timer _sessionMonitorTimer;
1342    private string _activeModuleSecureKey;
1343    private bool _secondAttempt;
1344
1345    public static SessionMonitor Instance
1346    {
1347      get
1348      {
1349        return SessionMonitor._instance;
1350      }
1351    }
1352
1353    public PingResponse FirstSessionPing { get; set; }
1354
1355    internal SessionState SessionState
1356    {
1357      get
1358      {
1359        return this._sessionState;
1360      }
1361      private set
1362      {
1363        if (this._sessionState == value)
1364          return;
1365        this._sessionState = value;
1366        Logger.WriteInfo((object) this, "SessionState", "SessionState changed status on '" + (object) this._sessionState + "'");
1367        if (this.SessionStateChanged == null)
1368          return;
1369        this.SessionStateChanged((object) this, new SessionStateEventArgs(value));
1370      }
1371    }
1372
1373    internal event EventHandler<SessionStateEventArgs> SessionStateChanged;
1374
1375    internal event SessionMonitor.PingEventHandler PingEvent;
1376
1377    private SessionMonitor()
1378    {
1379    }
1380
1381    public bool PingSession()
1382    {
1383      try
1384      {
1385        PingResponse pingResponse = Map.Get<ISessionManager>().PingSession(this._activeModuleSecureKey);
1386        if (pingResponse != null)
1387          this.InvokePingEvent(pingResponse.Lifetime);
1388        if (pingResponse != null)
1389          this.FirstSessionPing = pingResponse;
1390        return pingResponse != null;
1391      }
1392      catch (ApiException ex)
1393      {
1394        if (string.Equals(ex.StatusDescription, "Secret key not found"))
1395          this.TryGetNewSecureKey();
1396        else
1397          Logger.WriteError((object) this, "PingSession()", "Error during operation Ping on SessionMonitor", (Exception) ex);
1398        return false;
1399      }
1400      catch (Exception ex)
1401      {
1402        Logger.WriteError((object) this, "PingSession()", "Error during operation Ping on SessionMonitor", ex);
1403        return false;
1404      }
1405    }
1406
1407    public void InvokePingEvent(long lifeTime)
1408    {
1409      if (this.PingEvent == null)
1410        return;
1411      this.PingEvent((object) this, new PingEventArgs(lifeTime));
1412    }
1413
1414    internal void SetSessionStateToLogon()
1415    {
1416      NetworkMonitor.NetworkStateChanged -= new EventHandler<NetworkStateEventArgs>(this.OnNetworkStateChanged);
1417      NetworkMonitor.NetworkStateChanged += new EventHandler<NetworkStateEventArgs>(this.OnNetworkStateChanged);
1418      if (Map.Get<ISessionManager>().CurrentUser != null)
1419      {
1420        this.SessionState = SessionState.LogOn;
1421        this.TryChangeStateToAccrual();
1422      }
1423      else
1424      {
1425        Logger.WriteInfo((object) this, "SetSessionStateToLogon()", "??????? ?????? ?? ???? ??????? ? ????????? LogOn, ??? ??? ???????????? ???????????");
1426        this.SessionState = SessionState.LogOff;
1427      }
1428    }
1429
1430    internal void SetSessionStateToSuspended()
1431    {
1432      this.SessionState = SessionState.Suspended;
1433      NetworkMonitor.CheckServerOn(true);
1434    }
1435
1436    private static bool GetPackageModuleIsActive()
1437    {
1438      if (!AppVM.Instance.ActivePackageId.HasValue)
1439        return false;
1440      Module moduleByProductId = Map.Get<IModuleRepository>().GetModuleByProductId(AppVM.Instance.ActivePackageId.Value);
1441      return moduleByProductId != null && moduleByProductId.StateEnum == ModuleState.InstalledAndActivated;
1442    }
1443
1444    private void TryChangeStateToAccrual()
1445    {
1446      if (!AppVM.Instance.ActivePackageId.HasValue || AppVM.Instance.ActivePackageId.Value == 0L)
1447      {
1448        Logger.WriteWarning((object) this, "CheckActivePackageToAccrual", "??????? ??? ??????????? ?????????? ?? ???????????. ??? ????????? ??????.");
1449        AppVM.Instance.ModuleErrorState = ModuleErrorState.ModuleNotInstalledMessage;
1450        if (SessionMonitor._showedTrayMessage)
1451          return;
1452        ((TaskbarIcon) Map.Get<IAppTray>()).ShowBalloonTip(Resources.Tray_NotificationTitle, Resources.Tray_ModuleNotInstalledMessage, BalloonIcon.Info);
1453        SessionMonitor._showedTrayMessage = true;
1454      }
1455      else
1456      {
1457        this.SessionState = SessionState.Suspended;
1458        if (!SessionMonitor.GetPackageModuleIsActive())
1459        {
1460          Logger.WriteError((object) this, "CheckActivePackageToAccrual", "Ping not execute. The package module is not active or not installed");
1461          AppVM.Instance.ModuleErrorState = ModuleErrorState.ModuleNotInstalledMessage;
1462          if (SessionMonitor._showedTrayMessage)
1463            return;
1464          ((TaskbarIcon) Map.Get<IAppTray>()).ShowBalloonTip(Resources.Tray_NotificationTitle, Resources.Tray_ModuleNotInstalledMessage, BalloonIcon.Info);
1465          SessionMonitor._showedTrayMessage = true;
1466        }
1467        else
1468        {
1469          this._activeModuleSecureKey = Map.Get<IModuleResolver>().GetActiveModuleSecureKey();
1470          if (string.IsNullOrEmpty(this._activeModuleSecureKey))
1471          {
1472            Logger.WriteError((object) this, "CheckActivePackageToAccrual", "Ping not execute. The secure key not exists");
1473            AppVM.Instance.ModuleErrorState = ModuleErrorState.CrashOrNotFoundMainFile;
1474            if (SessionMonitor._showedTrayMessage)
1475              return;
1476            ((TaskbarIcon) Map.Get<IAppTray>()).ShowBalloonTip(Resources.Tray_NotificationTitle, Resources.Tray_ModuleCrashOrNotFoundMainFiledMessage, BalloonIcon.Info);
1477            SessionMonitor._showedTrayMessage = true;
1478          }
1479          else
1480          {
1481            AppVM.Instance.ModuleErrorState = ModuleErrorState.NoError;
1482            this.CheckSessionPing();
1483          }
1484        }
1485      }
1486    }
1487
1488    private bool TryGetNewSecureKey()
1489    {
1490      if (!AppVM.Instance.ActivePackageId.HasValue)
1491        return false;
1492      try
1493      {
1494        long productId = AppVM.Instance.ActivePackageId.Value;
1495        IScreenManager screenManager = Map.Get<IScreenManager>();
1496        screenManager.DoVisualSafe(screenManager.ShowStatusMessage(Resources.StatusMessage_TryActivateKeyRefresh, 5, false));
1497        Logger.WriteInfo((object) this, "TryGetNewSecureKey", "??????? ????????? ?????? ????? ????????? ?? ???????? ? ID = " + (object) productId);
1498        DateTime? lastTime = Enumerable.Max<Purchase, DateTime?>(Enumerable.Where<Purchase>((IEnumerable<Purchase>) Map.Get<IPurchaseManager>().Purchases, (Func<Purchase, bool>) (x => x.ProductId == productId)), (Func<Purchase, DateTime?>) (x => x.Date));
1499        if (Map.Get<IPurchaseManager>().ActivateModule(Enumerable.SingleOrDefault<Purchase>((IEnumerable<Purchase>) Map.Get<IPurchaseManager>().Purchases, (Func<Purchase, bool>) (x =>
1500        {
1501          if (x.ProductId != productId)
1502            return false;
1503          DateTime? date = x.Date;
1504          DateTime? nullable = lastTime;
1505          if (date.HasValue != nullable.HasValue)
1506            return false;
1507          if (date.HasValue)
1508            return date.GetValueOrDefault() == nullable.GetValueOrDefault();
1509          return true;
1510        }))))
1511        {
1512          this._activeModuleSecureKey = Map.Get<IModuleResolver>().GetActiveModuleSecureKey();
1513          return true;
1514        }
1515        Logger.WriteError((object) this, "CheckActivePackageToAccrual", "Ping not execute. The secure key not exists");
1516        AppVM.Instance.ModuleErrorState = ModuleErrorState.CrashOrNotFoundMainFile;
1517        if (!SessionMonitor._showedTrayMessage)
1518        {
1519          ((TaskbarIcon) Map.Get<IAppTray>()).ShowBalloonTip(Resources.Tray_NotificationTitle, Resources.Tray_ModuleCrashOrNotFoundMainFiledMessage, BalloonIcon.Info);
1520          SessionMonitor._showedTrayMessage = true;
1521        }
1522        return false;
1523      }
1524      catch (Exception ex)
1525      {
1526        Logger.WriteError((object) this, "TryGetNewSecureKey", "?????? ??? ?????????? ????? ?????????: " + ex.Message);
1527        return false;
1528      }
1529    }
1530
1531    private void CheckSessionPing()
1532    {
1533      bool flag = false;
1534      if (this.PingSession())
1535      {
1536        this._secondAttempt = false;
1537        flag = this.SessionState != SessionState.InAccrual;
1538        this.SessionState = SessionState.InAccrual;
1539        NetworkMonitor.CheckServerOff();
1540      }
1541      else if (this._secondAttempt)
1542        this.SetSessionStateToSuspended();
1543      else
1544        this._secondAttempt = true;
1545      this.StartSessionMonitorTimer(this._secondAttempt || flag);
1546    }
1547
1548    private void StartSessionMonitorTimer(bool shortInterval)
1549    {
1550      if (this._sessionMonitorTimer == null)
1551      {
1552        this._sessionMonitorTimer = new Timer(30000.0);
1553        this._sessionMonitorTimer.Elapsed += new ElapsedEventHandler(this.OnSessionMonitorTimerTick);
1554        Logger.WriteInfo(typeof (NetworkMonitor), "StartSessionMonitorTimer()", "??????? ?????? ????? ??????");
1555      }
1556      else
1557        this._sessionMonitorTimer.Interval = shortInterval ? 30000.0 : 180000.0;
1558      this._sessionMonitorTimer.Start();
1559    }
1560
1561    private void OnSessionMonitorTimerTick(object sender, ElapsedEventArgs e)
1562    {
1563      this._sessionMonitorTimer.Stop();
1564      this.CheckSessionPing();
1565    }
1566
1567    private void OnNetworkStateChanged(object sender, NetworkStateEventArgs e)
1568    {
1569      if (e.State != NetworkState.ServerOnline)
1570        return;
1571      Logger.WriteInfo((object) this, "OnNetworkStateChanged()", "???? ? ?????? Online");
1572      this.SetSessionStateToLogon();
1573    }
1574
1575    public delegate void PingEventHandler(object sender, PingEventArgs e);
1576  }
1577}
1578?// Decompiled with JetBrains decompiler
1579// Type: KairosPlanet.Managers.Network.SessionState
1580// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1581// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1582// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1583
1584namespace KairosPlanet.Managers.Network
1585{
1586  internal enum SessionState
1587  {
1588    LogOff,
1589    LogOn,
1590    Suspended,
1591    InAccrual,
1592  }
1593}
1594?// Decompiled with JetBrains decompiler
1595// Type: KairosPlanet.Managers.Network.SessionStateEventArgs
1596// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1597// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1598// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1599
1600using System;
1601
1602namespace KairosPlanet.Managers.Network
1603{
1604  internal class SessionStateEventArgs : EventArgs
1605  {
1606    public SessionState State { get; private set; }
1607
1608    public SessionStateEventArgs(SessionState state)
1609    {
1610      this.State = state;
1611    }
1612  }
1613}
1614?// Decompiled with JetBrains decompiler
1615// Type: KairosPlanet.Managers.Localization.UnifyCultureInfo
1616// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1617// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1618// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1619
1620using System.Globalization;
1621
1622namespace KairosPlanet.Managers.Localization
1623{
1624  public class UnifyCultureInfo : CultureInfo
1625  {
1626    public override DateTimeFormatInfo DateTimeFormat
1627    {
1628      get
1629      {
1630        DateTimeFormatInfo dateTimeFormat = base.DateTimeFormat;
1631        dateTimeFormat.ShortDatePattern = "yyyy-MM-dd";
1632        return dateTimeFormat;
1633      }
1634      set
1635      {
1636        base.DateTimeFormat = value;
1637      }
1638    }
1639
1640    public UnifyCultureInfo(string name)
1641      : base(name)
1642    {
1643    }
1644
1645    public UnifyCultureInfo(string name, bool useUserOverride)
1646      : base(name, useUserOverride)
1647    {
1648    }
1649
1650    public UnifyCultureInfo(int culture)
1651      : base(culture)
1652    {
1653    }
1654
1655    public UnifyCultureInfo(int culture, bool useUserOverride)
1656      : base(culture, useUserOverride)
1657    {
1658    }
1659  }
1660}
1661?// Decompiled with JetBrains decompiler
1662// Type: KairosPlanet.ViewModel.Services.RtfReplaseser
1663// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1664// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1665// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1666
1667using System.Collections.Generic;
1668using System.Text;
1669
1670namespace KairosPlanet.ViewModel.Services
1671{
1672  public class RtfReplaseser
1673  {
1674    private static string _open = "<%";
1675    private static string _close = "%>";
1676    private bool _pasteSpase = true;
1677    private string _inStr;
1678    private StringBuilder _outStr;
1679    private Dictionary<string, string> _dictionary;
1680
1681    private RtfReplaseser()
1682    {
1683    }
1684
1685    public static string Replase(string text, Dictionary<string, string> dictionary)
1686    {
1687      return new RtfReplaseser().OnReplase(text, dictionary);
1688    }
1689
1690    private void Replace()
1691    {
1692      string str = string.Empty;
1693      string key = string.Empty;
1694      bool flag = false;
1695      int index = 0;
1696      this._outStr = new StringBuilder();
1697      foreach (char ch in this._inStr)
1698      {
1699        if (!flag)
1700        {
1701          str += (string) (object) ch;
1702          key += (string) (object) ch;
1703          if ((int) RtfReplaseser._open[index] == (int) ch)
1704          {
1705            ++index;
1706            if (RtfReplaseser._open.Length == index)
1707            {
1708              flag = true;
1709              str = string.Empty;
1710              index = 0;
1711            }
1712          }
1713          else
1714          {
1715            this._outStr.Append(key);
1716            index = 0;
1717            str = key = string.Empty;
1718          }
1719        }
1720        else
1721        {
1722          str += (string) (object) ch;
1723          key += (string) (object) ch;
1724          if ((int) ch == 32)
1725          {
1726            this._outStr.Append(key);
1727            index = 0;
1728            str = key = string.Empty;
1729            flag = false;
1730          }
1731          if ((int) RtfReplaseser._close[index] == (int) ch)
1732          {
1733            ++index;
1734            if (RtfReplaseser._close.Length == index)
1735            {
1736              if (this._dictionary.ContainsKey(key))
1737                this._outStr.Append(this._dictionary[key]);
1738              else if (!this._pasteSpase)
1739                this._outStr.Append(key);
1740              str = key = string.Empty;
1741              index = 0;
1742              flag = false;
1743            }
1744          }
1745        }
1746      }
1747    }
1748
1749    private string OnReplase(string text, Dictionary<string, string> dictionary)
1750    {
1751      this._inStr = text;
1752      this._dictionary = dictionary;
1753      this.Replace();
1754      return this._outStr.ToString();
1755    }
1756  }
1757}
1758?// Decompiled with JetBrains decompiler
1759// Type: WinApp.View.AppTray
1760// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1761// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1762// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1763
1764using System;
1765using System.CodeDom.Compiler;
1766using System.ComponentModel;
1767using System.Diagnostics;
1768using System.Drawing;
1769using System.Windows;
1770using System.Windows.Controls;
1771using System.Windows.Markup;
1772using WinApp.Managers.Interfaces;
1773using WinApp.Tray.RichNotifyIcon;
1774using WinApp.ViewModel.Tray;
1775
1776namespace WinApp.View
1777{
1778  internal class AppTray : TaskbarIcon, IAppTray, IComponentConnector
1779  {
1780    private readonly AppTrayVM _viewModel;
1781    private bool _contentLoaded;
1782
1783    public UIElement Tray
1784    {
1785      get
1786      {
1787        return (UIElement) this;
1788      }
1789    }
1790
1791    public AppTray()
1792    {
1793      this.InitializeComponent();
1794      this.DataContext = (object) (this._viewModel = new AppTrayVM()
1795      {
1796        NoLoginContextMenu = (ContextMenu) this.Resources[(object) "NoLoginContextMenu"],
1797        FullContextMenu = (ContextMenu) this.Resources[(object) "FullContextMenu"]
1798      });
1799    }
1800
1801    ~AppTray()
1802    {
1803      this.Visibility = Visibility.Collapsed;
1804      this.Icon = (Icon) null;
1805      this.Dispose();
1806    }
1807
1808    public void Refresh()
1809    {
1810      this._viewModel.Refresh();
1811    }
1812
1813    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
1814    [DebuggerNonUserCode]
1815    public void InitializeComponent()
1816    {
1817      if (this._contentLoaded)
1818        return;
1819      this._contentLoaded = true;
1820      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/apptray.xaml", UriKind.Relative));
1821    }
1822
1823    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
1824    [DebuggerNonUserCode]
1825    internal Delegate _CreateDelegate(Type delegateType, string handler)
1826    {
1827      return Delegate.CreateDelegate(delegateType, (object) this, handler);
1828    }
1829
1830    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
1831    [DebuggerNonUserCode]
1832    [EditorBrowsable(EditorBrowsableState.Never)]
1833    void IComponentConnector.Connect(int connectionId, object target)
1834    {
1835      this._contentLoaded = true;
1836    }
1837  }
1838}
1839?// Decompiled with JetBrains decompiler
1840// Type: WinApp.View.Base.IWindowArrangeView
1841// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1842// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1843// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1844
1845using System.Windows;
1846
1847namespace WinApp.View.Base
1848{
1849  public interface IWindowArrangeView
1850  {
1851    double WindowHeight { get; }
1852
1853    double WindowWidth { get; }
1854
1855    ResizeMode ResizeMode { get; }
1856  }
1857}
1858?// Decompiled with JetBrains decompiler
1859// Type: WinApp.View.Base.WindowCommon
1860// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1861// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1862// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1863
1864using System.Windows;
1865using System.Windows.Controls;
1866using System.Windows.Data;
1867using System.Windows.Media;
1868using Telerik.Windows.Controls;
1869
1870namespace WinApp.View.Base
1871{
1872  internal class WindowCommon : RadWindow
1873  {
1874    public static readonly DependencyProperty TaskbarIconProperty = DependencyProperty.Register("TaskbarIcon", typeof (ImageSource), typeof (WindowCommon), new PropertyMetadata((object) null));
1875    private Window _parentWindow;
1876
1877    public ImageSource TaskbarIcon
1878    {
1879      get
1880      {
1881        return (ImageSource) ((DependencyObject) this).GetValue(WindowCommon.TaskbarIconProperty);
1882      }
1883      set
1884      {
1885        ((DependencyObject) this).SetValue(WindowCommon.TaskbarIconProperty, (object) value);
1886      }
1887    }
1888
1889    public Window ParentWindow
1890    {
1891      get
1892      {
1893        if (this._parentWindow == null)
1894        {
1895          this._parentWindow = (Window) ParentOfTypeExtensions.ParentOfType<Window>((DependencyObject) this);
1896          if (this._parentWindow == null)
1897            return (Window) null;
1898          this._parentWindow.SetBinding(FrameworkElement.DataContextProperty, (BindingBase) new Binding("DataContext")
1899          {
1900            Source = (object) this
1901          });
1902          BindingExpression bindingExpression = ((FrameworkElement) this).GetBindingExpression(HeaderedContentControl.HeaderProperty);
1903          if (bindingExpression != null)
1904            this._parentWindow.SetBinding(Window.TitleProperty, (BindingBase) bindingExpression.ParentBinding);
1905          else
1906            this._parentWindow.SetValue(Window.TitleProperty, ((HeaderedContentControl) this).Header);
1907          this._parentWindow.SetBinding(Window.IconProperty, (BindingBase) new Binding("TaskbarIcon")
1908          {
1909            Source = (object) this
1910          });
1911        }
1912        return this._parentWindow;
1913      }
1914    }
1915
1916    protected bool ShowInTaskbar
1917    {
1918      get
1919      {
1920        if (this.ParentWindow == null)
1921          return false;
1922        return this.ParentWindow.ShowInTaskbar;
1923      }
1924      set
1925      {
1926        if (this.ParentWindow == null)
1927          return;
1928        this.ParentWindow.ShowInTaskbar = value;
1929      }
1930    }
1931
1932    public WindowCommon()
1933    {
1934      base.\u002Ector();
1935      ((FrameworkElement) this).Loaded += new RoutedEventHandler(this.OnLoaded);
1936    }
1937
1938    protected virtual void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
1939    {
1940      this.ShowInTaskbar = true;
1941    }
1942  }
1943}
1944?// Decompiled with JetBrains decompiler
1945// Type: WinApp.View.MainViewUC
1946// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
1947// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
1948// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
1949
1950using System;
1951using System.CodeDom.Compiler;
1952using System.ComponentModel;
1953using System.Diagnostics;
1954using System.Windows;
1955using System.Windows.Controls;
1956using System.Windows.Markup;
1957using Telerik.Windows.Controls;
1958using WinApp.View.Base;
1959using WinApp.ViewModel;
1960
1961namespace WinApp.View
1962{
1963  internal class MainViewUC : UserControl, IWindowArrangeView, IComponentConnector
1964  {
1965    private readonly MainViewVM _viewModel;
1966    internal RadTreeView Menu;
1967    internal FlowDocumentScrollViewer ErrorBox;
1968    private bool _contentLoaded;
1969
1970    public MainViewVM ViewModel
1971    {
1972      get
1973      {
1974        return this._viewModel;
1975      }
1976    }
1977
1978    public double WindowHeight
1979    {
1980      get
1981      {
1982        return 600.0;
1983      }
1984    }
1985
1986    public double WindowWidth
1987    {
1988      get
1989      {
1990        return 1000.0;
1991      }
1992    }
1993
1994    public ResizeMode ResizeMode
1995    {
1996      get
1997      {
1998        return ResizeMode.CanResize;
1999      }
2000    }
2001
2002    public MainViewUC()
2003    {
2004      this.InitializeComponent();
2005      this.DataContext = (object) (this._viewModel = new MainViewVM(this));
2006    }
2007
2008    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2009    [DebuggerNonUserCode]
2010    public void InitializeComponent()
2011    {
2012      if (this._contentLoaded)
2013        return;
2014      this._contentLoaded = true;
2015      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/mainviewuc.xaml", UriKind.Relative));
2016    }
2017
2018    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2019    [DebuggerNonUserCode]
2020    [EditorBrowsable(EditorBrowsableState.Never)]
2021    void IComponentConnector.Connect(int connectionId, object target)
2022    {
2023      switch (connectionId)
2024      {
2025        case 1:
2026          this.Menu = (RadTreeView) target;
2027          break;
2028        case 2:
2029          this.ErrorBox = (FlowDocumentScrollViewer) target;
2030          break;
2031        default:
2032          this._contentLoaded = true;
2033          break;
2034      }
2035    }
2036  }
2037}
2038?// Decompiled with JetBrains decompiler
2039// Type: WinApp.View.LoginUC
2040// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2041// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2042// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2043
2044using System;
2045using System.CodeDom.Compiler;
2046using System.ComponentModel;
2047using System.Diagnostics;
2048using System.Windows;
2049using System.Windows.Controls;
2050using System.Windows.Markup;
2051using Telerik.Windows.Controls;
2052using WinApp.View.Base;
2053using WinApp.ViewModel;
2054
2055namespace WinApp.View
2056{
2057  internal class LoginUC : UserControl, IWindowArrangeView, IComponentConnector
2058  {
2059    internal RadWatermarkTextBox LoginBox;
2060    private bool _contentLoaded;
2061
2062    public double WindowHeight
2063    {
2064      get
2065      {
2066        return 500.0;
2067      }
2068    }
2069
2070    public double WindowWidth
2071    {
2072      get
2073      {
2074        return 400.0;
2075      }
2076    }
2077
2078    public ResizeMode ResizeMode
2079    {
2080      get
2081      {
2082        return ResizeMode.CanMinimize;
2083      }
2084    }
2085
2086    public LoginVM ViewModel { get; private set; }
2087
2088    public LoginUC()
2089      : this(new LoginVM())
2090    {
2091    }
2092
2093    public LoginUC(LoginVM loginVm)
2094    {
2095      this.InitializeComponent();
2096      this.DataContext = (object) (this.ViewModel = loginVm);
2097      this.ViewModel.Initialize();
2098    }
2099
2100    private void LoginUC_OnLoaded(object sender, RoutedEventArgs e)
2101    {
2102      ((UIElement) this.LoginBox).Focus();
2103    }
2104
2105    [DebuggerNonUserCode]
2106    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2107    public void InitializeComponent()
2108    {
2109      if (this._contentLoaded)
2110        return;
2111      this._contentLoaded = true;
2112      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/loginuc.xaml", UriKind.Relative));
2113    }
2114
2115    [DebuggerNonUserCode]
2116    [EditorBrowsable(EditorBrowsableState.Never)]
2117    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2118    void IComponentConnector.Connect(int connectionId, object target)
2119    {
2120      switch (connectionId)
2121      {
2122        case 1:
2123          ((FrameworkElement) target).Loaded += new RoutedEventHandler(this.LoginUC_OnLoaded);
2124          break;
2125        case 2:
2126          this.LoginBox = (RadWatermarkTextBox) target;
2127          break;
2128        default:
2129          this._contentLoaded = true;
2130          break;
2131      }
2132    }
2133  }
2134}
2135?// Decompiled with JetBrains decompiler
2136// Type: WinApp.View.ChangePasswordUC
2137// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2138// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2139// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2140
2141using System;
2142using System.CodeDom.Compiler;
2143using System.ComponentModel;
2144using System.Diagnostics;
2145using System.Windows;
2146using System.Windows.Controls;
2147using System.Windows.Markup;
2148using WinApp.ViewModel.Controls;
2149
2150namespace WinApp.View
2151{
2152  internal class ChangePasswordUC : UserControl, IComponentConnector
2153  {
2154    private bool _contentLoaded;
2155
2156    public ChangePasswordVM ViewModel { get; private set; }
2157
2158    public ChangePasswordUC()
2159    {
2160      this.InitializeComponent();
2161      this.DataContext = (object) (this.ViewModel = new ChangePasswordVM());
2162    }
2163
2164    [DebuggerNonUserCode]
2165    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2166    public void InitializeComponent()
2167    {
2168      if (this._contentLoaded)
2169        return;
2170      this._contentLoaded = true;
2171      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/changepassworduc.xaml", UriKind.Relative));
2172    }
2173
2174    [DebuggerNonUserCode]
2175    [EditorBrowsable(EditorBrowsableState.Never)]
2176    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2177    void IComponentConnector.Connect(int connectionId, object target)
2178    {
2179      this._contentLoaded = true;
2180    }
2181  }
2182}
2183?// Decompiled with JetBrains decompiler
2184// Type: WinApp.View.SessionHistoryUC
2185// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2186// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2187// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2188
2189using System;
2190using System.CodeDom.Compiler;
2191using System.ComponentModel;
2192using System.Diagnostics;
2193using System.Windows;
2194using System.Windows.Controls;
2195using System.Windows.Markup;
2196using WinApp.ViewModel.Controls;
2197
2198namespace WinApp.View
2199{
2200  internal class SessionHistoryUC : UserControl, IComponentConnector
2201  {
2202    private bool _contentLoaded;
2203
2204    public SessionHistoryVM ViewModel { get; private set; }
2205
2206    public SessionHistoryUC()
2207    {
2208      this.InitializeComponent();
2209      this.DataContext = (object) (this.ViewModel = new SessionHistoryVM());
2210    }
2211
2212    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2213    [DebuggerNonUserCode]
2214    public void InitializeComponent()
2215    {
2216      if (this._contentLoaded)
2217        return;
2218      this._contentLoaded = true;
2219      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/sessionhistoryuc.xaml", UriKind.Relative));
2220    }
2221
2222    [DebuggerNonUserCode]
2223    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2224    [EditorBrowsable(EditorBrowsableState.Never)]
2225    void IComponentConnector.Connect(int connectionId, object target)
2226    {
2227      this._contentLoaded = true;
2228    }
2229  }
2230}
2231?// Decompiled with JetBrains decompiler
2232// Type: WinApp.View.Helpers.TelerikThemeManager
2233// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2234// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2235// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2236
2237using Inc.Logging;
2238using System.Windows;
2239using System.Windows.Media;
2240using Telerik.Windows.Controls;
2241
2242namespace WinApp.View.Helpers
2243{
2244  internal class TelerikThemeManager : DependencyObject
2245  {
2246    public TelerikThemeManager()
2247    {
2248      TelerikThemeManager.ApplyTheme();
2249    }
2250
2251    public static void ApplyTheme()
2252    {
2253      MetroColors.get_PaletteInstance().set_AccentColor(Color.FromArgb(byte.MaxValue, (byte) 61, (byte) 86, (byte) 109));
2254      MetroColors.get_PaletteInstance().set_StrongColor(Color.FromArgb(byte.MaxValue, (byte) 63, (byte) 63, (byte) 63));
2255      TelerikThemeManager.ApplyTheme((Theme) new MetroTheme());
2256    }
2257
2258    public static void ApplyTheme(Theme theme)
2259    {
2260      Logger.WriteInfo(typeof (TelerikThemeManager), "ApplyTheme()", string.Format("?????????? ???? '{0}'...", (object) theme));
2261      StyleManager.set_ApplicationTheme(theme);
2262      Logger.WriteInfo(typeof (TelerikThemeManager), "ApplyTheme()", "???? ??????? ?????????");
2263    }
2264  }
2265}
2266?// Decompiled with JetBrains decompiler
2267// Type: WinApp.View.Helpers.WebHelper
2268// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2269// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2270// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2271
2272using System;
2273using System.IO;
2274using System.Net;
2275using WinApp.Managers.Configuration;
2276
2277namespace WinApp.View.Helpers
2278{
2279  public static class WebHelper
2280  {
2281    public static Stream DownloadImage(Uri uri, string savePath)
2282    {
2283      HttpWebRequest httpWebRequest = WebRequest.Create(uri) as HttpWebRequest;
2284      if (httpWebRequest == null)
2285        return Stream.Null;
2286      httpWebRequest.UserAgent = ConfigurationManager.GetUserAgent();
2287      WebResponse response = httpWebRequest.GetResponse();
2288      using (Stream responseStream = response.GetResponseStream())
2289      {
2290        byte[] numArray = new byte[response.ContentLength];
2291        int offset = 0;
2292        while (responseStream != null)
2293        {
2294          int num = responseStream.Read(numArray, offset, numArray.Length - offset);
2295          offset += num;
2296          if (num <= 0)
2297          {
2298            string directoryName = Path.GetDirectoryName(savePath);
2299            if (!Directory.Exists(directoryName))
2300              Directory.CreateDirectory(directoryName);
2301            System.IO.File.WriteAllBytes(savePath, numArray);
2302            return (Stream) new MemoryStream(numArray);
2303          }
2304        }
2305        return Stream.Null;
2306      }
2307    }
2308  }
2309}
2310?// Decompiled with JetBrains decompiler
2311// Type: WinApp.View.Helpers.PasswordBoxAssistant
2312// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2313// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2314// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2315
2316using System.Windows;
2317using System.Windows.Controls;
2318
2319namespace WinApp.View.Helpers
2320{
2321  public static class PasswordBoxAssistant
2322  {
2323    public static readonly DependencyProperty BoundPassword = DependencyProperty.RegisterAttached("BoundPassword", typeof (string), typeof (PasswordBoxAssistant), new PropertyMetadata((object) string.Empty, new PropertyChangedCallback(PasswordBoxAssistant.OnBoundPasswordChanged)));
2324    public static readonly DependencyProperty BindPassword = DependencyProperty.RegisterAttached("BindPassword", typeof (bool), typeof (PasswordBoxAssistant), new PropertyMetadata((object) false, new PropertyChangedCallback(PasswordBoxAssistant.OnBindPasswordChanged)));
2325    private static readonly DependencyProperty _updatingPassword = DependencyProperty.RegisterAttached("_updatingPassword", typeof (bool), typeof (PasswordBoxAssistant), new PropertyMetadata((object) false));
2326
2327    public static void SetBindPassword(DependencyObject dp, bool value)
2328    {
2329      dp.SetValue(PasswordBoxAssistant.BindPassword, (object) (bool) (value ? 1 : 0));
2330    }
2331
2332    public static bool GetBindPassword(DependencyObject dp)
2333    {
2334      return (bool) dp.GetValue(PasswordBoxAssistant.BindPassword);
2335    }
2336
2337    public static string GetBoundPassword(DependencyObject dp)
2338    {
2339      return (string) dp.GetValue(PasswordBoxAssistant.BoundPassword);
2340    }
2341
2342    public static void SetBoundPassword(DependencyObject dp, string value)
2343    {
2344      dp.SetValue(PasswordBoxAssistant.BoundPassword, (object) value);
2345    }
2346
2347    private static void OnBoundPasswordChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
2348    {
2349      PasswordBox passwordBox = d as PasswordBox;
2350      if (d == null || !PasswordBoxAssistant.GetBindPassword(d) || passwordBox == null)
2351        return;
2352      passwordBox.PasswordChanged -= new RoutedEventHandler(PasswordBoxAssistant.HandlePasswordChanged);
2353      string str = (string) e.NewValue;
2354      if (!PasswordBoxAssistant.GetUpdatingPassword((DependencyObject) passwordBox))
2355        passwordBox.Password = str;
2356      passwordBox.PasswordChanged += new RoutedEventHandler(PasswordBoxAssistant.HandlePasswordChanged);
2357    }
2358
2359    private static void OnBindPasswordChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)
2360    {
2361      PasswordBox passwordBox = dp as PasswordBox;
2362      if (passwordBox == null)
2363        return;
2364      bool flag1 = (bool) e.OldValue;
2365      bool flag2 = (bool) e.NewValue;
2366      if (flag1)
2367        passwordBox.PasswordChanged -= new RoutedEventHandler(PasswordBoxAssistant.HandlePasswordChanged);
2368      if (!flag2)
2369        return;
2370      passwordBox.PasswordChanged += new RoutedEventHandler(PasswordBoxAssistant.HandlePasswordChanged);
2371    }
2372
2373    private static void HandlePasswordChanged(object sender, RoutedEventArgs e)
2374    {
2375      PasswordBox passwordBox = sender as PasswordBox;
2376      PasswordBoxAssistant.SetUpdatingPassword((DependencyObject) passwordBox, true);
2377      if (passwordBox == null)
2378        return;
2379      PasswordBoxAssistant.SetBoundPassword((DependencyObject) passwordBox, passwordBox.Password);
2380      PasswordBoxAssistant.SetUpdatingPassword((DependencyObject) passwordBox, false);
2381    }
2382
2383    private static bool GetUpdatingPassword(DependencyObject dp)
2384    {
2385      return (bool) dp.GetValue(PasswordBoxAssistant._updatingPassword);
2386    }
2387
2388    private static void SetUpdatingPassword(DependencyObject dp, bool value)
2389    {
2390      dp.SetValue(PasswordBoxAssistant._updatingPassword, (object) (bool) (value ? 1 : 0));
2391    }
2392  }
2393}
2394?// Decompiled with JetBrains decompiler
2395// Type: WinApp.View.Helpers.CommandBindingExtension
2396// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2397// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2398// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2399
2400using System;
2401using System.Reflection;
2402using System.Windows;
2403using System.Windows.Input;
2404using System.Windows.Markup;
2405
2406namespace WinApp.View.Helpers
2407{
2408  [MarkupExtensionReturnType(typeof (ICommand))]
2409  public class CommandBindingExtension : MarkupExtension
2410  {
2411    private object targetObject;
2412    private object targetProperty;
2413    private bool dataContextChangeHandlerSet;
2414
2415    [ConstructorArgument("commandName")]
2416    public string CommandName { get; set; }
2417
2418    public CommandBindingExtension()
2419    {
2420    }
2421
2422    public CommandBindingExtension(string commandName)
2423    {
2424      this.CommandName = commandName;
2425    }
2426
2427    public override object ProvideValue(IServiceProvider serviceProvider)
2428    {
2429      IProvideValueTarget provideValueTarget = serviceProvider.GetService(typeof (IProvideValueTarget)) as IProvideValueTarget;
2430      if (provideValueTarget != null)
2431      {
2432        this.targetObject = provideValueTarget.TargetObject;
2433        this.targetProperty = provideValueTarget.TargetProperty;
2434      }
2435      if (!string.IsNullOrEmpty(this.CommandName))
2436      {
2437        ParserContext privateFieldValue1 = this.GetPrivateFieldValue<ParserContext>((object) serviceProvider, "_context");
2438        if (privateFieldValue1 != null)
2439        {
2440          FrameworkElement privateFieldValue2 = this.GetPrivateFieldValue<FrameworkElement>((object) privateFieldValue1, "_rootElement");
2441          if (privateFieldValue2 != null)
2442          {
2443            object dataContext = privateFieldValue2.DataContext;
2444            if (!this.dataContextChangeHandlerSet)
2445            {
2446              privateFieldValue2.DataContextChanged += new DependencyPropertyChangedEventHandler(this.rootElement_DataContextChanged);
2447              this.dataContextChangeHandlerSet = true;
2448            }
2449            if (dataContext != null)
2450            {
2451              ICommand command = this.GetCommand(dataContext, this.CommandName);
2452              if (command != null)
2453                return (object) command;
2454            }
2455          }
2456        }
2457      }
2458      return (object) CommandBindingExtension.DummyCommand.Instance;
2459    }
2460
2461    private ICommand GetCommand(object dataContext, string commandName)
2462    {
2463      PropertyInfo property = dataContext.GetType().GetProperty(commandName);
2464      if (property != null)
2465      {
2466        ICommand command = property.GetValue(dataContext, (object[]) null) as ICommand;
2467        if (command != null)
2468          return command;
2469      }
2470      return (ICommand) null;
2471    }
2472
2473    private void AssignCommand(ICommand command)
2474    {
2475      if (this.targetObject == null || this.targetProperty == null)
2476        return;
2477      if (this.targetProperty is DependencyProperty)
2478        (this.targetObject as DependencyObject).SetValue(this.targetProperty as DependencyProperty, (object) command);
2479      else
2480        (this.targetProperty as PropertyInfo).SetValue(this.targetObject, (object) command, (object[]) null);
2481    }
2482
2483    private void rootElement_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
2484    {
2485      FrameworkElement frameworkElement = sender as FrameworkElement;
2486      if (frameworkElement == null)
2487        return;
2488      object dataContext = frameworkElement.DataContext;
2489      if (dataContext == null)
2490        return;
2491      ICommand command = this.GetCommand(dataContext, this.CommandName);
2492      if (command == null)
2493        return;
2494      this.AssignCommand(command);
2495    }
2496
2497    private T GetPrivateFieldValue<T>(object target, string fieldName)
2498    {
2499      FieldInfo field = target.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
2500      if (field != null)
2501        return (T) field.GetValue(target);
2502      return default (T);
2503    }
2504
2505    private class DummyCommand : ICommand
2506    {
2507      private static CommandBindingExtension.DummyCommand _instance;
2508
2509      public static CommandBindingExtension.DummyCommand Instance
2510      {
2511        get
2512        {
2513          if (CommandBindingExtension.DummyCommand._instance == null)
2514            CommandBindingExtension.DummyCommand._instance = new CommandBindingExtension.DummyCommand();
2515          return CommandBindingExtension.DummyCommand._instance;
2516        }
2517      }
2518
2519      public event EventHandler CanExecuteChanged;
2520
2521      private DummyCommand()
2522      {
2523      }
2524
2525      public bool CanExecute(object parameter)
2526      {
2527        return false;
2528      }
2529
2530      public void Execute(object parameter)
2531      {
2532      }
2533    }
2534  }
2535}
2536?// Decompiled with JetBrains decompiler
2537// Type: WinApp.View.Helpers.VisualDescendantsExtention
2538// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2539// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2540// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2541
2542using System.Collections.Generic;
2543using System.Windows;
2544using System.Windows.Media;
2545
2546namespace WinApp.View.Helpers
2547{
2548  public static class VisualDescendantsExtention
2549  {
2550    public static IEnumerable<T> GetVisualDescendants<T>(this DependencyObject depObj) where T : DependencyObject
2551    {
2552      if (depObj != null)
2553      {
2554        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); ++i)
2555        {
2556          DependencyObject child = VisualTreeHelper.GetChild(depObj, i);
2557          if (child is T)
2558            yield return (T) child;
2559          foreach (T obj in VisualDescendantsExtention.GetVisualDescendants<T>(child))
2560            yield return obj;
2561        }
2562      }
2563    }
2564  }
2565}
2566?// Decompiled with JetBrains decompiler
2567// Type: WinApp.View.PersonalInformationUC
2568// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2569// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2570// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2571
2572using IncMap;
2573using System;
2574using System.CodeDom.Compiler;
2575using System.ComponentModel;
2576using System.Diagnostics;
2577using System.Windows;
2578using System.Windows.Controls;
2579using System.Windows.Markup;
2580using WinApp.Managers.Interfaces;
2581using WinApp.ViewModel.Controls;
2582
2583namespace WinApp.View
2584{
2585  internal class PersonalInformationUC : UserControl, IComponentConnector
2586  {
2587    private bool _contentLoaded;
2588
2589    public PersonalInformationVM ViewModel { get; private set; }
2590
2591    public PersonalInformationUC()
2592    {
2593      this.InitializeComponent();
2594      this.DataContext = (object) (this.ViewModel = new PersonalInformationVM(Map.Get<ISessionManager>().CurrentUser));
2595    }
2596
2597    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2598    [DebuggerNonUserCode]
2599    public void InitializeComponent()
2600    {
2601      if (this._contentLoaded)
2602        return;
2603      this._contentLoaded = true;
2604      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/personalinformationuc.xaml", UriKind.Relative));
2605    }
2606
2607    [DebuggerNonUserCode]
2608    [EditorBrowsable(EditorBrowsableState.Never)]
2609    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2610    void IComponentConnector.Connect(int connectionId, object target)
2611    {
2612      this._contentLoaded = true;
2613    }
2614  }
2615}
2616?// Decompiled with JetBrains decompiler
2617// Type: WinApp.View.ContactInformationUC
2618// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2619// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2620// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2621
2622using IncMap;
2623using System;
2624using System.CodeDom.Compiler;
2625using System.ComponentModel;
2626using System.Diagnostics;
2627using System.Windows;
2628using System.Windows.Controls;
2629using System.Windows.Markup;
2630using WinApp.Managers.Interfaces;
2631using WinApp.ViewModel.Controls;
2632
2633namespace WinApp.View
2634{
2635  internal class ContactInformationUC : UserControl, IComponentConnector
2636  {
2637    private bool _contentLoaded;
2638
2639    public ContactInformationVM ViewModel { get; private set; }
2640
2641    public ContactInformationUC()
2642    {
2643      this.InitializeComponent();
2644      this.DataContext = (object) (this.ViewModel = new ContactInformationVM(Map.Get<ISessionManager>().CurrentUser));
2645    }
2646
2647    [DebuggerNonUserCode]
2648    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2649    public void InitializeComponent()
2650    {
2651      if (this._contentLoaded)
2652        return;
2653      this._contentLoaded = true;
2654      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/contactinformationuc.xaml", UriKind.Relative));
2655    }
2656
2657    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2658    [DebuggerNonUserCode]
2659    [EditorBrowsable(EditorBrowsableState.Never)]
2660    void IComponentConnector.Connect(int connectionId, object target)
2661    {
2662      this._contentLoaded = true;
2663    }
2664  }
2665}
2666?// Decompiled with JetBrains decompiler
2667// Type: WinApp.View.ServicesUC
2668// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2669// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2670// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2671
2672using System;
2673using System.CodeDom.Compiler;
2674using System.ComponentModel;
2675using System.Diagnostics;
2676using System.Linq;
2677using System.Windows;
2678using System.Windows.Controls;
2679using System.Windows.Input;
2680using System.Windows.Markup;
2681using Telerik.Windows;
2682using Telerik.Windows.Controls;
2683using WinApp.View.Helpers;
2684using WinApp.ViewModel.Controls;
2685using WinApp.ViewModel.Services;
2686
2687namespace WinApp.View
2688{
2689  internal class ServicesUC : UserControl, IComponentConnector, IStyleConnector
2690  {
2691    private readonly ServicesControlVM _viewModel;
2692    private bool _contentLoaded;
2693
2694    public ServicesUC()
2695    {
2696      this.InitializeComponent();
2697      this.DataContext = (object) (this._viewModel = new ServicesControlVM());
2698    }
2699
2700    private void Service_OnMouseLeftUp(object sender, MouseButtonEventArgs e)
2701    {
2702      RadTileViewItem radTileViewItem = sender as RadTileViewItem;
2703      if (radTileViewItem == null)
2704        return;
2705      ServiceVM serviceVm = (ServiceVM) null;
2706      if (((FrameworkElement) radTileViewItem).DataContext != null)
2707        serviceVm = ((FrameworkElement) radTileViewItem).DataContext as ServiceVM;
2708      if (serviceVm == null || !serviceVm.IsEnableMainButton || radTileViewItem.get_TileState() == 1)
2709        return;
2710      radTileViewItem.set_TileState((TileViewItemState) 1);
2711    }
2712
2713    private void RadTileView_OnTileStateChanged(object sender, RadRoutedEventArgs e)
2714    {
2715      RadTileViewItem radTileViewItem = ((RoutedEventArgs) e).Source as RadTileViewItem;
2716      if (radTileViewItem == null)
2717        return;
2718      RadFluidContentControl fluidContentControl = Enumerable.SingleOrDefault<RadFluidContentControl>(VisualDescendantsExtention.GetVisualDescendants<RadFluidContentControl>((DependencyObject) radTileViewItem));
2719      if (fluidContentControl == null)
2720        return;
2721      switch ((int) radTileViewItem.get_TileState())
2722      {
2723        case 0:
2724          fluidContentControl.set_State((FluidContentControlState) 1);
2725          break;
2726        case 1:
2727          fluidContentControl.set_State((FluidContentControlState) 2);
2728          break;
2729        case 2:
2730          fluidContentControl.set_State((FluidContentControlState) 0);
2731          break;
2732      }
2733    }
2734
2735    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2736    [DebuggerNonUserCode]
2737    public void InitializeComponent()
2738    {
2739      if (this._contentLoaded)
2740        return;
2741      this._contentLoaded = true;
2742      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/servicesuc.xaml", UriKind.Relative));
2743    }
2744
2745    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2746    [DebuggerNonUserCode]
2747    [EditorBrowsable(EditorBrowsableState.Never)]
2748    void IComponentConnector.Connect(int connectionId, object target)
2749    {
2750      if (connectionId == 1)
2751        ((RadTileView) target).add_TileStateChanged(new EventHandler<RadRoutedEventArgs>(this.RadTileView_OnTileStateChanged));
2752      else
2753        this._contentLoaded = true;
2754    }
2755
2756    [DebuggerNonUserCode]
2757    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2758    [EditorBrowsable(EditorBrowsableState.Never)]
2759    void IStyleConnector.Connect(int connectionId, object target)
2760    {
2761      if (connectionId != 2)
2762        return;
2763      ((Style) target).Setters.Add((SetterBase) new EventSetter()
2764      {
2765        Event = UIElement.MouseLeftButtonUpEvent,
2766        Handler = (Delegate) new MouseButtonEventHandler(this.Service_OnMouseLeftUp)
2767      });
2768      ((Style) target).Setters.Add((SetterBase) new EventSetter()
2769      {
2770        Event = (RoutedEvent) RadTileViewItem.TileStateChangedEvent,
2771        Handler = (Delegate) new EventHandler<RadRoutedEventArgs>(this.RadTileView_OnTileStateChanged)
2772      });
2773    }
2774  }
2775}
2776?// Decompiled with JetBrains decompiler
2777// Type: WinApp.View.SettingsUC
2778// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2779// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2780// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2781
2782using System;
2783using System.CodeDom.Compiler;
2784using System.ComponentModel;
2785using System.Diagnostics;
2786using System.Windows;
2787using System.Windows.Controls;
2788using System.Windows.Markup;
2789using WinApp.ViewModel.Controls;
2790
2791namespace WinApp.View
2792{
2793  internal class SettingsUC : UserControl, IComponentConnector
2794  {
2795    private bool _contentLoaded;
2796
2797    public SettingsVM ViewModel { get; private set; }
2798
2799    public SettingsUC()
2800    {
2801      this.InitializeComponent();
2802      this.DataContext = (object) (this.ViewModel = new SettingsVM());
2803    }
2804
2805    [DebuggerNonUserCode]
2806    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2807    public void InitializeComponent()
2808    {
2809      if (this._contentLoaded)
2810        return;
2811      this._contentLoaded = true;
2812      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/settingsuc.xaml", UriKind.Relative));
2813    }
2814
2815    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2816    [EditorBrowsable(EditorBrowsableState.Never)]
2817    [DebuggerNonUserCode]
2818    void IComponentConnector.Connect(int connectionId, object target)
2819    {
2820      this._contentLoaded = true;
2821    }
2822  }
2823}
2824?// Decompiled with JetBrains decompiler
2825// Type: WinApp.View.MainWindow
2826// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2827// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2828// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2829
2830using Inc.Logging;
2831using IncMap;
2832using System;
2833using System.CodeDom.Compiler;
2834using System.ComponentModel;
2835using System.Diagnostics;
2836using System.Windows;
2837using System.Windows.Controls;
2838using System.Windows.Markup;
2839using Telerik.Windows.Controls;
2840using WinApp.Managers.Interfaces;
2841using WinApp.View.Base;
2842using WinApp.ViewModel;
2843
2844namespace WinApp.View
2845{
2846  internal class MainWindow : WindowCommon, IMainWindow, IComponentConnector
2847  {
2848    private WindowState _lastWindowState;
2849    internal Grid LayoutGrid;
2850    private bool _contentLoaded;
2851
2852    public bool CloseToTray { get; set; }
2853
2854    public MainWindowVM ViewModel { get; private set; }
2855
2856    public MainWindow()
2857    {
2858      this.InitializeComponent();
2859      ((FrameworkElement) this).DataContext = (object) (this.ViewModel = new MainWindowVM(this));
2860      this.CloseToTray = true;
2861      this.LayoutGrid.Children.Add(Map.Get<IAppTray>().Tray);
2862    }
2863
2864    public void Open()
2865    {
2866      if (((WindowBase) this).get_WindowState() == WindowState.Minimized)
2867      {
2868        Logger.WriteInfo(typeof (MainWindow), "Open()", "???????? ?????????? ?? ????");
2869        this.ShowInTaskbar = true;
2870        ((UIElement) this).Visibility = Visibility.Visible;
2871        ((WindowBase) this).set_WindowState(this._lastWindowState != WindowState.Minimized ? this._lastWindowState : WindowState.Normal);
2872      }
2873      ((WindowBase) this).BringToFront();
2874    }
2875
2876    protected virtual void OnPreviewClosed(WindowPreviewClosedEventArgs e)
2877    {
2878      if (!this.CloseToTray)
2879        return;
2880      Logger.WriteInfo(typeof (MainWindow), "OnPreviewClosed()", "???????????? ?????????? ? ????");
2881      e.set_Cancel(new bool?(true));
2882      this._lastWindowState = ((WindowBase) this).get_WindowState();
2883      ((WindowBase) this).set_WindowState(WindowState.Minimized);
2884      ((UIElement) this).Visibility = Visibility.Collapsed;
2885      this.ShowInTaskbar = false;
2886    }
2887
2888    private void Window_Loaded(object sender, RoutedEventArgs e)
2889    {
2890      ((MainWindowVM) ((FrameworkElement) this).DataContext).MainWindowLoaded();
2891    }
2892
2893    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2894    [DebuggerNonUserCode]
2895    public void InitializeComponent()
2896    {
2897      if (this._contentLoaded)
2898        return;
2899      this._contentLoaded = true;
2900      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/mainwindow.xaml", UriKind.Relative));
2901    }
2902
2903    [DebuggerNonUserCode]
2904    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2905    internal Delegate _CreateDelegate(Type delegateType, string handler)
2906    {
2907      return Delegate.CreateDelegate(delegateType, (object) this, handler);
2908    }
2909
2910    [DebuggerNonUserCode]
2911    [EditorBrowsable(EditorBrowsableState.Never)]
2912    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2913    void IComponentConnector.Connect(int connectionId, object target)
2914    {
2915      if (connectionId == 1)
2916        this.LayoutGrid = (Grid) target;
2917      else
2918        this._contentLoaded = true;
2919    }
2920
2921    void IMainWindow.Show()
2922    {
2923      this.Show();
2924    }
2925  }
2926}
2927?// Decompiled with JetBrains decompiler
2928// Type: WinApp.View.VersionUC
2929// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
2930// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
2931// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
2932
2933using System;
2934using System.CodeDom.Compiler;
2935using System.ComponentModel;
2936using System.Diagnostics;
2937using System.Windows;
2938using System.Windows.Controls;
2939using System.Windows.Markup;
2940using WinApp.ViewModel.Controls;
2941
2942namespace WinApp.View
2943{
2944  public class VersionUC : UserControl, IComponentConnector
2945  {
2946    private VersionControlVM _viewModel;
2947    private bool _contentLoaded;
2948
2949    public double WindowHeight
2950    {
2951      get
2952      {
2953        return 400.0;
2954      }
2955    }
2956
2957    public double WindowWidth
2958    {
2959      get
2960      {
2961        return 400.0;
2962      }
2963    }
2964
2965    public ResizeMode ResizeMode
2966    {
2967      get
2968      {
2969        return ResizeMode.CanMinimize;
2970      }
2971    }
2972
2973    public VersionUC(Version appVersionOnSite, Version appVersionCurrent)
2974    {
2975      this.InitializeComponent();
2976      this._viewModel = new VersionControlVM(appVersionOnSite, appVersionCurrent);
2977      this.DataContext = (object) this._viewModel;
2978    }
2979
2980    private void Button_Click(object sender, RoutedEventArgs e)
2981    {
2982      this._viewModel.ButtonOkClick();
2983    }
2984
2985    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2986    [DebuggerNonUserCode]
2987    public void InitializeComponent()
2988    {
2989      if (this._contentLoaded)
2990        return;
2991      this._contentLoaded = true;
2992      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/versionuc.xaml", UriKind.Relative));
2993    }
2994
2995    [EditorBrowsable(EditorBrowsableState.Never)]
2996    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
2997    [DebuggerNonUserCode]
2998    void IComponentConnector.Connect(int connectionId, object target)
2999    {
3000      this._contentLoaded = true;
3001    }
3002  }
3003}
3004?// Decompiled with JetBrains decompiler
3005// Type: WinApp.View.SessionStatisticsUC
3006// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
3007// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
3008// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
3009
3010using System;
3011using System.CodeDom.Compiler;
3012using System.ComponentModel;
3013using System.Diagnostics;
3014using System.Windows;
3015using System.Windows.Controls;
3016using System.Windows.Markup;
3017using WinApp.ViewModel.Controls;
3018
3019namespace WinApp.View
3020{
3021  internal class SessionStatisticsUC : UserControl, IComponentConnector
3022  {
3023    private bool _contentLoaded;
3024
3025    public SessionStatisticsVM ViewModel { get; private set; }
3026
3027    public SessionStatisticsUC()
3028    {
3029      this.InitializeComponent();
3030      this.DataContext = (object) (this.ViewModel = new SessionStatisticsVM());
3031    }
3032
3033    [DebuggerNonUserCode]
3034    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
3035    public void InitializeComponent()
3036    {
3037      if (this._contentLoaded)
3038        return;
3039      this._contentLoaded = true;
3040      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/view/sessionstatisticsuc.xaml", UriKind.Relative));
3041    }
3042
3043    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
3044    [EditorBrowsable(EditorBrowsableState.Never)]
3045    [DebuggerNonUserCode]
3046    void IComponentConnector.Connect(int connectionId, object target)
3047    {
3048      this._contentLoaded = true;
3049    }
3050  }
3051}
3052?// Decompiled with JetBrains decompiler
3053// Type: WinApp.Tray.RichNotifyIcon.RoutedEventHelper
3054// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
3055// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
3056// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
3057
3058using System;
3059using System.Windows;
3060
3061namespace WinApp.Tray.RichNotifyIcon
3062{
3063  internal static class RoutedEventHelper
3064  {
3065    internal static void RaiseEvent(DependencyObject target, RoutedEventArgs args)
3066    {
3067      if (target is UIElement)
3068      {
3069        (target as UIElement).RaiseEvent(args);
3070      }
3071      else
3072      {
3073        if (!(target is ContentElement))
3074          return;
3075        (target as ContentElement).RaiseEvent(args);
3076      }
3077    }
3078
3079    internal static void AddHandler(DependencyObject element, RoutedEvent routedEvent, Delegate handler)
3080    {
3081      UIElement uiElement = element as UIElement;
3082      if (uiElement != null)
3083      {
3084        uiElement.AddHandler(routedEvent, handler);
3085      }
3086      else
3087      {
3088        ContentElement contentElement = element as ContentElement;
3089        if (contentElement == null)
3090          return;
3091        contentElement.AddHandler(routedEvent, handler);
3092      }
3093    }
3094
3095    internal static void RemoveHandler(DependencyObject element, RoutedEvent routedEvent, Delegate handler)
3096    {
3097      UIElement uiElement = element as UIElement;
3098      if (uiElement != null)
3099      {
3100        uiElement.RemoveHandler(routedEvent, handler);
3101      }
3102      else
3103      {
3104        ContentElement contentElement = element as ContentElement;
3105        if (contentElement == null)
3106          return;
3107        contentElement.RemoveHandler(routedEvent, handler);
3108      }
3109    }
3110  }
3111}
3112?// Decompiled with JetBrains decompiler
3113// Type: WinApp.Tray.RichNotifyIcon.PopupActivationMode
3114// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
3115// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
3116// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
3117
3118namespace WinApp.Tray.RichNotifyIcon
3119{
3120  public enum PopupActivationMode
3121  {
3122    LeftClick,
3123    RightClick,
3124    DoubleClick,
3125    LeftOrRightClick,
3126    LeftOrDoubleClick,
3127    MiddleClick,
3128    All,
3129  }
3130}
3131?// Decompiled with JetBrains decompiler
3132// Type: WinApp.Tray.RichNotifyIcon.TaskbarIcon
3133// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
3134// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
3135// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
3136
3137using System;
3138using System.ComponentModel;
3139using System.Drawing;
3140using System.Threading;
3141using System.Windows;
3142using System.Windows.Controls;
3143using System.Windows.Controls.Primitives;
3144using System.Windows.Input;
3145using System.Windows.Interop;
3146using System.Windows.Media;
3147using System.Windows.Threading;
3148using WinApp.Tray.RichNotifyIcon.Interop;
3149
3150namespace WinApp.Tray.RichNotifyIcon
3151{
3152  public class TaskbarIcon : FrameworkElement, IDisposable
3153  {
3154    private static readonly DependencyPropertyKey TrayPopupResolvedPropertyKey = DependencyProperty.RegisterReadOnly("TrayPopupResolved", typeof (Popup), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3155    public static readonly DependencyProperty TrayPopupResolvedProperty = TaskbarIcon.TrayPopupResolvedPropertyKey.DependencyProperty;
3156    private static readonly DependencyPropertyKey TrayToolTipResolvedPropertyKey = DependencyProperty.RegisterReadOnly("TrayToolTipResolved", typeof (ToolTip), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3157    public static readonly DependencyProperty TrayToolTipResolvedProperty = TaskbarIcon.TrayToolTipResolvedPropertyKey.DependencyProperty;
3158    private static readonly DependencyPropertyKey CustomBalloonPropertyKey = DependencyProperty.RegisterReadOnly("CustomBalloon", typeof (Popup), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3159    public static readonly DependencyProperty CustomBalloonProperty = TaskbarIcon.CustomBalloonPropertyKey.DependencyProperty;
3160    public static readonly DependencyProperty IconSourceProperty = DependencyProperty.Register("IconSource", typeof (ImageSource), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) null, new PropertyChangedCallback(TaskbarIcon.IconSourcePropertyChanged)));
3161    public static readonly DependencyProperty ToolTipTextProperty = DependencyProperty.Register("ToolTipText", typeof (string), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) string.Empty, new PropertyChangedCallback(TaskbarIcon.ToolTipTextPropertyChanged)));
3162    public static readonly DependencyProperty TrayToolTipProperty = DependencyProperty.Register("TrayToolTip", typeof (UIElement), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) null, new PropertyChangedCallback(TaskbarIcon.TrayToolTipPropertyChanged)));
3163    public static readonly DependencyProperty TrayPopupProperty = DependencyProperty.Register("TrayPopup", typeof (UIElement), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) null, new PropertyChangedCallback(TaskbarIcon.TrayPopupPropertyChanged)));
3164    public static readonly DependencyProperty MenuActivationProperty = DependencyProperty.Register("MenuActivation", typeof (PopupActivationMode), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) PopupActivationMode.RightClick));
3165    public static readonly DependencyProperty PopupActivationProperty = DependencyProperty.Register("PopupActivation", typeof (PopupActivationMode), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) PopupActivationMode.LeftClick));
3166    public static readonly DependencyProperty DoubleClickCommandProperty = DependencyProperty.Register("DoubleClickCommand", typeof (ICommand), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3167    public static readonly DependencyProperty DoubleClickCommandParameterProperty = DependencyProperty.Register("DoubleClickCommandParameter", typeof (object), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3168    public static readonly DependencyProperty DoubleClickCommandTargetProperty = DependencyProperty.Register("DoubleClickCommandTarget", typeof (IInputElement), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3169    public static readonly DependencyProperty LeftClickCommandProperty = DependencyProperty.Register("LeftClickCommand", typeof (ICommand), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3170    public static readonly DependencyProperty LeftClickCommandParameterProperty = DependencyProperty.Register("LeftClickCommandParameter", typeof (object), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3171    public static readonly DependencyProperty LeftClickCommandTargetProperty = DependencyProperty.Register("LeftClickCommandTarget", typeof (IInputElement), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((PropertyChangedCallback) null));
3172    public static readonly RoutedEvent TrayLeftMouseDownEvent = EventManager.RegisterRoutedEvent("TrayLeftMouseDown", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3173    public static readonly RoutedEvent TrayRightMouseDownEvent = EventManager.RegisterRoutedEvent("TrayRightMouseDown", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3174    public static readonly RoutedEvent TrayMiddleMouseDownEvent = EventManager.RegisterRoutedEvent("TrayMiddleMouseDown", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3175    public static readonly RoutedEvent TrayLeftMouseUpEvent = EventManager.RegisterRoutedEvent("TrayLeftMouseUp", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3176    public static readonly RoutedEvent TrayRightMouseUpEvent = EventManager.RegisterRoutedEvent("TrayRightMouseUp", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3177    public static readonly RoutedEvent TrayMiddleMouseUpEvent = EventManager.RegisterRoutedEvent("TrayMiddleMouseUp", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3178    public static readonly RoutedEvent TrayMouseDoubleClickEvent = EventManager.RegisterRoutedEvent("TrayMouseDoubleClick", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3179    public static readonly RoutedEvent TrayMouseMoveEvent = EventManager.RegisterRoutedEvent("TrayMouseMove", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3180    public static readonly RoutedEvent TrayBalloonTipShownEvent = EventManager.RegisterRoutedEvent("TrayBalloonTipShown", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3181    public static readonly RoutedEvent TrayBalloonTipClosedEvent = EventManager.RegisterRoutedEvent("TrayBalloonTipClosed", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3182    public static readonly RoutedEvent TrayBalloonTipClickedEvent = EventManager.RegisterRoutedEvent("TrayBalloonTipClicked", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3183    public static readonly RoutedEvent TrayContextMenuOpenEvent = EventManager.RegisterRoutedEvent("TrayContextMenuOpen", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3184    public static readonly RoutedEvent PreviewTrayContextMenuOpenEvent = EventManager.RegisterRoutedEvent("PreviewTrayContextMenuOpen", RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3185    public static readonly RoutedEvent TrayPopupOpenEvent = EventManager.RegisterRoutedEvent("TrayPopupOpen", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3186    public static readonly RoutedEvent PreviewTrayPopupOpenEvent = EventManager.RegisterRoutedEvent("PreviewTrayPopupOpen", RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3187    public static readonly RoutedEvent TrayToolTipOpenEvent = EventManager.RegisterRoutedEvent("TrayToolTipOpen", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3188    public static readonly RoutedEvent PreviewTrayToolTipOpenEvent = EventManager.RegisterRoutedEvent("PreviewTrayToolTipOpen", RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3189    public static readonly RoutedEvent TrayToolTipCloseEvent = EventManager.RegisterRoutedEvent("TrayToolTipClose", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3190    public static readonly RoutedEvent PreviewTrayToolTipCloseEvent = EventManager.RegisterRoutedEvent("PreviewTrayToolTipClose", RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3191    public static readonly RoutedEvent PopupOpenedEvent = EventManager.RegisterRoutedEvent("PopupOpened", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3192    public static readonly RoutedEvent ToolTipOpenedEvent = EventManager.RegisterRoutedEvent("ToolTipOpened", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3193    public static readonly RoutedEvent ToolTipCloseEvent = EventManager.RegisterRoutedEvent("ToolTipClose", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3194    public static readonly RoutedEvent BalloonShowingEvent = EventManager.RegisterRoutedEvent("BalloonShowing", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3195    public static readonly RoutedEvent BalloonClosingEvent = EventManager.RegisterRoutedEvent("BalloonClosing", RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
3196    public static readonly DependencyProperty ParentTaskbarIconProperty = DependencyProperty.RegisterAttached("ParentTaskbarIcon", typeof (TaskbarIcon), typeof (TaskbarIcon), (PropertyMetadata) new FrameworkPropertyMetadata((object) null, FrameworkPropertyMetadataOptions.Inherits));
3197    private double scalingFactor = double.NaN;
3198    public const string CategoryName = "NotifyIcon";
3199    private NotifyIconData iconData;
3200    private readonly WindowMessageSink messageSink;
3201    private Action singleClickTimerAction;
3202    private readonly Timer singleClickTimer;
3203    private readonly Timer balloonCloseTimer;
3204    private Icon icon;
3205
3206    public bool IsTaskbarIconCreated { get; private set; }
3207
3208    public bool SupportsCustomToolTips
3209    {
3210      get
3211      {
3212        return this.messageSink.Version == NotifyIconVersion.Vista;
3213      }
3214    }
3215
3216    private bool IsPopupOpen
3217    {
3218      get
3219      {
3220        Popup trayPopupResolved = this.TrayPopupResolved;
3221        ContextMenu contextMenu = this.ContextMenu;
3222        Popup customBalloon = this.CustomBalloon;
3223        if (trayPopupResolved != null && trayPopupResolved.IsOpen || contextMenu != null && contextMenu.IsOpen)
3224          return true;
3225        if (customBalloon != null)
3226          return customBalloon.IsOpen;
3227        return false;
3228      }
3229    }
3230
3231    public bool IsDisposed { get; private set; }
3232
3233    [Category("NotifyIcon")]
3234    public Popup TrayPopupResolved
3235    {
3236      get
3237      {
3238        return (Popup) this.GetValue(TaskbarIcon.TrayPopupResolvedProperty);
3239      }
3240    }
3241
3242    [Browsable(true)]
3243    [Bindable(true)]
3244    [Category("NotifyIcon")]
3245    public ToolTip TrayToolTipResolved
3246    {
3247      get
3248      {
3249        return (ToolTip) this.GetValue(TaskbarIcon.TrayToolTipResolvedProperty);
3250      }
3251    }
3252
3253    public Popup CustomBalloon
3254    {
3255      get
3256      {
3257        return (Popup) this.GetValue(TaskbarIcon.CustomBalloonProperty);
3258      }
3259    }
3260
3261    [Browsable(false)]
3262    public Icon Icon
3263    {
3264      get
3265      {
3266        return this.icon;
3267      }
3268      set
3269      {
3270        this.icon = value;
3271        this.iconData.IconHandle = value == null ? IntPtr.Zero : this.icon.Handle;
3272        Util.WriteIconData(ref this.iconData, NotifyCommand.Modify, IconDataMembers.Icon);
3273      }
3274    }
3275
3276    [Description("Sets the displayed taskbar icon.")]
3277    [Category("NotifyIcon")]
3278    public ImageSource IconSource
3279    {
3280      get
3281      {
3282        return (ImageSource) this.GetValue(TaskbarIcon.IconSourceProperty);
3283      }
3284      set
3285      {
3286        this.SetValue(TaskbarIcon.IconSourceProperty, (object) value);
3287      }
3288    }
3289
3290    [Category("NotifyIcon")]
3291    [Description("Alternative to a fully blown ToolTip, which is only displayed on Vista and above.")]
3292    public string ToolTipText
3293    {
3294      get
3295      {
3296        return (string) this.GetValue(TaskbarIcon.ToolTipTextProperty);
3297      }
3298      set
3299      {
3300        this.SetValue(TaskbarIcon.ToolTipTextProperty, (object) value);
3301      }
3302    }
3303
3304    [Category("NotifyIcon")]
3305    [Description("Custom UI element that is displayed as a tooltip. Only on Vista and above")]
3306    public UIElement TrayToolTip
3307    {
3308      get
3309      {
3310        return (UIElement) this.GetValue(TaskbarIcon.TrayToolTipProperty);
3311      }
3312      set
3313      {
3314        this.SetValue(TaskbarIcon.TrayToolTipProperty, (object) value);
3315      }
3316    }
3317
3318    [Category("NotifyIcon")]
3319    [Description("Displayed as a Popup if the user clicks on the taskbar icon.")]
3320    public UIElement TrayPopup
3321    {
3322      get
3323      {
3324        return (UIElement) this.GetValue(TaskbarIcon.TrayPopupProperty);
3325      }
3326      set
3327      {
3328        this.SetValue(TaskbarIcon.TrayPopupProperty, (object) value);
3329      }
3330    }
3331
3332    [Category("NotifyIcon")]
3333    [Description("Defines what mouse events display the context menu.")]
3334    public PopupActivationMode MenuActivation
3335    {
3336      get
3337      {
3338        return (PopupActivationMode) this.GetValue(TaskbarIcon.MenuActivationProperty);
3339      }
3340      set
3341      {
3342        this.SetValue(TaskbarIcon.MenuActivationProperty, (object) value);
3343      }
3344    }
3345
3346    [Category("NotifyIcon")]
3347    [Description("Defines what mouse events display the TaskbarIconPopup.")]
3348    public PopupActivationMode PopupActivation
3349    {
3350      get
3351      {
3352        return (PopupActivationMode) this.GetValue(TaskbarIcon.PopupActivationProperty);
3353      }
3354      set
3355      {
3356        this.SetValue(TaskbarIcon.PopupActivationProperty, (object) value);
3357      }
3358    }
3359
3360    [Category("NotifyIcon")]
3361    [Description("A command that is being executed if the tray icon is being double-clicked.")]
3362    public ICommand DoubleClickCommand
3363    {
3364      get
3365      {
3366        return (ICommand) this.GetValue(TaskbarIcon.DoubleClickCommandProperty);
3367      }
3368      set
3369      {
3370        this.SetValue(TaskbarIcon.DoubleClickCommandProperty, (object) value);
3371      }
3372    }
3373
3374    [Category("NotifyIcon")]
3375    [Description("Parameter to submit to the DoubleClickCommand when the user double clicks on the NotifyIcon.")]
3376    public object DoubleClickCommandParameter
3377    {
3378      get
3379      {
3380        return this.GetValue(TaskbarIcon.DoubleClickCommandParameterProperty);
3381      }
3382      set
3383      {
3384        this.SetValue(TaskbarIcon.DoubleClickCommandParameterProperty, value);
3385      }
3386    }
3387
3388    [Category("NotifyIcon")]
3389    [Description("The target of the command that is fired if the notify icon is double clicked.")]
3390    public IInputElement DoubleClickCommandTarget
3391    {
3392      get
3393      {
3394        return (IInputElement) this.GetValue(TaskbarIcon.DoubleClickCommandTargetProperty);
3395      }
3396      set
3397      {
3398        this.SetValue(TaskbarIcon.DoubleClickCommandTargetProperty, (object) value);
3399      }
3400    }
3401
3402    [Category("NotifyIcon")]
3403    [Description("A command that is being executed if the tray icon is being left-clicked.")]
3404    public ICommand LeftClickCommand
3405    {
3406      get
3407      {
3408        return (ICommand) this.GetValue(TaskbarIcon.LeftClickCommandProperty);
3409      }
3410      set
3411      {
3412        this.SetValue(TaskbarIcon.LeftClickCommandProperty, (object) value);
3413      }
3414    }
3415
3416    [Description("The target of the command that is fired if the notify icon is clicked with the left mouse button.")]
3417    [Category("NotifyIcon")]
3418    public object LeftClickCommandParameter
3419    {
3420      get
3421      {
3422        return this.GetValue(TaskbarIcon.LeftClickCommandParameterProperty);
3423      }
3424      set
3425      {
3426        this.SetValue(TaskbarIcon.LeftClickCommandParameterProperty, value);
3427      }
3428    }
3429
3430    [Category("NotifyIcon")]
3431    [Description("The target of the command that is fired if the notify icon is clicked with the left mouse button.")]
3432    public IInputElement LeftClickCommandTarget
3433    {
3434      get
3435      {
3436        return (IInputElement) this.GetValue(TaskbarIcon.LeftClickCommandTargetProperty);
3437      }
3438      set
3439      {
3440        this.SetValue(TaskbarIcon.LeftClickCommandTargetProperty, (object) value);
3441      }
3442    }
3443
3444    [Category("NotifyIcon")]
3445    public event RoutedEventHandler TrayLeftMouseDown
3446    {
3447      add
3448      {
3449        this.AddHandler(TaskbarIcon.TrayLeftMouseDownEvent, (Delegate) value);
3450      }
3451      remove
3452      {
3453        this.RemoveHandler(TaskbarIcon.TrayLeftMouseDownEvent, (Delegate) value);
3454      }
3455    }
3456
3457    public event RoutedEventHandler TrayRightMouseDown
3458    {
3459      add
3460      {
3461        this.AddHandler(TaskbarIcon.TrayRightMouseDownEvent, (Delegate) value);
3462      }
3463      remove
3464      {
3465        this.RemoveHandler(TaskbarIcon.TrayRightMouseDownEvent, (Delegate) value);
3466      }
3467    }
3468
3469    public event RoutedEventHandler TrayMiddleMouseDown
3470    {
3471      add
3472      {
3473        this.AddHandler(TaskbarIcon.TrayMiddleMouseDownEvent, (Delegate) value);
3474      }
3475      remove
3476      {
3477        this.RemoveHandler(TaskbarIcon.TrayMiddleMouseDownEvent, (Delegate) value);
3478      }
3479    }
3480
3481    public event RoutedEventHandler TrayLeftMouseUp
3482    {
3483      add
3484      {
3485        this.AddHandler(TaskbarIcon.TrayLeftMouseUpEvent, (Delegate) value);
3486      }
3487      remove
3488      {
3489        this.RemoveHandler(TaskbarIcon.TrayLeftMouseUpEvent, (Delegate) value);
3490      }
3491    }
3492
3493    public event RoutedEventHandler TrayRightMouseUp
3494    {
3495      add
3496      {
3497        this.AddHandler(TaskbarIcon.TrayRightMouseUpEvent, (Delegate) value);
3498      }
3499      remove
3500      {
3501        this.RemoveHandler(TaskbarIcon.TrayRightMouseUpEvent, (Delegate) value);
3502      }
3503    }
3504
3505    public event RoutedEventHandler TrayMiddleMouseUp
3506    {
3507      add
3508      {
3509        this.AddHandler(TaskbarIcon.TrayMiddleMouseUpEvent, (Delegate) value);
3510      }
3511      remove
3512      {
3513        this.RemoveHandler(TaskbarIcon.TrayMiddleMouseUpEvent, (Delegate) value);
3514      }
3515    }
3516
3517    public event RoutedEventHandler TrayMouseDoubleClick
3518    {
3519      add
3520      {
3521        this.AddHandler(TaskbarIcon.TrayMouseDoubleClickEvent, (Delegate) value);
3522      }
3523      remove
3524      {
3525        this.RemoveHandler(TaskbarIcon.TrayMouseDoubleClickEvent, (Delegate) value);
3526      }
3527    }
3528
3529    public event RoutedEventHandler TrayMouseMove
3530    {
3531      add
3532      {
3533        this.AddHandler(TaskbarIcon.TrayMouseMoveEvent, (Delegate) value);
3534      }
3535      remove
3536      {
3537        this.RemoveHandler(TaskbarIcon.TrayMouseMoveEvent, (Delegate) value);
3538      }
3539    }
3540
3541    public event RoutedEventHandler TrayBalloonTipShown
3542    {
3543      add
3544      {
3545        this.AddHandler(TaskbarIcon.TrayBalloonTipShownEvent, (Delegate) value);
3546      }
3547      remove
3548      {
3549        this.RemoveHandler(TaskbarIcon.TrayBalloonTipShownEvent, (Delegate) value);
3550      }
3551    }
3552
3553    public event RoutedEventHandler TrayBalloonTipClosed
3554    {
3555      add
3556      {
3557        this.AddHandler(TaskbarIcon.TrayBalloonTipClosedEvent, (Delegate) value);
3558      }
3559      remove
3560      {
3561        this.RemoveHandler(TaskbarIcon.TrayBalloonTipClosedEvent, (Delegate) value);
3562      }
3563    }
3564
3565    public event RoutedEventHandler TrayBalloonTipClicked
3566    {
3567      add
3568      {
3569        this.AddHandler(TaskbarIcon.TrayBalloonTipClickedEvent, (Delegate) value);
3570      }
3571      remove
3572      {
3573        this.RemoveHandler(TaskbarIcon.TrayBalloonTipClickedEvent, (Delegate) value);
3574      }
3575    }
3576
3577    public event RoutedEventHandler TrayContextMenuOpen
3578    {
3579      add
3580      {
3581        this.AddHandler(TaskbarIcon.TrayContextMenuOpenEvent, (Delegate) value);
3582      }
3583      remove
3584      {
3585        this.RemoveHandler(TaskbarIcon.TrayContextMenuOpenEvent, (Delegate) value);
3586      }
3587    }
3588
3589    public event RoutedEventHandler PreviewTrayContextMenuOpen
3590    {
3591      add
3592      {
3593        this.AddHandler(TaskbarIcon.PreviewTrayContextMenuOpenEvent, (Delegate) value);
3594      }
3595      remove
3596      {
3597        this.RemoveHandler(TaskbarIcon.PreviewTrayContextMenuOpenEvent, (Delegate) value);
3598      }
3599    }
3600
3601    public event RoutedEventHandler TrayPopupOpen
3602    {
3603      add
3604      {
3605        this.AddHandler(TaskbarIcon.TrayPopupOpenEvent, (Delegate) value);
3606      }
3607      remove
3608      {
3609        this.RemoveHandler(TaskbarIcon.TrayPopupOpenEvent, (Delegate) value);
3610      }
3611    }
3612
3613    public event RoutedEventHandler PreviewTrayPopupOpen
3614    {
3615      add
3616      {
3617        this.AddHandler(TaskbarIcon.PreviewTrayPopupOpenEvent, (Delegate) value);
3618      }
3619      remove
3620      {
3621        this.RemoveHandler(TaskbarIcon.PreviewTrayPopupOpenEvent, (Delegate) value);
3622      }
3623    }
3624
3625    public event RoutedEventHandler TrayToolTipOpen
3626    {
3627      add
3628      {
3629        this.AddHandler(TaskbarIcon.TrayToolTipOpenEvent, (Delegate) value);
3630      }
3631      remove
3632      {
3633        this.RemoveHandler(TaskbarIcon.TrayToolTipOpenEvent, (Delegate) value);
3634      }
3635    }
3636
3637    public event RoutedEventHandler PreviewTrayToolTipOpen
3638    {
3639      add
3640      {
3641        this.AddHandler(TaskbarIcon.PreviewTrayToolTipOpenEvent, (Delegate) value);
3642      }
3643      remove
3644      {
3645        this.RemoveHandler(TaskbarIcon.PreviewTrayToolTipOpenEvent, (Delegate) value);
3646      }
3647    }
3648
3649    public event RoutedEventHandler TrayToolTipClose
3650    {
3651      add
3652      {
3653        this.AddHandler(TaskbarIcon.TrayToolTipCloseEvent, (Delegate) value);
3654      }
3655      remove
3656      {
3657        this.RemoveHandler(TaskbarIcon.TrayToolTipCloseEvent, (Delegate) value);
3658      }
3659    }
3660
3661    public event RoutedEventHandler PreviewTrayToolTipClose
3662    {
3663      add
3664      {
3665        this.AddHandler(TaskbarIcon.PreviewTrayToolTipCloseEvent, (Delegate) value);
3666      }
3667      remove
3668      {
3669        this.RemoveHandler(TaskbarIcon.PreviewTrayToolTipCloseEvent, (Delegate) value);
3670      }
3671    }
3672
3673    static TaskbarIcon()
3674    {
3675      PropertyMetadata typeMetadata1 = new PropertyMetadata((object) Visibility.Visible, new PropertyChangedCallback(TaskbarIcon.VisibilityPropertyChanged));
3676      UIElement.VisibilityProperty.OverrideMetadata(typeof (TaskbarIcon), typeMetadata1);
3677      PropertyMetadata typeMetadata2 = (PropertyMetadata) new FrameworkPropertyMetadata(new PropertyChangedCallback(TaskbarIcon.DataContextPropertyChanged));
3678      FrameworkElement.DataContextProperty.OverrideMetadata(typeof (TaskbarIcon), typeMetadata2);
3679      PropertyMetadata typeMetadata3 = (PropertyMetadata) new FrameworkPropertyMetadata(new PropertyChangedCallback(TaskbarIcon.ContextMenuPropertyChanged));
3680      FrameworkElement.ContextMenuProperty.OverrideMetadata(typeof (TaskbarIcon), typeMetadata3);
3681    }
3682
3683    public TaskbarIcon()
3684    {
3685      this.messageSink = Util.IsDesignMode ? WindowMessageSink.CreateEmpty() : new WindowMessageSink(NotifyIconVersion.Win95);
3686      this.iconData = NotifyIconData.CreateDefault(this.messageSink.MessageWindowHandle);
3687      this.CreateTaskbarIcon();
3688      this.messageSink.MouseEventReceived += new Action<MouseEvent>(this.OnMouseEvent);
3689      this.messageSink.TaskbarCreated += new Action(this.OnTaskbarCreated);
3690      this.messageSink.ChangeToolTipStateRequest += new Action<bool>(this.OnToolTipChange);
3691      this.messageSink.BalloonToolTipChanged += new Action<bool>(this.OnBalloonToolTipChanged);
3692      this.singleClickTimer = new Timer(new TimerCallback(this.DoSingleClickAction));
3693      this.balloonCloseTimer = new Timer(new TimerCallback(this.CloseBalloonCallback));
3694      if (Application.Current == null)
3695        return;
3696      Application.Current.Exit += new ExitEventHandler(this.OnExit);
3697    }
3698
3699    ~TaskbarIcon()
3700    {
3701      this.Dispose(false);
3702    }
3703
3704    public void ShowCustomBalloon(UIElement balloon, PopupAnimation animation, int? timeout)
3705    {
3706      Dispatcher dispatcher = Util.GetDispatcher((DispatcherObject) this);
3707      if (!dispatcher.CheckAccess())
3708      {
3709        Action action = (Action) (() => this.ShowCustomBalloon(balloon, animation, timeout));
3710        dispatcher.Invoke(DispatcherPriority.Normal, (Delegate) action);
3711      }
3712      else
3713      {
3714        if (balloon == null)
3715          throw new ArgumentNullException("balloon");
3716        if (timeout.HasValue)
3717        {
3718          int? nullable = timeout;
3719          if ((nullable.GetValueOrDefault() >= 500 ? 0 : (nullable.HasValue ? 1 : 0)) != 0)
3720            throw new ArgumentOutOfRangeException("timeout", string.Format("Invalid timeout of {0} milliseconds. Timeout must be at least 500 ms", (object) timeout));
3721        }
3722        this.EnsureNotDisposed();
3723        lock (this)
3724          this.CloseBalloon();
3725        Popup popup1 = new Popup();
3726        popup1.AllowsTransparency = true;
3727        this.UpdateDataContext((FrameworkElement) popup1, (object) null, this.DataContext);
3728        popup1.PopupAnimation = animation;
3729        Popup popup2 = LogicalTreeHelper.GetParent((DependencyObject) balloon) as Popup;
3730        if (popup2 != null)
3731          popup2.Child = (UIElement) null;
3732        if (popup2 != null)
3733          throw new InvalidOperationException(string.Format("Cannot display control [{0}] in a new balloon popup - that control already has a parent. You may consider creating new balloons every time you want to show one.", (object) balloon));
3734        popup1.Child = balloon;
3735        popup1.Placement = PlacementMode.AbsolutePoint;
3736        popup1.StaysOpen = true;
3737        WinApp.Tray.RichNotifyIcon.Interop.Point deviceCoordinates = this.GetDeviceCoordinates(TrayInfo.GetTrayLocation());
3738        popup1.HorizontalOffset = (double) (deviceCoordinates.X - 1);
3739        popup1.VerticalOffset = (double) (deviceCoordinates.Y - 1);
3740        lock (this)
3741          this.SetCustomBalloon(popup1);
3742        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) balloon, this);
3743        TaskbarIcon.RaiseBalloonShowingEvent((DependencyObject) balloon, this);
3744        popup1.IsOpen = true;
3745        if (!timeout.HasValue)
3746          return;
3747        this.balloonCloseTimer.Change(timeout.Value, -1);
3748      }
3749    }
3750
3751    public void ResetBalloonCloseTimer()
3752    {
3753      if (this.IsDisposed)
3754        return;
3755      lock (this)
3756        this.balloonCloseTimer.Change(-1, -1);
3757    }
3758
3759    public void CloseBalloon()
3760    {
3761      if (this.IsDisposed)
3762        return;
3763      Dispatcher dispatcher = Util.GetDispatcher((DispatcherObject) this);
3764      if (!dispatcher.CheckAccess())
3765      {
3766        Action action = new Action(this.CloseBalloon);
3767        dispatcher.Invoke(DispatcherPriority.Normal, (Delegate) action);
3768      }
3769      else
3770      {
3771        lock (this)
3772        {
3773          this.balloonCloseTimer.Change(-1, -1);
3774          Popup local_2 = this.CustomBalloon;
3775          if (local_2 == null)
3776            return;
3777          UIElement local_3 = local_2.Child;
3778          if (!TaskbarIcon.RaiseBalloonClosingEvent((DependencyObject) local_3, this).Handled)
3779          {
3780            local_2.IsOpen = false;
3781            local_2.Child = (UIElement) null;
3782            if (local_3 != null)
3783              TaskbarIcon.SetParentTaskbarIcon((DependencyObject) local_3, (TaskbarIcon) null);
3784          }
3785          this.SetCustomBalloon((Popup) null);
3786        }
3787      }
3788    }
3789
3790    private void CloseBalloonCallback(object state)
3791    {
3792      if (this.IsDisposed)
3793        return;
3794      Util.GetDispatcher((DispatcherObject) this).Invoke((Delegate) new Action(this.CloseBalloon));
3795    }
3796
3797    private void OnMouseEvent(MouseEvent me)
3798    {
3799      if (this.IsDisposed)
3800        return;
3801      switch (me)
3802      {
3803        case MouseEvent.MouseMove:
3804          this.RaiseTrayMouseMoveEvent();
3805          return;
3806        case MouseEvent.IconRightMouseDown:
3807          this.RaiseTrayRightMouseDownEvent();
3808          break;
3809        case MouseEvent.IconLeftMouseDown:
3810          this.RaiseTrayLeftMouseDownEvent();
3811          break;
3812        case MouseEvent.IconRightMouseUp:
3813          this.RaiseTrayRightMouseUpEvent();
3814          break;
3815        case MouseEvent.IconLeftMouseUp:
3816          this.RaiseTrayLeftMouseUpEvent();
3817          break;
3818        case MouseEvent.IconMiddleMouseDown:
3819          this.RaiseTrayMiddleMouseDownEvent();
3820          break;
3821        case MouseEvent.IconMiddleMouseUp:
3822          this.RaiseTrayMiddleMouseUpEvent();
3823          break;
3824        case MouseEvent.IconDoubleClick:
3825          this.singleClickTimer.Change(-1, -1);
3826          this.RaiseTrayMouseDoubleClickEvent();
3827          break;
3828        case MouseEvent.BalloonToolTipClicked:
3829          this.RaiseTrayBalloonTipClickedEvent();
3830          break;
3831        default:
3832          throw new ArgumentOutOfRangeException("me", "Missing handler for mouse event flag: " + (object) me);
3833      }
3834      WinApp.Tray.RichNotifyIcon.Interop.Point cursorPosition = new WinApp.Tray.RichNotifyIcon.Interop.Point();
3835      if (this.messageSink.Version == NotifyIconVersion.Vista)
3836        WinApi.GetPhysicalCursorPos(ref cursorPosition);
3837      else
3838        WinApi.GetCursorPos(ref cursorPosition);
3839      cursorPosition = this.GetDeviceCoordinates(cursorPosition);
3840      bool flag = false;
3841      if (Util.IsMatch(me, this.PopupActivation))
3842      {
3843        if (me == MouseEvent.IconLeftMouseUp)
3844        {
3845          this.singleClickTimerAction = (Action) (() =>
3846          {
3847            Util.ExecuteIfEnabled(this.LeftClickCommand, this.LeftClickCommandParameter, this.LeftClickCommandTarget ?? (IInputElement) this);
3848            this.ShowTrayPopup(cursorPosition);
3849          });
3850          this.singleClickTimer.Change(WinApi.GetDoubleClickTime(), -1);
3851          flag = true;
3852        }
3853        else
3854          this.ShowTrayPopup(cursorPosition);
3855      }
3856      if (Util.IsMatch(me, this.MenuActivation))
3857      {
3858        if (me == MouseEvent.IconLeftMouseUp)
3859        {
3860          this.singleClickTimerAction = (Action) (() =>
3861          {
3862            Util.ExecuteIfEnabled(this.LeftClickCommand, this.LeftClickCommandParameter, this.LeftClickCommandTarget ?? (IInputElement) this);
3863            this.ShowContextMenu(cursorPosition);
3864          });
3865          this.singleClickTimer.Change(WinApi.GetDoubleClickTime(), -1);
3866          flag = true;
3867        }
3868        else
3869          this.ShowContextMenu(cursorPosition);
3870      }
3871      if (me != MouseEvent.IconLeftMouseUp || flag)
3872        return;
3873      this.singleClickTimerAction = (Action) (() => Util.ExecuteIfEnabled(this.LeftClickCommand, this.LeftClickCommandParameter, this.LeftClickCommandTarget ?? (IInputElement) this));
3874      this.singleClickTimer.Change(WinApi.GetDoubleClickTime(), -1);
3875    }
3876
3877    private void OnToolTipChange(bool visible)
3878    {
3879      if (this.TrayToolTipResolved == null)
3880        return;
3881      if (visible)
3882      {
3883        if (this.IsPopupOpen || this.RaisePreviewTrayToolTipOpenEvent().Handled)
3884          return;
3885        this.TrayToolTipResolved.IsOpen = true;
3886        if (this.TrayToolTip != null)
3887          TaskbarIcon.RaiseToolTipOpenedEvent((DependencyObject) this.TrayToolTip);
3888        this.RaiseTrayToolTipOpenEvent();
3889      }
3890      else
3891      {
3892        if (this.RaisePreviewTrayToolTipCloseEvent().Handled)
3893          return;
3894        if (this.TrayToolTip != null)
3895          TaskbarIcon.RaiseToolTipCloseEvent((DependencyObject) this.TrayToolTip);
3896        this.TrayToolTipResolved.IsOpen = false;
3897        this.RaiseTrayToolTipCloseEvent();
3898      }
3899    }
3900
3901    private void CreateCustomToolTip()
3902    {
3903      ToolTip toolTip = this.TrayToolTip as ToolTip;
3904      if (toolTip == null && this.TrayToolTip != null)
3905      {
3906        toolTip = new ToolTip();
3907        toolTip.Placement = PlacementMode.Mouse;
3908        toolTip.HasDropShadow = false;
3909        toolTip.BorderThickness = new Thickness(0.0);
3910        toolTip.Background = (System.Windows.Media.Brush) System.Windows.Media.Brushes.Transparent;
3911        toolTip.StaysOpen = true;
3912        toolTip.Content = (object) this.TrayToolTip;
3913      }
3914      else if (toolTip == null && !string.IsNullOrEmpty(this.ToolTipText))
3915      {
3916        toolTip = new ToolTip();
3917        toolTip.Content = (object) this.ToolTipText;
3918      }
3919      if (toolTip != null)
3920        this.UpdateDataContext((FrameworkElement) toolTip, (object) null, this.DataContext);
3921      this.SetTrayToolTipResolved(toolTip);
3922    }
3923
3924    private void WriteToolTipSettings()
3925    {
3926      this.iconData.ToolTipText = this.ToolTipText;
3927      if (this.messageSink.Version == NotifyIconVersion.Vista && string.IsNullOrEmpty(this.iconData.ToolTipText) && this.TrayToolTipResolved != null)
3928        this.iconData.ToolTipText = "ToolTip";
3929      Util.WriteIconData(ref this.iconData, NotifyCommand.Modify, IconDataMembers.Tip);
3930    }
3931
3932    private void CreatePopup()
3933    {
3934      Popup popup = this.TrayPopup as Popup;
3935      if (popup == null && this.TrayPopup != null)
3936      {
3937        popup = new Popup();
3938        popup.AllowsTransparency = true;
3939        popup.PopupAnimation = PopupAnimation.None;
3940        popup.Child = this.TrayPopup;
3941        popup.Placement = PlacementMode.AbsolutePoint;
3942        popup.StaysOpen = false;
3943      }
3944      if (popup != null)
3945        this.UpdateDataContext((FrameworkElement) popup, (object) null, this.DataContext);
3946      this.SetTrayPopupResolved(popup);
3947    }
3948
3949    private void ShowTrayPopup(WinApp.Tray.RichNotifyIcon.Interop.Point cursorPosition)
3950    {
3951      if (this.IsDisposed || this.RaisePreviewTrayPopupOpenEvent().Handled || this.TrayPopup == null)
3952        return;
3953      this.TrayPopupResolved.Placement = PlacementMode.AbsolutePoint;
3954      this.TrayPopupResolved.HorizontalOffset = (double) cursorPosition.X;
3955      this.TrayPopupResolved.VerticalOffset = (double) cursorPosition.Y;
3956      this.TrayPopupResolved.IsOpen = true;
3957      IntPtr hWnd = IntPtr.Zero;
3958      if (this.TrayPopupResolved.Child != null)
3959      {
3960        HwndSource hwndSource = (HwndSource) PresentationSource.FromVisual((Visual) this.TrayPopupResolved.Child);
3961        if (hwndSource != null)
3962          hWnd = hwndSource.Handle;
3963      }
3964      if (hWnd == IntPtr.Zero)
3965        hWnd = this.messageSink.MessageWindowHandle;
3966      WinApi.SetForegroundWindow(hWnd);
3967      if (this.TrayPopup != null)
3968        TaskbarIcon.RaisePopupOpenedEvent((DependencyObject) this.TrayPopup);
3969      this.RaiseTrayPopupOpenEvent();
3970    }
3971
3972    private void ShowContextMenu(WinApp.Tray.RichNotifyIcon.Interop.Point cursorPosition)
3973    {
3974      if (this.IsDisposed || this.RaisePreviewTrayContextMenuOpenEvent().Handled || this.ContextMenu == null)
3975        return;
3976      this.ContextMenu.Placement = PlacementMode.AbsolutePoint;
3977      this.ContextMenu.HorizontalOffset = (double) cursorPosition.X;
3978      this.ContextMenu.VerticalOffset = (double) cursorPosition.Y;
3979      this.ContextMenu.IsOpen = true;
3980      IntPtr hWnd = IntPtr.Zero;
3981      HwndSource hwndSource = (HwndSource) PresentationSource.FromVisual((Visual) this.ContextMenu);
3982      if (hwndSource != null)
3983        hWnd = hwndSource.Handle;
3984      if (hWnd == IntPtr.Zero)
3985        hWnd = this.messageSink.MessageWindowHandle;
3986      WinApi.SetForegroundWindow(hWnd);
3987      this.RaiseTrayContextMenuOpenEvent();
3988    }
3989
3990    private void OnBalloonToolTipChanged(bool visible)
3991    {
3992      if (visible)
3993        this.RaiseTrayBalloonTipShownEvent();
3994      else
3995        this.RaiseTrayBalloonTipClosedEvent();
3996    }
3997
3998    public void ShowBalloonTip(string title, string message, BalloonIcon symbol)
3999    {
4000      lock (this)
4001        this.ShowBalloonTip(title, message, Util.GetBalloonFlag(symbol), IntPtr.Zero);
4002    }
4003
4004    public void ShowBalloonTip(string title, string message, Icon customIcon)
4005    {
4006      if (customIcon == null)
4007        throw new ArgumentNullException("customIcon");
4008      lock (this)
4009        this.ShowBalloonTip(title, message, BalloonFlags.User, customIcon.Handle);
4010    }
4011
4012    private void ShowBalloonTip(string title, string message, BalloonFlags flags, IntPtr balloonIconHandle)
4013    {
4014      this.EnsureNotDisposed();
4015      this.iconData.BalloonText = message ?? string.Empty;
4016      this.iconData.BalloonTitle = title ?? string.Empty;
4017      this.iconData.BalloonFlags = flags;
4018      this.iconData.CustomBalloonIconHandle = balloonIconHandle;
4019      Util.WriteIconData(ref this.iconData, NotifyCommand.Modify, IconDataMembers.Icon | IconDataMembers.Info);
4020    }
4021
4022    public void HideBalloonTip()
4023    {
4024      this.EnsureNotDisposed();
4025      this.iconData.BalloonText = this.iconData.BalloonTitle = string.Empty;
4026      Util.WriteIconData(ref this.iconData, NotifyCommand.Modify, IconDataMembers.Info);
4027    }
4028
4029    private void DoSingleClickAction(object state)
4030    {
4031      if (this.IsDisposed)
4032        return;
4033      Action action = this.singleClickTimerAction;
4034      if (action == null)
4035        return;
4036      this.singleClickTimerAction = (Action) null;
4037      Util.GetDispatcher((DispatcherObject) this).Invoke((Delegate) action);
4038    }
4039
4040    private void SetVersion()
4041    {
4042      this.iconData.VersionOrTimeout = 4U;
4043      bool flag = WinApi.Shell_NotifyIcon(NotifyCommand.SetVersion, ref this.iconData);
4044      if (!flag)
4045      {
4046        this.iconData.VersionOrTimeout = 3U;
4047        flag = Util.WriteIconData(ref this.iconData, NotifyCommand.SetVersion);
4048      }
4049      if (!flag)
4050      {
4051        this.iconData.VersionOrTimeout = 0U;
4052        flag = Util.WriteIconData(ref this.iconData, NotifyCommand.SetVersion);
4053      }
4054      int num = flag ? 1 : 0;
4055    }
4056
4057    private void OnTaskbarCreated()
4058    {
4059      this.IsTaskbarIconCreated = false;
4060      this.CreateTaskbarIcon();
4061    }
4062
4063    private void CreateTaskbarIcon()
4064    {
4065      lock (this)
4066      {
4067        if (this.IsTaskbarIconCreated || !Util.WriteIconData(ref this.iconData, NotifyCommand.Add, IconDataMembers.Message | IconDataMembers.Icon | IconDataMembers.Tip))
4068          return;
4069        this.SetVersion();
4070        this.messageSink.Version = (NotifyIconVersion) this.iconData.VersionOrTimeout;
4071        this.IsTaskbarIconCreated = true;
4072      }
4073    }
4074
4075    private void RemoveTaskbarIcon()
4076    {
4077      lock (this)
4078      {
4079        if (!this.IsTaskbarIconCreated)
4080          return;
4081        Util.WriteIconData(ref this.iconData, NotifyCommand.Delete, IconDataMembers.Message);
4082        this.IsTaskbarIconCreated = false;
4083      }
4084    }
4085
4086    private WinApp.Tray.RichNotifyIcon.Interop.Point GetDeviceCoordinates(WinApp.Tray.RichNotifyIcon.Interop.Point point)
4087    {
4088      if (double.IsNaN(this.scalingFactor))
4089      {
4090        PresentationSource presentationSource = PresentationSource.FromVisual((Visual) this);
4091        this.scalingFactor = presentationSource != null ? 1.0 / presentationSource.CompositionTarget.TransformToDevice.M11 : 1.0;
4092      }
4093      if (this.scalingFactor == 1.0)
4094        return point;
4095      return new WinApp.Tray.RichNotifyIcon.Interop.Point()
4096      {
4097        X = (int) ((double) point.X * this.scalingFactor),
4098        Y = (int) ((double) point.Y * this.scalingFactor)
4099      };
4100    }
4101
4102    private void EnsureNotDisposed()
4103    {
4104      if (this.IsDisposed)
4105        throw new ObjectDisposedException(this.Name ?? this.GetType().FullName);
4106    }
4107
4108    private void OnExit(object sender, EventArgs e)
4109    {
4110      this.Dispose();
4111    }
4112
4113    public void Dispose()
4114    {
4115      this.Dispose(true);
4116      GC.SuppressFinalize((object) this);
4117    }
4118
4119    private void Dispose(bool disposing)
4120    {
4121      if (this.IsDisposed || !disposing)
4122        return;
4123      lock (this)
4124      {
4125        this.IsDisposed = true;
4126        if (Application.Current != null)
4127          Application.Current.Exit -= new ExitEventHandler(this.OnExit);
4128        this.singleClickTimer.Dispose();
4129        this.balloonCloseTimer.Dispose();
4130        this.messageSink.Dispose();
4131        this.RemoveTaskbarIcon();
4132      }
4133    }
4134
4135    protected void SetTrayPopupResolved(Popup value)
4136    {
4137      this.SetValue(TaskbarIcon.TrayPopupResolvedPropertyKey, (object) value);
4138    }
4139
4140    protected void SetTrayToolTipResolved(ToolTip value)
4141    {
4142      this.SetValue(TaskbarIcon.TrayToolTipResolvedPropertyKey, (object) value);
4143    }
4144
4145    protected void SetCustomBalloon(Popup value)
4146    {
4147      this.SetValue(TaskbarIcon.CustomBalloonPropertyKey, (object) value);
4148    }
4149
4150    private static void IconSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4151    {
4152      ((TaskbarIcon) d).OnIconSourcePropertyChanged(e);
4153    }
4154
4155    private void OnIconSourcePropertyChanged(DependencyPropertyChangedEventArgs e)
4156    {
4157      ImageSource imageSource = (ImageSource) e.NewValue;
4158      if (Util.IsDesignMode)
4159        return;
4160      this.Icon = Util.ToIcon(imageSource);
4161    }
4162
4163    private static void ToolTipTextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4164    {
4165      ((TaskbarIcon) d).OnToolTipTextPropertyChanged(e);
4166    }
4167
4168    private void OnToolTipTextPropertyChanged(DependencyPropertyChangedEventArgs e)
4169    {
4170      if (this.TrayToolTip == null)
4171      {
4172        ToolTip trayToolTipResolved = this.TrayToolTipResolved;
4173        if (trayToolTipResolved == null)
4174          this.CreateCustomToolTip();
4175        else
4176          trayToolTipResolved.Content = e.NewValue;
4177      }
4178      this.WriteToolTipSettings();
4179    }
4180
4181    private static void TrayToolTipPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4182    {
4183      ((TaskbarIcon) d).OnTrayToolTipPropertyChanged(e);
4184    }
4185
4186    private void OnTrayToolTipPropertyChanged(DependencyPropertyChangedEventArgs e)
4187    {
4188      this.CreateCustomToolTip();
4189      if (e.OldValue != null)
4190        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) e.OldValue, (TaskbarIcon) null);
4191      if (e.NewValue != null)
4192        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) e.NewValue, this);
4193      this.WriteToolTipSettings();
4194    }
4195
4196    private static void TrayPopupPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4197    {
4198      ((TaskbarIcon) d).OnTrayPopupPropertyChanged(e);
4199    }
4200
4201    private void OnTrayPopupPropertyChanged(DependencyPropertyChangedEventArgs e)
4202    {
4203      if (e.OldValue != null)
4204        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) e.OldValue, (TaskbarIcon) null);
4205      if (e.NewValue != null)
4206        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) e.NewValue, this);
4207      this.CreatePopup();
4208    }
4209
4210    private static void VisibilityPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4211    {
4212      ((TaskbarIcon) d).OnVisibilityPropertyChanged(e);
4213    }
4214
4215    private void OnVisibilityPropertyChanged(DependencyPropertyChangedEventArgs e)
4216    {
4217      if ((Visibility) e.NewValue == Visibility.Visible)
4218        this.CreateTaskbarIcon();
4219      else
4220        this.RemoveTaskbarIcon();
4221    }
4222
4223    private void UpdateDataContext(FrameworkElement target, object oldDataContextValue, object newDataContextValue)
4224    {
4225      if (target == null || Util.IsDataContextDataBound(target) || !object.ReferenceEquals((object) this, target.DataContext) && !object.Equals(oldDataContextValue, target.DataContext))
4226        return;
4227      target.DataContext = newDataContextValue ?? (object) this;
4228    }
4229
4230    private static void DataContextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4231    {
4232      ((TaskbarIcon) d).OnDataContextPropertyChanged(e);
4233    }
4234
4235    private void OnDataContextPropertyChanged(DependencyPropertyChangedEventArgs e)
4236    {
4237      object newValue = e.NewValue;
4238      object oldValue = e.OldValue;
4239      this.UpdateDataContext((FrameworkElement) this.TrayPopupResolved, oldValue, newValue);
4240      this.UpdateDataContext((FrameworkElement) this.TrayToolTipResolved, oldValue, newValue);
4241      this.UpdateDataContext((FrameworkElement) this.ContextMenu, oldValue, newValue);
4242    }
4243
4244    private static void ContextMenuPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
4245    {
4246      ((TaskbarIcon) d).OnContextMenuPropertyChanged(e);
4247    }
4248
4249    private void OnContextMenuPropertyChanged(DependencyPropertyChangedEventArgs e)
4250    {
4251      if (e.OldValue != null)
4252        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) e.OldValue, (TaskbarIcon) null);
4253      if (e.NewValue != null)
4254        TaskbarIcon.SetParentTaskbarIcon((DependencyObject) e.NewValue, this);
4255      this.UpdateDataContext((FrameworkElement) e.NewValue, (object) null, this.DataContext);
4256    }
4257
4258    protected RoutedEventArgs RaiseTrayLeftMouseDownEvent()
4259    {
4260      return TaskbarIcon.RaiseTrayLeftMouseDownEvent((DependencyObject) this);
4261    }
4262
4263    internal static RoutedEventArgs RaiseTrayLeftMouseDownEvent(DependencyObject target)
4264    {
4265      if (target == null)
4266        return (RoutedEventArgs) null;
4267      RoutedEventArgs args = new RoutedEventArgs();
4268      args.RoutedEvent = TaskbarIcon.TrayLeftMouseDownEvent;
4269      RoutedEventHelper.RaiseEvent(target, args);
4270      return args;
4271    }
4272
4273    protected RoutedEventArgs RaiseTrayRightMouseDownEvent()
4274    {
4275      return TaskbarIcon.RaiseTrayRightMouseDownEvent((DependencyObject) this);
4276    }
4277
4278    internal static RoutedEventArgs RaiseTrayRightMouseDownEvent(DependencyObject target)
4279    {
4280      if (target == null)
4281        return (RoutedEventArgs) null;
4282      RoutedEventArgs args = new RoutedEventArgs();
4283      args.RoutedEvent = TaskbarIcon.TrayRightMouseDownEvent;
4284      RoutedEventHelper.RaiseEvent(target, args);
4285      return args;
4286    }
4287
4288    protected RoutedEventArgs RaiseTrayMiddleMouseDownEvent()
4289    {
4290      return TaskbarIcon.RaiseTrayMiddleMouseDownEvent((DependencyObject) this);
4291    }
4292
4293    internal static RoutedEventArgs RaiseTrayMiddleMouseDownEvent(DependencyObject target)
4294    {
4295      if (target == null)
4296        return (RoutedEventArgs) null;
4297      RoutedEventArgs args = new RoutedEventArgs();
4298      args.RoutedEvent = TaskbarIcon.TrayMiddleMouseDownEvent;
4299      RoutedEventHelper.RaiseEvent(target, args);
4300      return args;
4301    }
4302
4303    protected RoutedEventArgs RaiseTrayLeftMouseUpEvent()
4304    {
4305      return TaskbarIcon.RaiseTrayLeftMouseUpEvent((DependencyObject) this);
4306    }
4307
4308    internal static RoutedEventArgs RaiseTrayLeftMouseUpEvent(DependencyObject target)
4309    {
4310      if (target == null)
4311        return (RoutedEventArgs) null;
4312      RoutedEventArgs args = new RoutedEventArgs();
4313      args.RoutedEvent = TaskbarIcon.TrayLeftMouseUpEvent;
4314      RoutedEventHelper.RaiseEvent(target, args);
4315      return args;
4316    }
4317
4318    protected RoutedEventArgs RaiseTrayRightMouseUpEvent()
4319    {
4320      return TaskbarIcon.RaiseTrayRightMouseUpEvent((DependencyObject) this);
4321    }
4322
4323    internal static RoutedEventArgs RaiseTrayRightMouseUpEvent(DependencyObject target)
4324    {
4325      if (target == null)
4326        return (RoutedEventArgs) null;
4327      RoutedEventArgs args = new RoutedEventArgs();
4328      args.RoutedEvent = TaskbarIcon.TrayRightMouseUpEvent;
4329      RoutedEventHelper.RaiseEvent(target, args);
4330      return args;
4331    }
4332
4333    protected RoutedEventArgs RaiseTrayMiddleMouseUpEvent()
4334    {
4335      return TaskbarIcon.RaiseTrayMiddleMouseUpEvent((DependencyObject) this);
4336    }
4337
4338    internal static RoutedEventArgs RaiseTrayMiddleMouseUpEvent(DependencyObject target)
4339    {
4340      if (target == null)
4341        return (RoutedEventArgs) null;
4342      RoutedEventArgs args = new RoutedEventArgs();
4343      args.RoutedEvent = TaskbarIcon.TrayMiddleMouseUpEvent;
4344      RoutedEventHelper.RaiseEvent(target, args);
4345      return args;
4346    }
4347
4348    protected RoutedEventArgs RaiseTrayMouseDoubleClickEvent()
4349    {
4350      RoutedEventArgs routedEventArgs = TaskbarIcon.RaiseTrayMouseDoubleClickEvent((DependencyObject) this);
4351      Util.ExecuteIfEnabled(this.DoubleClickCommand, this.DoubleClickCommandParameter, this.DoubleClickCommandTarget ?? (IInputElement) this);
4352      return routedEventArgs;
4353    }
4354
4355    internal static RoutedEventArgs RaiseTrayMouseDoubleClickEvent(DependencyObject target)
4356    {
4357      if (target == null)
4358        return (RoutedEventArgs) null;
4359      RoutedEventArgs args = new RoutedEventArgs();
4360      args.RoutedEvent = TaskbarIcon.TrayMouseDoubleClickEvent;
4361      RoutedEventHelper.RaiseEvent(target, args);
4362      return args;
4363    }
4364
4365    protected RoutedEventArgs RaiseTrayMouseMoveEvent()
4366    {
4367      return TaskbarIcon.RaiseTrayMouseMoveEvent((DependencyObject) this);
4368    }
4369
4370    internal static RoutedEventArgs RaiseTrayMouseMoveEvent(DependencyObject target)
4371    {
4372      if (target == null)
4373        return (RoutedEventArgs) null;
4374      RoutedEventArgs args = new RoutedEventArgs();
4375      args.RoutedEvent = TaskbarIcon.TrayMouseMoveEvent;
4376      RoutedEventHelper.RaiseEvent(target, args);
4377      return args;
4378    }
4379
4380    protected RoutedEventArgs RaiseTrayBalloonTipShownEvent()
4381    {
4382      return TaskbarIcon.RaiseTrayBalloonTipShownEvent((DependencyObject) this);
4383    }
4384
4385    internal static RoutedEventArgs RaiseTrayBalloonTipShownEvent(DependencyObject target)
4386    {
4387      if (target == null)
4388        return (RoutedEventArgs) null;
4389      RoutedEventArgs args = new RoutedEventArgs();
4390      args.RoutedEvent = TaskbarIcon.TrayBalloonTipShownEvent;
4391      RoutedEventHelper.RaiseEvent(target, args);
4392      return args;
4393    }
4394
4395    protected RoutedEventArgs RaiseTrayBalloonTipClosedEvent()
4396    {
4397      return TaskbarIcon.RaiseTrayBalloonTipClosedEvent((DependencyObject) this);
4398    }
4399
4400    internal static RoutedEventArgs RaiseTrayBalloonTipClosedEvent(DependencyObject target)
4401    {
4402      if (target == null)
4403        return (RoutedEventArgs) null;
4404      RoutedEventArgs args = new RoutedEventArgs();
4405      args.RoutedEvent = TaskbarIcon.TrayBalloonTipClosedEvent;
4406      RoutedEventHelper.RaiseEvent(target, args);
4407      return args;
4408    }
4409
4410    protected RoutedEventArgs RaiseTrayBalloonTipClickedEvent()
4411    {
4412      return TaskbarIcon.RaiseTrayBalloonTipClickedEvent((DependencyObject) this);
4413    }
4414
4415    internal static RoutedEventArgs RaiseTrayBalloonTipClickedEvent(DependencyObject target)
4416    {
4417      if (target == null)
4418        return (RoutedEventArgs) null;
4419      RoutedEventArgs args = new RoutedEventArgs();
4420      args.RoutedEvent = TaskbarIcon.TrayBalloonTipClickedEvent;
4421      RoutedEventHelper.RaiseEvent(target, args);
4422      return args;
4423    }
4424
4425    protected RoutedEventArgs RaiseTrayContextMenuOpenEvent()
4426    {
4427      return TaskbarIcon.RaiseTrayContextMenuOpenEvent((DependencyObject) this);
4428    }
4429
4430    internal static RoutedEventArgs RaiseTrayContextMenuOpenEvent(DependencyObject target)
4431    {
4432      if (target == null)
4433        return (RoutedEventArgs) null;
4434      RoutedEventArgs args = new RoutedEventArgs();
4435      args.RoutedEvent = TaskbarIcon.TrayContextMenuOpenEvent;
4436      RoutedEventHelper.RaiseEvent(target, args);
4437      return args;
4438    }
4439
4440    protected RoutedEventArgs RaisePreviewTrayContextMenuOpenEvent()
4441    {
4442      return TaskbarIcon.RaisePreviewTrayContextMenuOpenEvent((DependencyObject) this);
4443    }
4444
4445    internal static RoutedEventArgs RaisePreviewTrayContextMenuOpenEvent(DependencyObject target)
4446    {
4447      if (target == null)
4448        return (RoutedEventArgs) null;
4449      RoutedEventArgs args = new RoutedEventArgs();
4450      args.RoutedEvent = TaskbarIcon.PreviewTrayContextMenuOpenEvent;
4451      RoutedEventHelper.RaiseEvent(target, args);
4452      return args;
4453    }
4454
4455    protected RoutedEventArgs RaiseTrayPopupOpenEvent()
4456    {
4457      return TaskbarIcon.RaiseTrayPopupOpenEvent((DependencyObject) this);
4458    }
4459
4460    internal static RoutedEventArgs RaiseTrayPopupOpenEvent(DependencyObject target)
4461    {
4462      if (target == null)
4463        return (RoutedEventArgs) null;
4464      RoutedEventArgs args = new RoutedEventArgs();
4465      args.RoutedEvent = TaskbarIcon.TrayPopupOpenEvent;
4466      RoutedEventHelper.RaiseEvent(target, args);
4467      return args;
4468    }
4469
4470    protected RoutedEventArgs RaisePreviewTrayPopupOpenEvent()
4471    {
4472      return TaskbarIcon.RaisePreviewTrayPopupOpenEvent((DependencyObject) this);
4473    }
4474
4475    internal static RoutedEventArgs RaisePreviewTrayPopupOpenEvent(DependencyObject target)
4476    {
4477      if (target == null)
4478        return (RoutedEventArgs) null;
4479      RoutedEventArgs args = new RoutedEventArgs();
4480      args.RoutedEvent = TaskbarIcon.PreviewTrayPopupOpenEvent;
4481      RoutedEventHelper.RaiseEvent(target, args);
4482      return args;
4483    }
4484
4485    protected RoutedEventArgs RaiseTrayToolTipOpenEvent()
4486    {
4487      return TaskbarIcon.RaiseTrayToolTipOpenEvent((DependencyObject) this);
4488    }
4489
4490    internal static RoutedEventArgs RaiseTrayToolTipOpenEvent(DependencyObject target)
4491    {
4492      if (target == null)
4493        return (RoutedEventArgs) null;
4494      RoutedEventArgs args = new RoutedEventArgs();
4495      args.RoutedEvent = TaskbarIcon.TrayToolTipOpenEvent;
4496      RoutedEventHelper.RaiseEvent(target, args);
4497      return args;
4498    }
4499
4500    protected RoutedEventArgs RaisePreviewTrayToolTipOpenEvent()
4501    {
4502      return TaskbarIcon.RaisePreviewTrayToolTipOpenEvent((DependencyObject) this);
4503    }
4504
4505    internal static RoutedEventArgs RaisePreviewTrayToolTipOpenEvent(DependencyObject target)
4506    {
4507      if (target == null)
4508        return (RoutedEventArgs) null;
4509      RoutedEventArgs args = new RoutedEventArgs();
4510      args.RoutedEvent = TaskbarIcon.PreviewTrayToolTipOpenEvent;
4511      RoutedEventHelper.RaiseEvent(target, args);
4512      return args;
4513    }
4514
4515    protected RoutedEventArgs RaiseTrayToolTipCloseEvent()
4516    {
4517      return TaskbarIcon.RaiseTrayToolTipCloseEvent((DependencyObject) this);
4518    }
4519
4520    internal static RoutedEventArgs RaiseTrayToolTipCloseEvent(DependencyObject target)
4521    {
4522      if (target == null)
4523        return (RoutedEventArgs) null;
4524      RoutedEventArgs args = new RoutedEventArgs();
4525      args.RoutedEvent = TaskbarIcon.TrayToolTipCloseEvent;
4526      RoutedEventHelper.RaiseEvent(target, args);
4527      return args;
4528    }
4529
4530    protected RoutedEventArgs RaisePreviewTrayToolTipCloseEvent()
4531    {
4532      return TaskbarIcon.RaisePreviewTrayToolTipCloseEvent((DependencyObject) this);
4533    }
4534
4535    internal static RoutedEventArgs RaisePreviewTrayToolTipCloseEvent(DependencyObject target)
4536    {
4537      if (target == null)
4538        return (RoutedEventArgs) null;
4539      RoutedEventArgs args = new RoutedEventArgs();
4540      args.RoutedEvent = TaskbarIcon.PreviewTrayToolTipCloseEvent;
4541      RoutedEventHelper.RaiseEvent(target, args);
4542      return args;
4543    }
4544
4545    public static void AddPopupOpenedHandler(DependencyObject element, RoutedEventHandler handler)
4546    {
4547      RoutedEventHelper.AddHandler(element, TaskbarIcon.PopupOpenedEvent, (Delegate) handler);
4548    }
4549
4550    public static void RemovePopupOpenedHandler(DependencyObject element, RoutedEventHandler handler)
4551    {
4552      RoutedEventHelper.RemoveHandler(element, TaskbarIcon.PopupOpenedEvent, (Delegate) handler);
4553    }
4554
4555    internal static RoutedEventArgs RaisePopupOpenedEvent(DependencyObject target)
4556    {
4557      if (target == null)
4558        return (RoutedEventArgs) null;
4559      RoutedEventArgs args = new RoutedEventArgs();
4560      args.RoutedEvent = TaskbarIcon.PopupOpenedEvent;
4561      RoutedEventHelper.RaiseEvent(target, args);
4562      return args;
4563    }
4564
4565    public static void AddToolTipOpenedHandler(DependencyObject element, RoutedEventHandler handler)
4566    {
4567      RoutedEventHelper.AddHandler(element, TaskbarIcon.ToolTipOpenedEvent, (Delegate) handler);
4568    }
4569
4570    public static void RemoveToolTipOpenedHandler(DependencyObject element, RoutedEventHandler handler)
4571    {
4572      RoutedEventHelper.RemoveHandler(element, TaskbarIcon.ToolTipOpenedEvent, (Delegate) handler);
4573    }
4574
4575    internal static RoutedEventArgs RaiseToolTipOpenedEvent(DependencyObject target)
4576    {
4577      if (target == null)
4578        return (RoutedEventArgs) null;
4579      RoutedEventArgs args = new RoutedEventArgs();
4580      args.RoutedEvent = TaskbarIcon.ToolTipOpenedEvent;
4581      RoutedEventHelper.RaiseEvent(target, args);
4582      return args;
4583    }
4584
4585    public static void AddToolTipCloseHandler(DependencyObject element, RoutedEventHandler handler)
4586    {
4587      RoutedEventHelper.AddHandler(element, TaskbarIcon.ToolTipCloseEvent, (Delegate) handler);
4588    }
4589
4590    public static void RemoveToolTipCloseHandler(DependencyObject element, RoutedEventHandler handler)
4591    {
4592      RoutedEventHelper.RemoveHandler(element, TaskbarIcon.ToolTipCloseEvent, (Delegate) handler);
4593    }
4594
4595    internal static RoutedEventArgs RaiseToolTipCloseEvent(DependencyObject target)
4596    {
4597      if (target == null)
4598        return (RoutedEventArgs) null;
4599      RoutedEventArgs args = new RoutedEventArgs();
4600      args.RoutedEvent = TaskbarIcon.ToolTipCloseEvent;
4601      RoutedEventHelper.RaiseEvent(target, args);
4602      return args;
4603    }
4604
4605    public static void AddBalloonShowingHandler(DependencyObject element, RoutedEventHandler handler)
4606    {
4607      RoutedEventHelper.AddHandler(element, TaskbarIcon.BalloonShowingEvent, (Delegate) handler);
4608    }
4609
4610    public static void RemoveBalloonShowingHandler(DependencyObject element, RoutedEventHandler handler)
4611    {
4612      RoutedEventHelper.RemoveHandler(element, TaskbarIcon.BalloonShowingEvent, (Delegate) handler);
4613    }
4614
4615    internal static RoutedEventArgs RaiseBalloonShowingEvent(DependencyObject target, TaskbarIcon source)
4616    {
4617      if (target == null)
4618        return (RoutedEventArgs) null;
4619      RoutedEventArgs args = new RoutedEventArgs(TaskbarIcon.BalloonShowingEvent, (object) source);
4620      RoutedEventHelper.RaiseEvent(target, args);
4621      return args;
4622    }
4623
4624    public static void AddBalloonClosingHandler(DependencyObject element, RoutedEventHandler handler)
4625    {
4626      RoutedEventHelper.AddHandler(element, TaskbarIcon.BalloonClosingEvent, (Delegate) handler);
4627    }
4628
4629    public static void RemoveBalloonClosingHandler(DependencyObject element, RoutedEventHandler handler)
4630    {
4631      RoutedEventHelper.RemoveHandler(element, TaskbarIcon.BalloonClosingEvent, (Delegate) handler);
4632    }
4633
4634    internal static RoutedEventArgs RaiseBalloonClosingEvent(DependencyObject target, TaskbarIcon source)
4635    {
4636      if (target == null)
4637        return (RoutedEventArgs) null;
4638      RoutedEventArgs args = new RoutedEventArgs(TaskbarIcon.BalloonClosingEvent, (object) source);
4639      RoutedEventHelper.RaiseEvent(target, args);
4640      return args;
4641    }
4642
4643    public static TaskbarIcon GetParentTaskbarIcon(DependencyObject d)
4644    {
4645      return (TaskbarIcon) d.GetValue(TaskbarIcon.ParentTaskbarIconProperty);
4646    }
4647
4648    public static void SetParentTaskbarIcon(DependencyObject d, TaskbarIcon value)
4649    {
4650      d.SetValue(TaskbarIcon.ParentTaskbarIconProperty, (object) value);
4651    }
4652  }
4653}
4654?// Decompiled with JetBrains decompiler
4655// Type: WinApp.Tray.RichNotifyIcon.BalloonIcon
4656// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4657// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4658// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4659
4660namespace WinApp.Tray.RichNotifyIcon
4661{
4662  public enum BalloonIcon
4663  {
4664    None,
4665    Info,
4666    Warning,
4667    Error,
4668  }
4669}
4670?// Decompiled with JetBrains decompiler
4671// Type: WinApp.Tray.RichNotifyIcon.Util
4672// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4673// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4674// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4675
4676using System;
4677using System.ComponentModel;
4678using System.Drawing;
4679using System.Windows;
4680using System.Windows.Input;
4681using System.Windows.Media;
4682using System.Windows.Resources;
4683using System.Windows.Threading;
4684using WinApp.Tray.RichNotifyIcon.Interop;
4685
4686namespace WinApp.Tray.RichNotifyIcon
4687{
4688  internal static class Util
4689  {
4690    public static readonly object SyncRoot = new object();
4691    private static readonly bool isDesignMode = (bool) DependencyPropertyDescriptor.FromProperty(DesignerProperties.IsInDesignModeProperty, typeof (FrameworkElement)).Metadata.DefaultValue;
4692
4693    public static bool IsDesignMode
4694    {
4695      get
4696      {
4697        return Util.isDesignMode;
4698      }
4699    }
4700
4701    public static Window CreateHelperWindow()
4702    {
4703      Window window = new Window();
4704      window.Width = 0.0;
4705      window.Height = 0.0;
4706      window.ShowInTaskbar = false;
4707      window.WindowStyle = WindowStyle.None;
4708      window.AllowsTransparency = true;
4709      window.Opacity = 0.0;
4710      return window;
4711    }
4712
4713    public static bool WriteIconData(ref NotifyIconData data, NotifyCommand command)
4714    {
4715      return Util.WriteIconData(ref data, command, data.ValidMembers);
4716    }
4717
4718    public static bool WriteIconData(ref NotifyIconData data, NotifyCommand command, IconDataMembers flags)
4719    {
4720      if (Util.IsDesignMode)
4721        return true;
4722      data.ValidMembers = flags;
4723      lock (Util.SyncRoot)
4724        return WinApi.Shell_NotifyIcon(command, ref data);
4725    }
4726
4727    public static BalloonFlags GetBalloonFlag(this BalloonIcon icon)
4728    {
4729      switch (icon)
4730      {
4731        case BalloonIcon.None:
4732          return BalloonFlags.None;
4733        case BalloonIcon.Info:
4734          return BalloonFlags.Info;
4735        case BalloonIcon.Warning:
4736          return BalloonFlags.Warning;
4737        case BalloonIcon.Error:
4738          return BalloonFlags.Error;
4739        default:
4740          throw new ArgumentOutOfRangeException("icon");
4741      }
4742    }
4743
4744    public static Icon ToIcon(this ImageSource imageSource)
4745    {
4746      if (imageSource == null)
4747        return (Icon) null;
4748      StreamResourceInfo resourceStream = Application.GetResourceStream(new Uri(imageSource.ToString()));
4749      if (resourceStream == null)
4750        throw new ArgumentException(string.Format("The supplied image source '{0}' could not be resolved.", (object) imageSource));
4751      return new Icon(resourceStream.Stream);
4752    }
4753
4754    public static bool Is<T>(this T value, params T[] candidates)
4755    {
4756      if (candidates == null)
4757        return false;
4758      foreach (T obj in candidates)
4759      {
4760        if (value.Equals((object) obj))
4761          return true;
4762      }
4763      return false;
4764    }
4765
4766    public static bool IsMatch(this MouseEvent me, PopupActivationMode activationMode)
4767    {
4768      switch (activationMode)
4769      {
4770        case PopupActivationMode.LeftClick:
4771          return me == MouseEvent.IconLeftMouseUp;
4772        case PopupActivationMode.RightClick:
4773          return me == MouseEvent.IconRightMouseUp;
4774        case PopupActivationMode.DoubleClick:
4775          return Util.Is<MouseEvent>(me, MouseEvent.IconDoubleClick);
4776        case PopupActivationMode.LeftOrRightClick:
4777          return Util.Is<MouseEvent>(me, MouseEvent.IconLeftMouseUp, MouseEvent.IconRightMouseUp);
4778        case PopupActivationMode.LeftOrDoubleClick:
4779          return Util.Is<MouseEvent>(me, MouseEvent.IconLeftMouseUp, MouseEvent.IconDoubleClick);
4780        case PopupActivationMode.MiddleClick:
4781          return me == MouseEvent.IconMiddleMouseUp;
4782        case PopupActivationMode.All:
4783          return me != MouseEvent.MouseMove;
4784        default:
4785          throw new ArgumentOutOfRangeException("activationMode");
4786      }
4787    }
4788
4789    public static void ExecuteIfEnabled(this ICommand command, object commandParameter, IInputElement target)
4790    {
4791      if (command == null)
4792        return;
4793      RoutedCommand routedCommand = command as RoutedCommand;
4794      if (routedCommand != null)
4795      {
4796        if (!routedCommand.CanExecute(commandParameter, target))
4797          return;
4798        routedCommand.Execute(commandParameter, target);
4799      }
4800      else
4801      {
4802        if (!command.CanExecute(commandParameter))
4803          return;
4804        command.Execute(commandParameter);
4805      }
4806    }
4807
4808    internal static Dispatcher GetDispatcher(this DispatcherObject source)
4809    {
4810      if (Application.Current != null)
4811        return Application.Current.Dispatcher;
4812      if (source.Dispatcher != null)
4813        return source.Dispatcher;
4814      return Dispatcher.CurrentDispatcher;
4815    }
4816
4817    public static bool IsDataContextDataBound(this FrameworkElement element)
4818    {
4819      if (element == null)
4820        throw new ArgumentNullException("element");
4821      return element.GetBindingExpression(FrameworkElement.DataContextProperty) != null;
4822    }
4823  }
4824}
4825?// Decompiled with JetBrains decompiler
4826// Type: WinApp.Tray.RichNotifyIcon.Interop.NotifyIconData
4827// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4828// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4829// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4830
4831using System;
4832using System.Runtime.InteropServices;
4833
4834namespace WinApp.Tray.RichNotifyIcon.Interop
4835{
4836  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
4837  public struct NotifyIconData
4838  {
4839    public uint cbSize;
4840    public IntPtr WindowHandle;
4841    public uint TaskbarIconId;
4842    public IconDataMembers ValidMembers;
4843    public uint CallbackMessageId;
4844    public IntPtr IconHandle;
4845    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
4846    public string ToolTipText;
4847    public IconState IconState;
4848    public IconState StateMask;
4849    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
4850    public string BalloonText;
4851    public uint VersionOrTimeout;
4852    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
4853    public string BalloonTitle;
4854    public BalloonFlags BalloonFlags;
4855    public Guid TaskbarIconGuid;
4856    public IntPtr CustomBalloonIconHandle;
4857
4858    public static NotifyIconData CreateDefault(IntPtr handle)
4859    {
4860      NotifyIconData notifyIconData = new NotifyIconData();
4861      if (Environment.OSVersion.Version.Major >= 6)
4862      {
4863        notifyIconData.cbSize = (uint) Marshal.SizeOf((object) notifyIconData);
4864      }
4865      else
4866      {
4867        notifyIconData.cbSize = 952U;
4868        notifyIconData.VersionOrTimeout = 10U;
4869      }
4870      notifyIconData.WindowHandle = handle;
4871      notifyIconData.TaskbarIconId = 0U;
4872      notifyIconData.CallbackMessageId = 1024U;
4873      notifyIconData.VersionOrTimeout = 0U;
4874      notifyIconData.IconHandle = IntPtr.Zero;
4875      notifyIconData.IconState = IconState.Hidden;
4876      notifyIconData.StateMask = IconState.Hidden;
4877      notifyIconData.ValidMembers = IconDataMembers.Message | IconDataMembers.Icon | IconDataMembers.Tip;
4878      notifyIconData.ToolTipText = notifyIconData.BalloonText = notifyIconData.BalloonTitle = string.Empty;
4879      return notifyIconData;
4880    }
4881  }
4882}
4883?// Decompiled with JetBrains decompiler
4884// Type: WinApp.Tray.RichNotifyIcon.Interop.Point
4885// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4886// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4887// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4888
4889namespace WinApp.Tray.RichNotifyIcon.Interop
4890{
4891  public struct Point
4892  {
4893    public int X;
4894    public int Y;
4895  }
4896}
4897?// Decompiled with JetBrains decompiler
4898// Type: WinApp.Tray.RichNotifyIcon.Interop.WindowProcedureHandler
4899// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4900// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4901// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4902
4903using System;
4904
4905namespace WinApp.Tray.RichNotifyIcon.Interop
4906{
4907  public delegate IntPtr WindowProcedureHandler(IntPtr hwnd, uint uMsg, IntPtr wparam, IntPtr lparam);
4908}
4909?// Decompiled with JetBrains decompiler
4910// Type: WinApp.Tray.RichNotifyIcon.Interop.WinApi
4911// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4912// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4913// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4914
4915using System;
4916using System.Runtime.InteropServices;
4917
4918namespace WinApp.Tray.RichNotifyIcon.Interop
4919{
4920  internal static class WinApi
4921  {
4922    [DllImport("shell32.Dll", CharSet = CharSet.Unicode)]
4923    public static extern bool Shell_NotifyIcon(NotifyCommand cmd, [In] ref NotifyIconData data);
4924
4925    [DllImport("USER32.DLL", EntryPoint = "CreateWindowExW", SetLastError = true)]
4926    public static extern IntPtr CreateWindowEx(int dwExStyle, [MarshalAs(UnmanagedType.LPWStr)] string lpClassName, [MarshalAs(UnmanagedType.LPWStr)] string lpWindowName, int dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam);
4927
4928    [DllImport("USER32.DLL")]
4929    public static extern IntPtr DefWindowProc(IntPtr hWnd, uint msg, IntPtr wparam, IntPtr lparam);
4930
4931    [DllImport("USER32.DLL", EntryPoint = "RegisterClassW", SetLastError = true)]
4932    public static extern short RegisterClass(ref WindowClass lpWndClass);
4933
4934    [DllImport("User32.Dll", EntryPoint = "RegisterWindowMessageW")]
4935    public static extern uint RegisterWindowMessage([MarshalAs(UnmanagedType.LPWStr)] string lpString);
4936
4937    [DllImport("USER32.DLL", SetLastError = true)]
4938    public static extern bool DestroyWindow(IntPtr hWnd);
4939
4940    [DllImport("USER32.DLL")]
4941    public static extern bool SetForegroundWindow(IntPtr hWnd);
4942
4943    [DllImport("user32.dll", CharSet = CharSet.Auto)]
4944    public static extern int GetDoubleClickTime();
4945
4946    [DllImport("USER32.DLL", SetLastError = true)]
4947    public static extern bool GetPhysicalCursorPos(ref Point lpPoint);
4948
4949    [DllImport("USER32.DLL", SetLastError = true)]
4950    public static extern bool GetCursorPos(ref Point lpPoint);
4951  }
4952}
4953?// Decompiled with JetBrains decompiler
4954// Type: WinApp.Tray.RichNotifyIcon.Interop.MouseEvent
4955// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4956// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4957// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4958
4959namespace WinApp.Tray.RichNotifyIcon.Interop
4960{
4961  public enum MouseEvent
4962  {
4963    MouseMove,
4964    IconRightMouseDown,
4965    IconLeftMouseDown,
4966    IconRightMouseUp,
4967    IconLeftMouseUp,
4968    IconMiddleMouseDown,
4969    IconMiddleMouseUp,
4970    IconDoubleClick,
4971    BalloonToolTipClicked,
4972  }
4973}
4974?// Decompiled with JetBrains decompiler
4975// Type: WinApp.Tray.RichNotifyIcon.Interop.AppBarInfo
4976// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
4977// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
4978// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
4979
4980using System;
4981using System.Drawing;
4982using System.Runtime.InteropServices;
4983
4984namespace WinApp.Tray.RichNotifyIcon.Interop
4985{
4986  internal class AppBarInfo
4987  {
4988    private const int ABE_BOTTOM = 3;
4989    private const int ABE_LEFT = 0;
4990    private const int ABE_RIGHT = 2;
4991    private const int ABE_TOP = 1;
4992    private const int ABM_GETTASKBARPOS = 5;
4993    private const uint SPI_GETWORKAREA = 48;
4994    private AppBarInfo.APPBARDATA m_data;
4995
4996    public AppBarInfo.ScreenEdge Edge
4997    {
4998      get
4999      {
5000        return (AppBarInfo.ScreenEdge) this.m_data.uEdge;
5001      }
5002    }
5003
5004    public Rectangle WorkArea
5005    {
5006      get
5007      {
5008        AppBarInfo.RECT rect1 = new AppBarInfo.RECT();
5009        IntPtr num1 = Marshal.AllocHGlobal(Marshal.SizeOf((object) rect1));
5010        int num2 = AppBarInfo.SystemParametersInfo(48U, 0U, num1, 0U);
5011        AppBarInfo.RECT rect2 = (AppBarInfo.RECT) Marshal.PtrToStructure(num1, rect1.GetType());
5012        if (num2 != 1)
5013          return new Rectangle(0, 0, 0, 0);
5014        Marshal.FreeHGlobal(num1);
5015        return new Rectangle(rect2.left, rect2.top, rect2.right - rect2.left, rect2.bottom - rect2.top);
5016      }
5017    }
5018
5019    [DllImport("user32.dll")]
5020    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
5021
5022    [DllImport("shell32.dll")]
5023    private static extern uint SHAppBarMessage(uint dwMessage, ref AppBarInfo.APPBARDATA data);
5024
5025    [DllImport("user32.dll")]
5026    private static extern int SystemParametersInfo(uint uiAction, uint uiParam, IntPtr pvParam, uint fWinIni);
5027
5028    public void GetPosition(string strClassName, string strWindowName)
5029    {
5030      this.m_data = new AppBarInfo.APPBARDATA();
5031      this.m_data.cbSize = (uint) Marshal.SizeOf(this.m_data.GetType());
5032      if (!(AppBarInfo.FindWindow(strClassName, strWindowName) != IntPtr.Zero))
5033        throw new Exception("Failed to find an AppBar that matched the given criteria");
5034      if ((int) AppBarInfo.SHAppBarMessage(5U, ref this.m_data) != 1)
5035        throw new Exception("Failed to communicate with the given AppBar");
5036    }
5037
5038    public void GetSystemTaskBarPosition()
5039    {
5040      this.GetPosition("Shell_TrayWnd", (string) null);
5041    }
5042
5043    public enum ScreenEdge
5044    {
5045      Undefined = -1,
5046      Left = 0,
5047      Top = 1,
5048      Right = 2,
5049      Bottom = 3,
5050    }
5051
5052    private struct APPBARDATA
5053    {
5054      public uint cbSize;
5055      public IntPtr hWnd;
5056      public uint uCallbackMessage;
5057      public uint uEdge;
5058      public AppBarInfo.RECT rc;
5059      public int lParam;
5060    }
5061
5062    private struct RECT
5063    {
5064      public int left;
5065      public int top;
5066      public int right;
5067      public int bottom;
5068    }
5069  }
5070}
5071?// Decompiled with JetBrains decompiler
5072// Type: WinApp.Tray.RichNotifyIcon.Interop.NotifyIconVersion
5073// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5074// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5075// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5076
5077namespace WinApp.Tray.RichNotifyIcon.Interop
5078{
5079  public enum NotifyIconVersion
5080  {
5081    Win95 = 0,
5082    Win2000 = 3,
5083    Vista = 4,
5084  }
5085}
5086?// Decompiled with JetBrains decompiler
5087// Type: WinApp.Tray.RichNotifyIcon.Interop.BalloonFlags
5088// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5089// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5090// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5091
5092namespace WinApp.Tray.RichNotifyIcon.Interop
5093{
5094  public enum BalloonFlags
5095  {
5096    None = 0,
5097    Info = 1,
5098    Warning = 2,
5099    Error = 3,
5100    User = 4,
5101    NoSound = 16,
5102    LargeIcon = 32,
5103    RespectQuietTime = 128,
5104  }
5105}
5106?// Decompiled with JetBrains decompiler
5107// Type: WinApp.Tray.RichNotifyIcon.Interop.IconState
5108// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5109// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5110// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5111
5112namespace WinApp.Tray.RichNotifyIcon.Interop
5113{
5114  public enum IconState
5115  {
5116    Visible,
5117    Hidden,
5118  }
5119}
5120?// Decompiled with JetBrains decompiler
5121// Type: WinApp.Tray.RichNotifyIcon.Interop.WindowClass
5122// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5123// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5124// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5125
5126using System;
5127using System.Runtime.InteropServices;
5128
5129namespace WinApp.Tray.RichNotifyIcon.Interop
5130{
5131  public struct WindowClass
5132  {
5133    public uint style;
5134    public WindowProcedureHandler lpfnWndProc;
5135    public int cbClsExtra;
5136    public int cbWndExtra;
5137    public IntPtr hInstance;
5138    public IntPtr hIcon;
5139    public IntPtr hCursor;
5140    public IntPtr hbrBackground;
5141    [MarshalAs(UnmanagedType.LPWStr)]
5142    public string lpszMenuName;
5143    [MarshalAs(UnmanagedType.LPWStr)]
5144    public string lpszClassName;
5145  }
5146}
5147?// Decompiled with JetBrains decompiler
5148// Type: WinApp.Tray.RichNotifyIcon.Interop.WindowMessageSink
5149// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5150// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5151// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5152
5153using System;
5154using System.ComponentModel;
5155
5156namespace WinApp.Tray.RichNotifyIcon.Interop
5157{
5158  public class WindowMessageSink : IDisposable
5159  {
5160    public const int CallbackMessageId = 1024;
5161    private uint taskbarRestartMessageId;
5162    private bool isDoubleClick;
5163    private WindowProcedureHandler messageHandler;
5164
5165    internal string WindowId { get; private set; }
5166
5167    internal IntPtr MessageWindowHandle { get; private set; }
5168
5169    public NotifyIconVersion Version { get; set; }
5170
5171    public bool IsDisposed { get; private set; }
5172
5173    public event Action<bool> ChangeToolTipStateRequest;
5174
5175    public event Action<MouseEvent> MouseEventReceived;
5176
5177    public event Action<bool> BalloonToolTipChanged;
5178
5179    public event Action TaskbarCreated;
5180
5181    public WindowMessageSink(NotifyIconVersion version)
5182    {
5183      this.Version = version;
5184      this.CreateMessageWindow();
5185    }
5186
5187    private WindowMessageSink()
5188    {
5189    }
5190
5191    ~WindowMessageSink()
5192    {
5193      this.Dispose(false);
5194    }
5195
5196    internal static WindowMessageSink CreateEmpty()
5197    {
5198      return new WindowMessageSink()
5199      {
5200        MessageWindowHandle = IntPtr.Zero,
5201        Version = NotifyIconVersion.Vista
5202      };
5203    }
5204
5205    private void CreateMessageWindow()
5206    {
5207      this.WindowId = "WPFTaskbarIcon_" + (object) DateTime.Now.Ticks;
5208      this.messageHandler = new WindowProcedureHandler(this.OnWindowMessageReceived);
5209      WindowClass lpWndClass;
5210      lpWndClass.style = 0U;
5211      lpWndClass.lpfnWndProc = this.messageHandler;
5212      lpWndClass.cbClsExtra = 0;
5213      lpWndClass.cbWndExtra = 0;
5214      lpWndClass.hInstance = IntPtr.Zero;
5215      lpWndClass.hIcon = IntPtr.Zero;
5216      lpWndClass.hCursor = IntPtr.Zero;
5217      lpWndClass.hbrBackground = IntPtr.Zero;
5218      lpWndClass.lpszMenuName = "";
5219      lpWndClass.lpszClassName = this.WindowId;
5220      int num = (int) WinApi.RegisterClass(ref lpWndClass);
5221      this.taskbarRestartMessageId = WinApi.RegisterWindowMessage("TaskbarCreated");
5222      this.MessageWindowHandle = WinApi.CreateWindowEx(0, this.WindowId, "", 0, 0, 0, 1, 1, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
5223      if (this.MessageWindowHandle == IntPtr.Zero)
5224        throw new Win32Exception("Message window handle was not a valid pointer");
5225    }
5226
5227    private IntPtr OnWindowMessageReceived(IntPtr hwnd, uint messageId, IntPtr wparam, IntPtr lparam)
5228    {
5229      if ((int) messageId == (int) this.taskbarRestartMessageId)
5230        this.TaskbarCreated();
5231      this.ProcessWindowMessage(messageId, wparam, lparam);
5232      return WinApi.DefWindowProc(hwnd, messageId, wparam, lparam);
5233    }
5234
5235    private void ProcessWindowMessage(uint msg, IntPtr wParam, IntPtr lParam)
5236    {
5237      if ((int) msg != 1024)
5238        return;
5239      switch (lParam.ToInt32())
5240      {
5241        case 512:
5242          this.MouseEventReceived(MouseEvent.MouseMove);
5243          break;
5244        case 513:
5245          this.MouseEventReceived(MouseEvent.IconLeftMouseDown);
5246          break;
5247        case 514:
5248          if (!this.isDoubleClick)
5249            this.MouseEventReceived(MouseEvent.IconLeftMouseUp);
5250          this.isDoubleClick = false;
5251          break;
5252        case 515:
5253          this.isDoubleClick = true;
5254          this.MouseEventReceived(MouseEvent.IconDoubleClick);
5255          break;
5256        case 516:
5257          this.MouseEventReceived(MouseEvent.IconRightMouseDown);
5258          break;
5259        case 517:
5260          this.MouseEventReceived(MouseEvent.IconRightMouseUp);
5261          break;
5262        case 519:
5263          this.MouseEventReceived(MouseEvent.IconMiddleMouseDown);
5264          break;
5265        case 520:
5266          this.MouseEventReceived(MouseEvent.IconMiddleMouseUp);
5267          break;
5268        case 1026:
5269          this.BalloonToolTipChanged(true);
5270          break;
5271        case 1027:
5272        case 1028:
5273          this.BalloonToolTipChanged(false);
5274          break;
5275        case 1029:
5276          this.MouseEventReceived(MouseEvent.BalloonToolTipClicked);
5277          break;
5278        case 1030:
5279          this.ChangeToolTipStateRequest(true);
5280          break;
5281        case 1031:
5282          this.ChangeToolTipStateRequest(false);
5283          break;
5284      }
5285    }
5286
5287    public void Dispose()
5288    {
5289      this.Dispose(true);
5290      GC.SuppressFinalize((object) this);
5291    }
5292
5293    private void Dispose(bool disposing)
5294    {
5295      if (this.IsDisposed)
5296        return;
5297      this.IsDisposed = true;
5298      WinApi.DestroyWindow(this.MessageWindowHandle);
5299      this.messageHandler = (WindowProcedureHandler) null;
5300    }
5301  }
5302}
5303?// Decompiled with JetBrains decompiler
5304// Type: WinApp.Tray.RichNotifyIcon.Interop.TrayInfo
5305// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5306// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5307// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5308
5309using System.Drawing;
5310
5311namespace WinApp.Tray.RichNotifyIcon.Interop
5312{
5313  public static class TrayInfo
5314  {
5315    public static Point GetTrayLocation()
5316    {
5317      AppBarInfo appBarInfo = new AppBarInfo();
5318      appBarInfo.GetSystemTaskBarPosition();
5319      Rectangle workArea = appBarInfo.WorkArea;
5320      int num1 = 0;
5321      int num2 = 0;
5322      if (appBarInfo.Edge == AppBarInfo.ScreenEdge.Left)
5323      {
5324        num1 = workArea.Left + 2;
5325        num2 = workArea.Bottom;
5326      }
5327      else if (appBarInfo.Edge == AppBarInfo.ScreenEdge.Bottom)
5328      {
5329        num1 = workArea.Right;
5330        num2 = workArea.Bottom;
5331      }
5332      else if (appBarInfo.Edge == AppBarInfo.ScreenEdge.Top)
5333      {
5334        num1 = workArea.Right;
5335        num2 = workArea.Top;
5336      }
5337      else if (appBarInfo.Edge == AppBarInfo.ScreenEdge.Right)
5338      {
5339        num1 = workArea.Right;
5340        num2 = workArea.Bottom;
5341      }
5342      return new Point()
5343      {
5344        X = num1,
5345        Y = num2
5346      };
5347    }
5348  }
5349}
5350?// Decompiled with JetBrains decompiler
5351// Type: WinApp.Tray.RichNotifyIcon.Interop.IconDataMembers
5352// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5353// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5354// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5355
5356using System;
5357
5358namespace WinApp.Tray.RichNotifyIcon.Interop
5359{
5360  [Flags]
5361  public enum IconDataMembers
5362  {
5363    Message = 1,
5364    Icon = 2,
5365    Tip = 4,
5366    State = 8,
5367    Info = 16,
5368    Realtime = 64,
5369    UseLegacyToolTips = 128,
5370  }
5371}
5372?// Decompiled with JetBrains decompiler
5373// Type: WinApp.Tray.RichNotifyIcon.Interop.NotifyCommand
5374// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5375// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5376// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5377
5378namespace WinApp.Tray.RichNotifyIcon.Interop
5379{
5380  public enum NotifyCommand
5381  {
5382    Add,
5383    Modify,
5384    Delete,
5385    SetFocus,
5386    SetVersion,
5387  }
5388}
5389?// Decompiled with JetBrains decompiler
5390// Type: WinApp.LoginState
5391// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5392// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5393// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5394
5395namespace WinApp
5396{
5397  internal enum LoginState
5398  {
5399    NoLogin,
5400    Done,
5401  }
5402}
5403?// Decompiled with JetBrains decompiler
5404// Type: WinApp.App
5405// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5406// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5407// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5408
5409using Inc.Logging;
5410using System;
5411using System.CodeDom.Compiler;
5412using System.Configuration;
5413using System.Diagnostics;
5414using System.IO;
5415using System.Runtime.InteropServices;
5416using System.Threading;
5417using System.Windows;
5418using System.Windows.Threading;
5419using WinApp.ViewModel;
5420
5421namespace WinApp
5422{
5423  internal class App : Application
5424  {
5425    private const string _appName = "KairosPlanet";
5426    private static Mutex _instanceMutex;
5427    private bool _contentLoaded;
5428
5429    public App()
5430    {
5431      Application.Current.DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(this.Application_DispatcherUnhandledException);
5432      WinApp.Managers.Configuration.ConfigurationManager.Analyze();
5433      AppVM.Initialize();
5434    }
5435
5436    protected override void OnStartup(StartupEventArgs e)
5437    {
5438      try
5439      {
5440        bool createdNew;
5441        App._instanceMutex = new Mutex(true, "KairosPlanet", out createdNew);
5442        if (!createdNew)
5443        {
5444          App.SendMessage();
5445          this.Shutdown();
5446        }
5447        else
5448        {
5449          this.SetOverrideLogFile();
5450          Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
5451          AppVM.Instance.OnStartUp();
5452          base.OnStartup(e);
5453        }
5454      }
5455      catch (FileLoadException ex)
5456      {
5457        Logger.WriteError((object) this, "FileLoadException", "?????? ??? ????????? ???????? , ??????: " + ex.Message, (Exception) ex);
5458        int num = (int) MessageBox.Show("?????? ??? ????????? ????????, ?????????? ?? ????? ????????? ????????, ??? ????? ???????");
5459        this.Shutdown();
5460      }
5461      catch (Exception ex)
5462      {
5463        Logger.WriteError((object) this, "UnhandledException", "???????????? ??????????, ????????? ??????: " + (object) e, ex);
5464      }
5465    }
5466
5467    [DllImport("user32.dll", CharSet = CharSet.Auto)]
5468    private static extern int SendNotifyMessage(IntPtr hwnd, IntPtr wMsg, IntPtr wParam, IntPtr lParam);
5469
5470    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
5471    private static extern uint RegisterWindowMessage(string lpString);
5472
5473    private static void SendMessage()
5474    {
5475      App.SendNotifyMessage((IntPtr) ((int) ushort.MaxValue), (IntPtr) ((long) App.RegisterWindowMessage("KairosPlanetMessage")), Marshal.StringToHGlobalAuto("ShowMainWindow"), Marshal.StringToHGlobalAuto("another message"));
5476    }
5477
5478    private static void SaveParametrToAppConfig(string strSettingsName, string value)
5479    {
5480      Configuration configuration = System.Configuration.ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
5481      KeyValueConfigurationElement configurationElement = configuration.AppSettings.Settings[strSettingsName];
5482      if (configurationElement != null)
5483      {
5484        if (configurationElement.Value == value)
5485          return;
5486        configurationElement.Value = value;
5487      }
5488      else
5489        configuration.AppSettings.Settings.Add(strSettingsName, value);
5490      configuration.Save(ConfigurationSaveMode.Modified);
5491    }
5492
5493    private void Application_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
5494    {
5495      Logger.WriteError((object) this, "UnhandledException", "?????????? ?? ?????? ??????????. C???????? ??????: " + (object) e.Exception, e.Exception);
5496      e.Handled = true;
5497    }
5498
5499    private void SetOverrideLogFile()
5500    {
5501      App.SaveParametrToAppConfig("OverrideLogFile", "True");
5502    }
5503
5504    [DebuggerNonUserCode]
5505    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
5506    public void InitializeComponent()
5507    {
5508      if (this._contentLoaded)
5509        return;
5510      this._contentLoaded = true;
5511      Application.LoadComponent((object) this, new Uri("/KairosPlanet;component/app.xaml", UriKind.Relative));
5512    }
5513
5514    [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
5515    [DebuggerNonUserCode]
5516    [STAThread]
5517    public static void Main()
5518    {
5519      App app = new App();
5520      app.InitializeComponent();
5521      app.Run();
5522    }
5523  }
5524}
5525?// Decompiled with JetBrains decompiler
5526// Type: WinApp.Managers.Credentials
5527// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5528// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5529// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5530
5531namespace WinApp.Managers
5532{
5533  public class Credentials
5534  {
5535    public string Login { get; private set; }
5536
5537    public string Password { get; private set; }
5538
5539    public Credentials(string login, string password)
5540    {
5541      this.Login = login;
5542      this.Password = password;
5543    }
5544  }
5545}
5546?// Decompiled with JetBrains decompiler
5547// Type: WinApp.Managers.Interfaces.IMainWindow
5548// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5549// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5550// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5551
5552using WinApp.ViewModel;
5553
5554namespace WinApp.Managers.Interfaces
5555{
5556  internal interface IMainWindow
5557  {
5558    MainWindowVM ViewModel { get; }
5559
5560    bool CloseToTray { get; set; }
5561
5562    void Open();
5563
5564    void Show();
5565  }
5566}
5567?// Decompiled with JetBrains decompiler
5568// Type: WinApp.Managers.Interfaces.IModuleResolver
5569// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5570// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5571// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5572
5573using WinApp.Data.Model;
5574using WinApp.Module;
5575
5576namespace WinApp.Managers.Interfaces
5577{
5578  public interface IModuleResolver : IModuleCallback
5579  {
5580    IModuleManager GetModuleManager(ModuleInfo moduleInfo);
5581
5582    ModuleInfo GetModuleInfo(long productId);
5583
5584    bool DownloadModule(ModuleInfo moduleInfo);
5585
5586    string GetActiveModuleSecureKey();
5587  }
5588}
5589?// Decompiled with JetBrains decompiler
5590// Type: WinApp.Managers.Interfaces.IAppTray
5591// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5592// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5593// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5594
5595using System.Windows;
5596
5597namespace WinApp.Managers.Interfaces
5598{
5599  internal interface IAppTray
5600  {
5601    UIElement Tray { get; }
5602
5603    void Refresh();
5604  }
5605}
5606?// Decompiled with JetBrains decompiler
5607// Type: WinApp.Managers.Interfaces.ISessionManager
5608// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5609// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5610// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5611
5612using System;
5613using WinApp.Api.Data;
5614using WinApp.Api.Interfaces;
5615using WinApp.Data.Helpers;
5616using WinApp.Data.Model;
5617
5618namespace WinApp.Managers.Interfaces
5619{
5620  public interface ISessionManager
5621  {
5622    Man CurrentUser { get; }
5623
5624    IApi Api { get; }
5625
5626    LoginResponce Login(string user, string password);
5627
5628    PingResponse PingSession(string activeModuleSecureKey);
5629
5630    void CloseSession();
5631
5632    Statistic[] GetStatistics();
5633
5634    Statistic[] GetStatistics(DateTime periodStart, DateTime periodEnd);
5635
5636    Purchase[] GetPurchases();
5637
5638    string GetAppVersion();
5639
5640    ModuleInfo GetModuleInfo(long productId);
5641
5642    byte[] GetModuleContent(long productId);
5643
5644    string Activation(long purchaseId);
5645
5646    void UpdateUserAgentString();
5647  }
5648}
5649?// Decompiled with JetBrains decompiler
5650// Type: WinApp.Managers.Interfaces.IApplicationSettings
5651// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5652// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5653// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5654
5655using WinApp.Managers.Localization;
5656
5657namespace WinApp.Managers.Interfaces
5658{
5659  internal interface IApplicationSettings
5660  {
5661    string Email { get; set; }
5662
5663    string Password { get; set; }
5664
5665    string ProtectedEmail { get; set; }
5666
5667    string ProtectedPassword { get; set; }
5668
5669    bool IsRemeberMe { get; set; }
5670
5671    bool RunAtStartup { get; set; }
5672
5673    bool IsAutoLogin { get; set; }
5674
5675    bool IsHttpUsed { get; set; }
5676
5677    string LocalizationKey { get; set; }
5678
5679    long ActiveProductId { get; set; }
5680
5681    void Save();
5682
5683    void SetLocalization(LocalizationObject localizationObject);
5684
5685    void SetRunAtStartup(bool isRunAtStartup);
5686
5687    void SetIsAutoLogin(bool isAutoLogin);
5688
5689    void SetHttpPingUsed(bool isHttpPingUsed);
5690
5691    LocalizationObject GetLocalizationObject();
5692
5693    void RemeberMe(string email, string passwordHash);
5694
5695    void ForgetMe();
5696  }
5697}
5698?// Decompiled with JetBrains decompiler
5699// Type: WinApp.Managers.Interfaces.ICountriesManager
5700// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5701// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5702// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5703
5704using System.Collections.Generic;
5705
5706namespace WinApp.Managers.Interfaces
5707{
5708  internal interface ICountriesManager
5709  {
5710    List<string> GetAllCountries();
5711  }
5712}
5713?// Decompiled with JetBrains decompiler
5714// Type: WinApp.Managers.Interfaces.IScreenManager
5715// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5716// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5717// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5718
5719using System;
5720using WinApp.Module;
5721using WinApp.View;
5722using WinApp.ViewModel.Services;
5723
5724namespace WinApp.Managers.Interfaces
5725{
5726  internal interface IScreenManager
5727  {
5728    MainViewUC MainView { get; }
5729
5730    void DoVisualSafe(Action action);
5731
5732    void ShowAlert(string message, string title);
5733
5734    void SwitchToMain();
5735
5736    void SwitchToLogin();
5737
5738    void SwitchToInstall(InstallModuleUC installModuleUc, ServiceVM serviceVm, Action<bool> onInstalledAction);
5739
5740    void SwitchToNewVersionAvailableWindow(Version appVersionOnSite, Version appVersionCurrent);
5741
5742    Action ShowStatusMessage(string message, int timeInSeconds, bool isInProgress = false);
5743  }
5744}
5745?// Decompiled with JetBrains decompiler
5746// Type: WinApp.Managers.Network.NetworkStateEventArgs
5747// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5748// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5749// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5750
5751using System;
5752using WinApp;
5753
5754namespace WinApp.Managers.Network
5755{
5756  internal class NetworkStateEventArgs : EventArgs
5757  {
5758    public NetworkState State { get; private set; }
5759
5760    public NetworkStateEventArgs(NetworkState state)
5761    {
5762      this.State = state;
5763    }
5764  }
5765}
5766?// Decompiled with JetBrains decompiler
5767// Type: WinApp.Managers.Network.NetworkMonitor
5768// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5769// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5770// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5771
5772using Inc.Logging;
5773using IncMap;
5774using System;
5775using System.Net;
5776using System.Net.NetworkInformation;
5777using System.Timers;
5778using WinApp;
5779using WinApp.Managers;
5780using WinApp.Managers.Interfaces;
5781
5782namespace WinApp.Managers.Network
5783{
5784  internal static class NetworkMonitor
5785  {
5786    private static NetworkState _networkState = NetworkState.None;
5787    private static bool _checkServerRecursion = true;
5788    private static bool _isHttpUsed = Map.Get<IApplicationSettings>().IsHttpUsed;
5789    private static int _failedPingAttemptsCount;
5790    private static System.Timers.Timer _networkMonitorTimer;
5791
5792    public static NetworkState NetworkState
5793    {
5794      get
5795      {
5796        return NetworkMonitor._networkState;
5797      }
5798      private set
5799      {
5800        if (NetworkMonitor._networkState == value)
5801          return;
5802        NetworkMonitor._networkState = value;
5803        Logger.WriteInfo(typeof (NetworkMonitor), "NetworkState", "NetworkState changed status on '" + NetworkMonitor._networkState.ToString() + "'");
5804        if (NetworkMonitor.NetworkStateChanged == null)
5805          return;
5806        NetworkMonitor.NetworkStateChanged((object) typeof (NetworkMonitor), new NetworkStateEventArgs(value));
5807      }
5808    }
5809
5810    public static event EventHandler<NetworkStateEventArgs> NetworkStateChanged;
5811
5812    public static event EventHandler<EventArgs> ConnectionAttemptFailed;
5813
5814    public static void StartNetworkMonitoring()
5815    {
5816      NetworkChange.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(NetworkMonitor.InternalNetworkAvailabilityChanged);
5817      NetworkMonitor.TransitNetworkStateChange(NetworkInterface.GetIsNetworkAvailable());
5818    }
5819
5820    internal static void SetPingThrough(bool useHttpFlag)
5821    {
5822      NetworkMonitor._isHttpUsed = useHttpFlag;
5823    }
5824
5825    internal static void CheckServerOff()
5826    {
5827      NetworkMonitor._checkServerRecursion = false;
5828    }
5829
5830    internal static void CheckServerOn(bool immediately = false)
5831    {
5832      NetworkMonitor._checkServerRecursion = true;
5833      NetworkMonitor.StartNetworkMonitorTimer(immediately, true);
5834    }
5835
5836    private static void InternalNetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
5837    {
5838      NetworkMonitor.TransitNetworkStateChange(e.IsAvailable);
5839    }
5840
5841    private static void OnConnectionAttemptFailed()
5842    {
5843      if (NetworkMonitor.ConnectionAttemptFailed == null)
5844        return;
5845      NetworkMonitor.ConnectionAttemptFailed((object) null, new EventArgs());
5846    }
5847
5848    private static void TransitNetworkStateChange(bool isNetworkAvailable)
5849    {
5850      NetworkMonitor._checkServerRecursion = true;
5851      if (isNetworkAvailable)
5852      {
5853        Logger.WriteInfo(typeof (NetworkMonitor), "TransitNetworkStateChange()", "???? ????????. ??????? ? ?????? ???????");
5854        NetworkMonitor.CheckServer();
5855      }
5856      else
5857      {
5858        NetworkMonitor.NetworkState = NetworkState.NetworkNotFound;
5859        Logger.WriteInfo(typeof (NetworkMonitor), "TransitNetworkStateChange()", "???? ?? ????????. ??????? ? ????? NetworkNotFound");
5860      }
5861    }
5862
5863    private static void CheckServer()
5864    {
5865      bool flag = NetworkMonitor._isHttpUsed ? NetworkMonitor.HttpPingServer() : NetworkMonitor.PingServer();
5866      if (NetworkMonitor._failedPingAttemptsCount == 2)
5867      {
5868        NetworkMonitor.OnConnectionAttemptFailed();
5869        ++NetworkMonitor._failedPingAttemptsCount;
5870      }
5871      else if (!flag && NetworkMonitor._failedPingAttemptsCount < 2)
5872        ++NetworkMonitor._failedPingAttemptsCount;
5873      if (flag)
5874      {
5875        NetworkMonitor._failedPingAttemptsCount = 0;
5876        NetworkMonitor.NetworkState = NetworkState.ServerOnline;
5877        NetworkMonitor.StartNetworkMonitorTimer(false, false);
5878      }
5879      else
5880      {
5881        Logger.WriteInfo(typeof (NetworkMonitor), "CheckServer()", "?????? ?? ????????.");
5882        if (!NetworkInterface.GetIsNetworkAvailable())
5883        {
5884          Logger.WriteInfo(typeof (NetworkMonitor), "CheckServer()", "?????????, ??? ??????? ????.");
5885          NetworkMonitor.TransitNetworkStateChange(false);
5886        }
5887        else
5888        {
5889          NetworkMonitor.NetworkState = NetworkState.ServerNotFound;
5890          NetworkMonitor.CheckServerOn(false);
5891        }
5892      }
5893    }
5894
5895    private static void StartNetworkMonitorTimer(bool immediatelyTick = false, bool isShortInterval = false)
5896    {
5897      if (!NetworkMonitor._checkServerRecursion)
5898        return;
5899      if (NetworkMonitor._networkMonitorTimer == null)
5900      {
5901        NetworkMonitor._networkMonitorTimer = new System.Timers.Timer(10000.0);
5902        NetworkMonitor._networkMonitorTimer.Elapsed += new ElapsedEventHandler(NetworkMonitor.OnNetworkMonitorTimerTick);
5903        Logger.WriteInfo(typeof (NetworkMonitor), "StartNetworkMonitorTimer()", "??????? ?????? ????? ???????");
5904      }
5905      NetworkMonitor._networkMonitorTimer.Interval = isShortInterval ? 1000.0 : 10000.0;
5906      if (!immediatelyTick)
5907      {
5908        NetworkMonitor._networkMonitorTimer.Start();
5909      }
5910      else
5911      {
5912        NetworkMonitor._networkMonitorTimer.Stop();
5913        NetworkMonitor.OnNetworkMonitorTimerTick();
5914      }
5915    }
5916
5917    private static void OnNetworkMonitorTimerTick(object sender, ElapsedEventArgs e)
5918    {
5919      NetworkMonitor.OnNetworkMonitorTimerTick();
5920    }
5921
5922    private static void OnNetworkMonitorTimerTick()
5923    {
5924      NetworkMonitor._networkMonitorTimer.Stop();
5925      NetworkMonitor.CheckServer();
5926    }
5927
5928    private static bool PingServer()
5929    {
5930      Ping ping = new Ping();
5931      Uri uri = new Uri(ApplicationSettings.ServiceUri);
5932      try
5933      {
5934        PingReply pingReply = ping.Send(uri.Host, 2000);
5935        return pingReply != null && pingReply.Status == IPStatus.Success;
5936      }
5937      catch (PingException ex)
5938      {
5939        Logger.WriteError((object) typeof (NetworkMonitor), "PingServer", "PingException when pinging the host " + uri.Host + ": " + ex.Message);
5940        return false;
5941      }
5942      catch (Exception ex)
5943      {
5944        Logger.WriteError((object) typeof (NetworkMonitor), "PingServer", "Exception when pinging the host  " + uri.Host + ": " + ex.Message);
5945        return false;
5946      }
5947    }
5948
5949    private static bool HttpPingServer()
5950    {
5951      Uri requestUri = new Uri(ApplicationSettings.ServiceUri);
5952      try
5953      {
5954        HttpWebRequest httpWebRequest = (HttpWebRequest) WebRequest.Create(requestUri);
5955        httpWebRequest.Timeout = 2000;
5956        httpWebRequest.AllowAutoRedirect = false;
5957        HttpWebResponse httpWebResponse = (HttpWebResponse) httpWebRequest.GetResponse();
5958        return true;
5959      }
5960      catch (PingException ex)
5961      {
5962        Logger.WriteError((object) typeof (NetworkMonitor), "PingServer", "PingException when pinging the host " + requestUri.Host + ": " + ex.Message);
5963        return false;
5964      }
5965      catch (WebException ex)
5966      {
5967        if (ex.Status == WebExceptionStatus.TrustFailure)
5968          return true;
5969        Logger.WriteError((object) typeof (NetworkMonitor), "PingServer", "Exception when pinging the host  " + requestUri.Host + ": " + ex.Message);
5970        return false;
5971      }
5972    }
5973  }
5974}
5975?// Decompiled with JetBrains decompiler
5976// Type: WinApp.Managers.Configuration.ConfigurationManager
5977// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
5978// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
5979// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
5980
5981using Inc.Logging;
5982using Microsoft.Win32;
5983using System;
5984using System.Collections.Generic;
5985using System.Drawing;
5986using System.IO;
5987using System.Linq;
5988using System.Reflection;
5989using System.Runtime.InteropServices;
5990using System.Text;
5991using System.Windows;
5992using WinApp.ViewModel;
5993
5994namespace WinApp.Managers.Configuration
5995{
5996  public static class ConfigurationManager
5997  {
5998    private const int VER_NT_WORKSTATION = 1;
5999    private const int VER_NT_DOMAIN_CONTROLLER = 2;
6000    private const int VER_NT_SERVER = 3;
6001    private const int VER_SUITE_SMALLBUSINESS = 1;
6002    private const int VER_SUITE_ENTERPRISE = 2;
6003    private const int VER_SUITE_TERMINAL = 16;
6004    private const int VER_SUITE_DATACENTER = 128;
6005    private const int VER_SUITE_SINGLEUSERTS = 256;
6006    private const int VER_SUITE_PERSONAL = 512;
6007    private const int VER_SUITE_BLADE = 1024;
6008    private static string _userAgentCache;
6009
6010    public static void Analyze()
6011    {
6012      Logger.WriteInfo((object) typeof (ConfigurationManager), "Analyze()", "???????????? ???????", string.Format("\n\t\t\t\t\t?????????? ????: {0}\n\t\t\t\t\t???????????? ???????: {1}\n\t\t\t\t\t?????? .Net Framework: {2}", (object) Environment.ProcessorCount, (object) ConfigurationManager.GetOsInfo(), (object) ConfigurationManager.GetFrameworkVersion()));
6013      Logger.WriteInfo((object) typeof (ConfigurationManager), "Analyze()", "???????????? ????????????", string.Format("\n\t\t\t\t\t??? ??????: {0}\n\t\t\t\t\t?????: {1}\n\t\t\t\t\t??? ????????????: {2}", (object) Environment.MachineName, (object) Environment.UserDomainName, (object) Environment.UserName));
6014      Graphics graphics = Graphics.FromHwnd(IntPtr.Zero);
6015      Logger.WriteInfo((object) typeof (ConfigurationManager), "Analyze()", "???????????? ??????", string.Format("\n\t\t\t\t\t?????????? ??????: {0}x{1}\n\t\t\t\t\tDpi X: {2}\n\t\t\t\t\tDpi Y: {3}", (object) (SystemParameters.PrimaryScreenWidth / 96.0 * (double) graphics.DpiX), (object) (SystemParameters.PrimaryScreenHeight / 96.0 * (double) graphics.DpiY), (object) graphics.DpiX, (object) graphics.DpiY));
6016    }
6017
6018    public static void UpdateUserAgent()
6019    {
6020      ConfigurationManager._userAgentCache = string.Empty;
6021    }
6022
6023    public static string GetUserAgent()
6024    {
6025      if (!string.IsNullOrEmpty(ConfigurationManager._userAgentCache))
6026        return ConfigurationManager._userAgentCache;
6027      Version currentAppVersion = AppVM.Instance.GetCurrentAppVersion();
6028      string str = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modules\\Rent module\\RentModule.dll");
6029      Version version = (Version) null;
6030      if (File.Exists(str))
6031        version = AssemblyName.GetAssemblyName(str).Version;
6032      string format = "KairosPlanet/{0} ({1}; .Net Framework {2}) {3}";
6033      object[] objArray = new object[4]
6034      {
6035        (object) currentAppVersion,
6036        (object) ConfigurationManager.GetOsInfo(),
6037        (object) ConfigurationManager.GetFrameworkVersion(),
6038        version == (Version) null ? (object) string.Empty : (object) ("RentModule/" + (object) version)
6039      };
6040      return ConfigurationManager._userAgentCache = string.Format(format, objArray);
6041    }
6042
6043    private static string GetFrameworkVersion()
6044    {
6045      try
6046      {
6047        using (RegistryKey registryKey1 = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, string.Empty).OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\"))
6048        {
6049          if (registryKey1 == null)
6050            return "?? ????????";
6051          List<string> list = new List<string>();
6052          foreach (string name1 in registryKey1.GetSubKeyNames())
6053          {
6054            if (name1.StartsWith("v"))
6055            {
6056              RegistryKey registryKey2 = registryKey1.OpenSubKey(name1);
6057              if (registryKey2 != null)
6058              {
6059                string str1 = (string) registryKey2.GetValue("Version", (object) string.Empty);
6060                string str2 = registryKey2.GetValue("SP", (object) string.Empty).ToString();
6061                string str3 = registryKey2.GetValue("Install", (object) string.Empty).ToString();
6062                if (!string.IsNullOrEmpty(str3) && !string.IsNullOrEmpty(str2) && str3 == "1")
6063                  list.Add(string.Format("{0} {1} SP{2}", (object) name1, (object) str1, (object) str2));
6064                if (string.IsNullOrEmpty(str1))
6065                {
6066                  foreach (string name2 in registryKey2.GetSubKeyNames())
6067                  {
6068                    RegistryKey registryKey3 = registryKey2.OpenSubKey(name2);
6069                    if (registryKey3 != null)
6070                    {
6071                      string str4 = (string) registryKey3.GetValue("Version", (object) string.Empty);
6072                      if (!string.IsNullOrEmpty(str4))
6073                        str2 = registryKey3.GetValue("SP", (object) string.Empty).ToString();
6074                      string str5 = registryKey3.GetValue("Install", (object) string.Empty).ToString();
6075                      if (string.IsNullOrEmpty(str5))
6076                        list.Add(string.Format("{0} {1}", (object) name1, (object) str4));
6077                      else if (!string.IsNullOrEmpty(str2) && str5 == "1")
6078                        list.Add(string.Format("{0} {1} SP{2}", (object) name1, (object) str4, (object) str2));
6079                      else if (str5 == "1")
6080                        list.Add(string.Format("v{0} {1}", (object) str4, (object) name2));
6081                    }
6082                  }
6083                }
6084              }
6085            }
6086          }
6087          return Enumerable.FirstOrDefault<string>((IEnumerable<string>) Enumerable.OrderByDescending<string, string>((IEnumerable<string>) list, (Func<string, string>) (x => x)));
6088        }
6089      }
6090      catch (Exception ex)
6091      {
6092        Logger.WriteError(typeof (ConfigurationManager), "GetFrameworkVersion()", "?? ??????? ???????? ?????? framework", ex);
6093        return "?? ????????";
6094      }
6095    }
6096
6097    private static string GetOsInfo()
6098    {
6099      StringBuilder stringBuilder = new StringBuilder(string.Format("{0} ({1}) - version: {2}", (object) ConfigurationManager.GetOsName(), (object) ConfigurationManager.GetProcessorArchitecture(), (object) Environment.OSVersion.Version));
6100      string osServicePack = ConfigurationManager.GetOsServicePack();
6101      if (!string.IsNullOrEmpty(osServicePack))
6102        stringBuilder.AppendFormat(" {0}", (object) osServicePack);
6103      string osProductType = ConfigurationManager.GetOsProductType();
6104      if (!string.IsNullOrEmpty(osProductType))
6105        stringBuilder.AppendFormat(" - {0}", (object) osProductType);
6106      return stringBuilder.ToString();
6107    }
6108
6109    private static string GetProcessorArchitecture()
6110    {
6111      string environmentVariable = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
6112      if (string.IsNullOrEmpty(environmentVariable))
6113        return "?? ????????";
6114      return environmentVariable == "AMD64" ? "x64" : "x86";
6115    }
6116
6117    private static string GetOsName()
6118    {
6119      try
6120      {
6121        OperatingSystem osVersion = Environment.OSVersion;
6122        switch (osVersion.Platform)
6123        {
6124          case PlatformID.Win32Windows:
6125            switch (osVersion.Version.Minor)
6126            {
6127              case 0:
6128                return "Windows 95";
6129              case 10:
6130                return osVersion.Version.Revision.ToString() == "2222A" ? "Windows 98 Second Edition" : "Windows 98";
6131              case 90:
6132                return "Windows Me";
6133            }
6134          case PlatformID.Win32NT:
6135            switch (osVersion.Version.Major)
6136            {
6137              case 3:
6138                return "Windows NT 3.51";
6139              case 4:
6140                return "Windows NT 4.0";
6141              case 5:
6142                switch (osVersion.Version.Minor)
6143                {
6144                  case 0:
6145                    return "Windows 2000";
6146                  case 1:
6147                    return "Windows XP";
6148                  case 2:
6149                    return "Windows Server 2003";
6150                }
6151              case 6:
6152                OSVERSIONINFOEX? osVersionInfo = ConfigurationManager.GetOsVersionInfo();
6153                switch (osVersion.Version.Minor)
6154                {
6155                  case 0:
6156                    if (!osVersionInfo.HasValue)
6157                      return "Windows Vista/Windows Server 2008";
6158                    return (int) osVersionInfo.Value.wProductType == 1 ? "Windows Vista" : "Windows Server 2008";
6159                  case 1:
6160                    if (!osVersionInfo.HasValue)
6161                      return "Windows 7/Windows Server 2008 R2";
6162                    return (int) osVersionInfo.Value.wProductType == 1 ? "Windows 7" : "Windows Server 2008 R2";
6163                  case 2:
6164                    if (!osVersionInfo.HasValue)
6165                      return "Windows 8/Windows Server 2012";
6166                    return (int) osVersionInfo.Value.wProductType == 1 ? "Windows 8" : "Windows Server 2012";
6167                  case 3:
6168                    if (!osVersionInfo.HasValue)
6169                      return "Windows 8.1/Windows Server 2012 R2";
6170                    return (int) osVersionInfo.Value.wProductType == 1 ? "Windows 8.1" : "Windows Server 2012 R2";
6171                }
6172              case 10:
6173                return "Windows 10";
6174            }
6175        }
6176      }
6177      catch (Exception ex)
6178      {
6179        Logger.WriteError(typeof (ConfigurationManager), "GetOsName()", "?? ??????? ???????? ???????? ??", ex);
6180      }
6181      return "?? ????????";
6182    }
6183
6184    private static string GetOsServicePack()
6185    {
6186      try
6187      {
6188        OSVERSIONINFOEX? osVersionInfo = ConfigurationManager.GetOsVersionInfo();
6189        if (!osVersionInfo.HasValue)
6190          return string.Empty;
6191        return osVersionInfo.Value.szCSDVersion;
6192      }
6193      catch (Exception ex)
6194      {
6195        Logger.WriteError(typeof (ConfigurationManager), "GetOsServicePack()", "?? ??????? ???????? ????????? ????? ??", ex);
6196      }
6197      return "?? ????????";
6198    }
6199
6200    private static string GetOsProductType()
6201    {
6202      try
6203      {
6204        OSVERSIONINFOEX? osVersionInfo = ConfigurationManager.GetOsVersionInfo();
6205        if (!osVersionInfo.HasValue)
6206          return string.Empty;
6207        OperatingSystem osVersion = Environment.OSVersion;
6208        if (osVersion.Version.Major == 4)
6209        {
6210          if ((int) osVersionInfo.Value.wProductType == 1)
6211            return "Workstation";
6212          if ((int) osVersionInfo.Value.wProductType == 3)
6213            return "Server";
6214          return string.Empty;
6215        }
6216        if (osVersion.Version.Major == 5)
6217        {
6218          if ((int) osVersionInfo.Value.wProductType == 1)
6219            return ((int) osVersionInfo.Value.wSuiteMask & 512) == 512 ? "Home Edition" : "Professional";
6220          if ((int) osVersionInfo.Value.wProductType == 3)
6221          {
6222            if (osVersion.Version.Minor == 0)
6223            {
6224              if (((int) osVersionInfo.Value.wSuiteMask & 128) == 128)
6225                return "Datacenter Server";
6226              return ((int) osVersionInfo.Value.wSuiteMask & 2) == 2 ? "Advanced Server" : "Server";
6227            }
6228          }
6229          else
6230          {
6231            if (((int) osVersionInfo.Value.wSuiteMask & 128) == 128)
6232              return "Datacenter Edition";
6233            if (((int) osVersionInfo.Value.wSuiteMask & 2) == 2)
6234              return "Enterprise Edition";
6235            return ((int) osVersionInfo.Value.wSuiteMask & 1024) == 1024 ? "Web Edition" : "Standard Edition";
6236          }
6237        }
6238      }
6239      catch (Exception ex)
6240      {
6241        Logger.WriteError(typeof (ConfigurationManager), "GetOsProductType()", "?? ??????? ???????? ??? ???????? ??", ex);
6242      }
6243      return string.Empty;
6244    }
6245
6246    private static OSVERSIONINFOEX? GetOsVersionInfo()
6247    {
6248      OSVERSIONINFOEX osVersionInfo = new OSVERSIONINFOEX()
6249      {
6250        dwOSVersionInfoSize = Marshal.SizeOf(typeof (OSVERSIONINFOEX))
6251      };
6252      if (!ConfigurationManager.GetVersionEx(ref osVersionInfo))
6253        return new OSVERSIONINFOEX?();
6254      return new OSVERSIONINFOEX?(osVersionInfo);
6255    }
6256
6257    [DllImport("kernel32.dll")]
6258    private static extern bool GetVersionEx(ref OSVERSIONINFOEX osVersionInfo);
6259  }
6260}
6261?// Decompiled with JetBrains decompiler
6262// Type: WinApp.Managers.Configuration.OSVERSIONINFOEX
6263// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6264// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6265// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6266
6267using System.Runtime.InteropServices;
6268
6269namespace WinApp.Managers.Configuration
6270{
6271  public struct OSVERSIONINFOEX
6272  {
6273    public int dwOSVersionInfoSize;
6274    public int dwMajorVersion;
6275    public int dwMinorVersion;
6276    public int dwBuildNumber;
6277    public int dwPlatformId;
6278    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
6279    public string szCSDVersion;
6280    public short wServicePackMajor;
6281    public short wServicePackMinor;
6282    public short wSuiteMask;
6283    public byte wProductType;
6284    public byte wReserved;
6285  }
6286}
6287?// Decompiled with JetBrains decompiler
6288// Type: WinApp.Managers.Localization.ILocalizationManager
6289// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6290// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6291// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6292
6293using System.Collections.ObjectModel;
6294
6295namespace WinApp.Managers.Localization
6296{
6297  public interface ILocalizationManager
6298  {
6299    ObservableCollection<LocalizationObject> LanguagesCollection { get; }
6300
6301    void ApplyLocalization();
6302  }
6303}
6304?// Decompiled with JetBrains decompiler
6305// Type: WinApp.Managers.Localization.LocalizationObject
6306// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6307// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6308// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6309
6310namespace WinApp.Managers.Localization
6311{
6312  public class LocalizationObject
6313  {
6314    public string LocalizationKey { get; set; }
6315
6316    public string LanguageName { get; set; }
6317
6318    public string CountryName { get; set; }
6319  }
6320}
6321?// Decompiled with JetBrains decompiler
6322// Type: WinApp.Managers.Localization.LocalizationManager
6323// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6324// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6325// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6326
6327using Inc.Logging;
6328using IncMap;
6329using KairosPlanet.Managers.Localization;
6330using System;
6331using System.Collections.ObjectModel;
6332using System.Globalization;
6333using System.Threading;
6334using WinApp.Managers.Interfaces;
6335
6336namespace WinApp.Managers.Localization
6337{
6338  public class LocalizationManager : ILocalizationManager
6339  {
6340    public ObservableCollection<LocalizationObject> LanguagesCollection { get; private set; }
6341
6342    public LocalizationManager()
6343    {
6344      this.Initialize();
6345    }
6346
6347    public void ApplyLocalization()
6348    {
6349      string localizationKey1 = Map.Get<IApplicationSettings>().LocalizationKey;
6350      Logger.WriteInfo(typeof (LocalizationManager), "ApplyLocalization()", "?????????? ??????????? ?? ????? ApplicationSettings...");
6351      try
6352      {
6353        Thread.CurrentThread.CurrentCulture = (CultureInfo) new UnifyCultureInfo(localizationKey1);
6354        Thread.CurrentThread.CurrentUICulture = (CultureInfo) new UnifyCultureInfo(localizationKey1);
6355        Logger.WriteInfo(typeof (LocalizationManager), "ApplyLocalization()", string.Format("??????????? '{0}' ??????? ?????????", (object) localizationKey1));
6356      }
6357      catch (Exception ex1)
6358      {
6359        Logger.WriteWarning(typeof (LocalizationManager), "ApplyLocalization()", string.Format("?????? ??? ?????????? ??????????? '{0}'. ????? ????????? ??????????? ???????????", (object) localizationKey1));
6360        try
6361        {
6362          string localizationKey2 = this.LanguagesCollection[0].LocalizationKey;
6363          Map.Get<IApplicationSettings>().LocalizationKey = localizationKey2;
6364          Thread.CurrentThread.CurrentCulture = (CultureInfo) new UnifyCultureInfo(localizationKey2);
6365          Thread.CurrentThread.CurrentUICulture = (CultureInfo) new UnifyCultureInfo(localizationKey2);
6366          Logger.WriteInfo(typeof (LocalizationManager), "ApplyLocalization()", string.Format("??????????? '{0}' ??????? ?????????", (object) localizationKey2));
6367        }
6368        catch (Exception ex2)
6369        {
6370          Logger.WriteError(typeof (LocalizationManager), "ApplyLocalization()", string.Format("?????? ??? ?????????? ???????????"), ex2);
6371        }
6372      }
6373    }
6374
6375    private void Initialize()
6376    {
6377      Logger.WriteInfo(typeof (LocalizationManager), "Initialize()", "????????????? ?????? ???????????...");
6378      this.LanguagesCollection = new ObservableCollection<LocalizationObject>();
6379      this.LanguagesCollection.Add(new LocalizationObject()
6380      {
6381        LanguageName = "English",
6382        LocalizationKey = "en-US",
6383        CountryName = "USA"
6384      });
6385      this.LanguagesCollection.Add(new LocalizationObject()
6386      {
6387        LanguageName = "???????",
6388        LocalizationKey = "ru-RU",
6389        CountryName = "??????"
6390      });
6391      Logger.WriteInfo(typeof (LocalizationManager), "Initialize()", "?????? ??????????? ??????? ???????????????");
6392    }
6393  }
6394}
6395?// Decompiled with JetBrains decompiler
6396// Type: WinApp.Managers.PingEventArgs
6397// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6398// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6399// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6400
6401namespace WinApp.Managers
6402{
6403  public class PingEventArgs
6404  {
6405    public long LifeTime { get; private set; }
6406
6407    public PingEventArgs(long lifeTime)
6408    {
6409      this.LifeTime = lifeTime;
6410    }
6411  }
6412}
6413?// Decompiled with JetBrains decompiler
6414// Type: WinApp.Managers.ModuleResolver
6415// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6416// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6417// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6418
6419using Inc.Logging;
6420using IncMap;
6421using Ionic.Zip;
6422using System;
6423using System.Collections.Generic;
6424using System.IO;
6425using System.Linq;
6426using System.Reflection;
6427using System.Runtime.Serialization;
6428using WinApp.Data.Model;
6429using WinApp.Managers.Interfaces;
6430using WinApp.Module;
6431
6432namespace WinApp.Managers
6433{
6434  public class ModuleResolver : IModuleResolver, IModuleCallback
6435  {
6436    private static Dictionary<string, IModuleManager> _moduleManagerDictionary = new Dictionary<string, IModuleManager>();
6437    private Dictionary<long, ModuleInfo> _moduleInfoDictionary = new Dictionary<long, ModuleInfo>();
6438
6439    public IModuleManager GetModuleManager(ModuleInfo moduleInfo)
6440    {
6441      if (moduleInfo == null)
6442        throw new ArgumentException("Module info is null", "moduleInfo");
6443      Logger.WriteInfo((object) this, "GetModuleManager()", string.Format("?????? ????????? ?????? - {0}", (object) moduleInfo.Title));
6444      string str = Path.Combine(ModuleResolver.GetModulesFolderPath(), ModuleResolver.GetModuleInfoFileName(moduleInfo));
6445      bool flag = true;
6446      if (File.Exists(str))
6447      {
6448        Logger.WriteInfo((object) this, "GetModuleManager()", "Module already exist");
6449        Version version1 = new Version(ModuleResolver.ReadModuleInfo(str).Version);
6450        Version version2 = new Version(moduleInfo.Version);
6451        flag = version2 != version1;
6452        Logger.WriteInfo((object) this, "GetModuleManager()", string.Format("Module version on site: '{0}' and version local: '{1}'", (object) version2, (object) version1));
6453      }
6454      if (flag)
6455      {
6456        Logger.WriteInfo((object) this, "GetModuleManager()", "Module need update");
6457        if (!this.DownloadModule(moduleInfo))
6458        {
6459          Logger.WriteError((object) this, "GetModuleManager", "Module is not downloaded");
6460          return (IModuleManager) null;
6461        }
6462        if (!ModuleResolver.DeployedModule(moduleInfo))
6463        {
6464          Logger.WriteError((object) this, "GetModuleManager", "Module is not deployed");
6465          return (IModuleManager) null;
6466        }
6467        Map.Get<ISessionManager>().UpdateUserAgentString();
6468      }
6469      return ModuleResolver.GetInstanceModuleManager(moduleInfo);
6470    }
6471
6472    public ModuleInfo GetModuleInfoFromSite(long productId)
6473    {
6474      Logger.WriteInfo((object) this, "GetModuleInfoFromSite", "Get module info for productId = " + (object) productId);
6475      ModuleInfo moduleInfo = Map.Get<ISessionManager>().GetModuleInfo(productId);
6476      if (moduleInfo == null)
6477      {
6478        Logger.WriteError((object) this, "GetModuleInfoFromSite", "Module info from site is not received");
6479        return (ModuleInfo) null;
6480      }
6481      if (this._moduleInfoDictionary.ContainsKey(productId))
6482        this._moduleInfoDictionary[productId] = moduleInfo;
6483      else
6484        this._moduleInfoDictionary.Add(productId, moduleInfo);
6485      return moduleInfo;
6486    }
6487
6488    public ModuleInfo GetModuleInfo(long productId)
6489    {
6490      if (this._moduleInfoDictionary.ContainsKey(productId))
6491        return this._moduleInfoDictionary[productId];
6492      return this.GetModuleInfoFromSite(productId);
6493    }
6494
6495    public bool DownloadModule(ModuleInfo moduleInfo)
6496    {
6497      try
6498      {
6499        Logger.WriteInfo((object) this, "DownloadModule", "Start download module " + moduleInfo.Title);
6500        long productId = moduleInfo.ProductId;
6501        ModuleInfo moduleInfo1 = Map.Get<ISessionManager>().GetModuleInfo(productId);
6502        byte[] moduleContent = Map.Get<ISessionManager>().GetModuleContent(productId);
6503        Logger.WriteInfo((object) this, "DownloadModule", "Content for module " + moduleInfo.Title + " downloaded");
6504        ModuleResolver.SaveModuleFile(moduleContent, moduleInfo);
6505        Logger.WriteInfo((object) this, "DownloadModule", "Content for module " + moduleInfo.Title + " saved");
6506        string filePath = Path.Combine(ModuleResolver.GetDownloadsModuleFolderPath(moduleInfo), ModuleResolver.GetModuleInfoFileName(moduleInfo));
6507        ModuleResolver.SaveModuleInfo(moduleInfo1, filePath);
6508        Logger.WriteInfo((object) this, "DownloadModule", "ModuleInfo for module " + moduleInfo.Title + " saved");
6509        Logger.WriteInfo((object) this, "DownloadModule", "Module " + moduleInfo.Title + " downloaded successful");
6510        return true;
6511      }
6512      catch (Exception ex)
6513      {
6514        Logger.WriteError((object) this, "DownloadModule", "Error throw download module", ex);
6515        return false;
6516      }
6517    }
6518
6519    public string GetActiveModuleSecureKey()
6520    {
6521      try
6522      {
6523        long activeProductId = Map.Get<IApplicationSettings>().ActiveProductId;
6524        if (activeProductId == 0L)
6525          return string.Empty;
6526        ModuleInfo moduleInfo = this.GetModuleInfo(activeProductId);
6527        if (moduleInfo == null)
6528          return string.Empty;
6529        IModuleManager moduleManager = this.GetModuleManager(moduleInfo);
6530        if (moduleManager == null)
6531          return string.Empty;
6532        return moduleManager.GetSecurityKey((IModuleCallback) this);
6533      }
6534      catch (Exception ex)
6535      {
6536        Logger.WriteError((object) this, "GetActiveModuleSecureKey()", "Error by GetActiveModuleSecureKey", ex);
6537        return string.Empty;
6538      }
6539    }
6540
6541    public ModuleSettings GetModuleSettings(string moduleId)
6542    {
6543      return SettingsForAllModules.GetModuleSettings(moduleId);
6544    }
6545
6546    public void SaveModuleSettings(ModuleSettings moduleSettings)
6547    {
6548      SettingsForAllModules.SaveModuleSettings(moduleSettings);
6549    }
6550
6551    private static bool DeployedModule(ModuleInfo moduleInfo)
6552    {
6553      try
6554      {
6555        Logger.WriteInfo(typeof (ModuleResolver), "DeployedModule", "Start deploy for module " + moduleInfo.Title);
6556        string moduleFolderPath1 = ModuleResolver.GetDownloadsModuleFolderPath(moduleInfo);
6557        string moduleFolderPath2 = ModuleResolver.GetModuleFolderPath(moduleInfo);
6558        string moduleFolderPath3 = ModuleResolver.GetBackupModuleFolderPath(moduleInfo);
6559        if (Directory.Exists(moduleFolderPath2))
6560        {
6561          string[] files = Directory.GetFiles(moduleFolderPath2);
6562          if (files != null && files.Length > 0)
6563          {
6564            if (Directory.Exists(moduleFolderPath3))
6565              Directory.Delete(moduleFolderPath3, true);
6566            DirectoryInfo directoryInfo = new DirectoryInfo(moduleFolderPath3);
6567            if (!directoryInfo.Parent.Exists)
6568              directoryInfo.Parent.Create();
6569            Directory.Move(moduleFolderPath2, moduleFolderPath3);
6570          }
6571          Logger.WriteInfo(typeof (ModuleResolver), "DeployedModule", "Backup module " + moduleInfo.Title + " execute successful");
6572        }
6573        if (!Directory.Exists(moduleFolderPath2))
6574          Directory.CreateDirectory(moduleFolderPath2);
6575        new ZipFile(ModuleResolver.GetDownloadsModuleFilePath(moduleInfo)).ExtractAll(moduleFolderPath2);
6576        Logger.WriteInfo(typeof (ModuleResolver), "DeployedModule", "Module " + moduleInfo.Title + " unziped to folder " + moduleFolderPath2);
6577        File.Copy(Path.Combine(moduleFolderPath1, ModuleResolver.GetModuleInfoFileName(moduleInfo)), Path.Combine(ModuleResolver.GetModulesFolderPath(), ModuleResolver.GetModuleInfoFileName(moduleInfo)), true);
6578        Logger.WriteInfo(typeof (ModuleResolver), "DeployedModule", "ModuleInfo for module " + moduleInfo.Title + " moved to work folder");
6579        Logger.WriteInfo(typeof (ModuleResolver), "DeployedModule", "Module " + moduleInfo.Title + " deployed successful");
6580        return true;
6581      }
6582      catch (Exception ex)
6583      {
6584        Logger.WriteError(typeof (ModuleResolver), "DeployedModule", "Deploy module error", ex);
6585        return false;
6586      }
6587    }
6588
6589    private static void SaveModuleFile(byte[] content, ModuleInfo moduleInfo)
6590    {
6591      string downloadsModuleFilePath = ModuleResolver.GetDownloadsModuleFilePath(moduleInfo);
6592      FileInfo fileInfo = new FileInfo(downloadsModuleFilePath);
6593      if (!fileInfo.Directory.Exists)
6594        fileInfo.Directory.Create();
6595      using (FileStream fileStream = File.Open(downloadsModuleFilePath, FileMode.Create))
6596        fileStream.Write(content, 0, content.Length);
6597    }
6598
6599    private static IModuleManager GetInstanceModuleManager(ModuleInfo moduleInfo)
6600    {
6601      try
6602      {
6603        if (ModuleResolver._moduleManagerDictionary.ContainsKey(moduleInfo.Title))
6604          return ModuleResolver._moduleManagerDictionary[moduleInfo.Title];
6605        string moduleFolderPath = ModuleResolver.GetModuleFolderPath(moduleInfo);
6606        string title = moduleInfo.Title;
6607        if (!Directory.Exists(moduleFolderPath))
6608          return (IModuleManager) null;
6609        foreach (string path in Directory.GetFiles(moduleFolderPath, "*.dll"))
6610        {
6611          IModuleManager imoduleManager = (IModuleManager) null;
6612          Assembly assembly = Assembly.LoadFile(path);
6613          Type type1 = (Type) null;
6614          try
6615          {
6616            foreach (Type type2 in assembly.GetTypes())
6617            {
6618              if (Enumerable.Contains<Type>((IEnumerable<Type>) type2.GetInterfaces(), typeof (IModuleManager)))
6619              {
6620                type1 = type2;
6621                break;
6622              }
6623            }
6624            if (type1 == null)
6625              continue;
6626          }
6627          catch (ReflectionTypeLoadException ex)
6628          {
6629            Logger.WriteError(typeof (ModuleResolver), "GetModuleManager()", string.Format("?? ??????? ???????? ???? ?????????? '{0}'", (object) title), (Exception) ex);
6630            continue;
6631          }
6632          try
6633          {
6634            imoduleManager = (IModuleManager) Activator.CreateInstance(type1);
6635            if (!ModuleResolver._moduleManagerDictionary.ContainsKey(moduleInfo.Title))
6636              ModuleResolver._moduleManagerDictionary.Add(moduleInfo.Title, imoduleManager);
6637            return imoduleManager;
6638          }
6639          catch (InvalidCastException ex)
6640          {
6641            Logger.WriteError(typeof (ModuleResolver), "GetModuleManager()", "?? ??????? ???????? ?????? ? ???? 'IModuleManager'", (Exception) ex);
6642          }
6643          if (imoduleManager != null)
6644            Logger.WriteInfo(typeof (ModuleResolver), "GetModuleManager()", string.Format("?????? ??????? ???????? - {0}", (object) title));
6645        }
6646      }
6647      catch (Exception ex)
6648      {
6649        Logger.WriteError(typeof (ModuleResolver), "GetInstanceModuleManager", "Instance of module manager not loaded", ex);
6650      }
6651      return (IModuleManager) null;
6652    }
6653
6654    private static string GetDownloadsModuleFilePath(ModuleInfo moduleInfo)
6655    {
6656      return Path.Combine(ModuleResolver.GetDownloadsModuleFolderPath(moduleInfo), moduleInfo.Filename);
6657    }
6658
6659    private static string GetModuleInfoFileName(ModuleInfo moduleInfo)
6660    {
6661      return string.Format("{0}.ModuleInfo.xml", (object) moduleInfo.Title);
6662    }
6663
6664    private static void SaveModuleInfo(ModuleInfo moduleInfo, string filePath)
6665    {
6666      using (FileStream fileStream = File.Open(filePath, FileMode.Create))
6667        new DataContractSerializer(typeof (ModuleInfo)).WriteObject((Stream) fileStream, (object) moduleInfo);
6668    }
6669
6670    private static ModuleInfo ReadModuleInfo(string filePath)
6671    {
6672      if (!File.Exists(filePath))
6673        return (ModuleInfo) null;
6674      try
6675      {
6676        using (FileStream fileStream = File.Open(filePath, FileMode.Open))
6677          return (ModuleInfo) new DataContractSerializer(typeof (ModuleInfo)).ReadObject((Stream) fileStream);
6678      }
6679      catch (Exception ex)
6680      {
6681        Logger.WriteError(typeof (ModuleResolver), "ReadModuleInfo()", "Error: ", ex);
6682        return (ModuleInfo) null;
6683      }
6684    }
6685
6686    private static string GetDownloadsModuleFolderPath(ModuleInfo moduleInfo)
6687    {
6688      return Path.Combine(Environment.CurrentDirectory, string.Format("DownloadedModules\\{0}", (object) moduleInfo.Title));
6689    }
6690
6691    private static string GetBackupModuleFolderPath(ModuleInfo moduleInfo)
6692    {
6693      return Path.Combine(Environment.CurrentDirectory, string.Format("BackupModules\\{0}", (object) moduleInfo.Title));
6694    }
6695
6696    private static string GetModuleFolderPath(ModuleInfo moduleInfo)
6697    {
6698      return Path.Combine(ModuleResolver.GetModulesFolderPath(), moduleInfo.Title);
6699    }
6700
6701    private static string GetModulesFolderPath()
6702    {
6703      return Path.Combine(Environment.CurrentDirectory, "Modules");
6704    }
6705  }
6706}
6707?// Decompiled with JetBrains decompiler
6708// Type: WinApp.Managers.CountriesManager
6709// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6710// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6711// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6712
6713using Inc.Logging;
6714using IncMap;
6715using System;
6716using System.Collections.Generic;
6717using System.IO;
6718using System.Linq;
6719using System.Xml.Serialization;
6720using WinApp.Managers.Interfaces;
6721using WinApp.Managers.Localization;
6722
6723namespace WinApp.Managers
6724{
6725  internal class CountriesManager : ICountriesManager
6726  {
6727    private List<string> _deserializedCountries = new List<string>();
6728
6729    protected string FilePath
6730    {
6731      get
6732      {
6733        return Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "WinApp"), string.Format("countries.xml"));
6734      }
6735    }
6736
6737    public CountriesManager()
6738    {
6739      this.DeserializeCountries();
6740      this._deserializedCountries = new List<string>(Enumerable.Select<LocalizationObject, string>((IEnumerable<LocalizationObject>) Map.Get<ILocalizationManager>().LanguagesCollection, (Func<LocalizationObject, string>) (x => x.CountryName)));
6741    }
6742
6743    public List<string> GetAllCountries()
6744    {
6745      return this._deserializedCountries;
6746    }
6747
6748    private List<string> DeserializeCountries()
6749    {
6750      Logger.WriteError((object) typeof (CountriesManager), "DeserializeCountries()", "????????? ?????? ????? ?? ?????");
6751      if (!File.Exists(this.FilePath))
6752      {
6753        Logger.WriteWarning(typeof (CountriesManager), "DeserializeCountries()", "???? ?? ??????? ????? ?? ??????");
6754        return (List<string>) null;
6755      }
6756      List<string> list;
6757      try
6758      {
6759        XmlSerializer xmlSerializer = new XmlSerializer(typeof (List<string>));
6760        TextReader textReader = (TextReader) new StreamReader(this.FilePath);
6761        list = (List<string>) xmlSerializer.Deserialize(textReader);
6762        textReader.Close();
6763        Logger.WriteWarning(typeof (CountriesManager), "DeserializeCountries()", "?????? ????? ??????? ???????");
6764      }
6765      catch (Exception ex)
6766      {
6767        list = (List<string>) null;
6768        Logger.WriteError(typeof (CountriesManager), "DeserializeCountries()", "?????? ??? ????????? ????? ?? ?????", ex);
6769      }
6770      return list;
6771    }
6772  }
6773}
6774?// Decompiled with JetBrains decompiler
6775// Type: WinApp.Managers.SessionManager
6776// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
6777// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
6778// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
6779
6780using Inc.Logging;
6781using IncMap;
6782using KairosPlanet.Managers.Network;
6783using KairosPlanet.Properties;
6784using System;
6785using System.Net;
6786using System.ServiceModel;
6787using System.Windows;
6788using WinApp.Api;
6789using WinApp.Api.Data;
6790using WinApp.Api.Interfaces;
6791using WinApp.Data.Helpers;
6792using WinApp.Data.Model;
6793using WinApp.Managers.Configuration;
6794using WinApp.Managers.Interfaces;
6795
6796namespace WinApp.Managers
6797{
6798  public class SessionManager : ISessionManager
6799  {
6800    private IAuthApi _api;
6801    private Man _currentUser;
6802
6803    public Man CurrentUser
6804    {
6805      get
6806      {
6807        return this._currentUser;
6808      }
6809    }
6810
6811    public IApi Api
6812    {
6813      get
6814      {
6815        return (IApi) this._api;
6816      }
6817    }
6818
6819    public LoginResponce Login(string user, string password)
6820    {
6821      CheckPoint checkPoint = Logger.CheckPointStart("Login(user, password)");
6822      Logger.WriteInfo((object) this, "Login()", "Connect to service " + ApplicationSettings.ServiceUri);
6823      this._api = Map.Get<IClientFactory>().CreateChannel(user, password, ApplicationSettings.ServiceUri, ConfigurationManager.GetUserAgent());
6824      this._api.SetUserData(user, password);
6825      try
6826      {
6827        UserResponse user1 = this._api.GetUser();
6828        if (user1.User == null)
6829          return LoginResponce.NoResponce;
6830        if (user1.User.Email != user)
6831        {
6832          Logger.WriteError((object) this, "Login()", "?????? ?????? ????? ??????? ????????????.");
6833          user1 = this._api.GetUser();
6834          if (string.Equals(user1.User.Name, user, StringComparison.InvariantCultureIgnoreCase))
6835          {
6836            Logger.WriteError((object) this, "Login()", "?????? ?????? ?????? ????? ??????? ????????????.");
6837            SessionMonitor.Instance.SetSessionStateToSuspended();
6838            int num = (int) MessageBox.Show(Resources.Error_ServerReturnIncorrectData, "Error", MessageBoxButton.OK, MessageBoxImage.Hand);
6839            throw new ApiException("?????? ?????? ????? ??????? ????????????.", HttpStatusCode.InternalServerError, "");
6840          }
6841        }
6842        this._currentUser = user1.User;
6843        SessionMonitor.Instance.SetSessionStateToLogon();
6844        return LoginResponce.Pass(this.CurrentUser);
6845      }
6846      catch (ApiException ex)
6847      {
6848        if (ex.ErrorCode == HttpStatusCode.Unauthorized)
6849          return LoginResponce.WrongInput;
6850      }
6851      finally
6852      {
6853        checkPoint.Close();
6854      }
6855      return LoginResponce.NoResponce;
6856    }
6857
6858    public PingResponse PingSession(string activeModuleSecureKey)
6859    {
6860      try
6861      {
6862        Logger.WriteInfo((object) this, "PingSession()", "???????? Ping");
6863        bool flag;
6864        try
6865        {
6866          return this._api.Ping(activeModuleSecureKey);
6867        }
6868        catch (ApiException ex)
6869        {
6870          if (ex.ErrorCode == HttpStatusCode.NotFound || ex.ErrorCode == HttpStatusCode.Unauthorized)
6871          {
6872            if (string.Equals(ex.StatusDescription, "Secret key not found"))
6873              throw;
6874            else
6875              flag = true;
6876          }
6877          else
6878            throw;
6879        }
6880        if (flag)
6881        {
6882          Logger.WriteInfo((object) this, "PingSession()", "????????? ??????? ????????? ????????????(api.GetUser())");
6883          if (this._api.GetUser().User.Id != this.CurrentUser.Id)
6884          {
6885            Logger.WriteError((object) this, "PingSession()", "?????? ?????? ????? ??????? ????????????.");
6886            SessionMonitor.Instance.SetSessionStateToSuspended();
6887            int num = (int) MessageBox.Show(Resources.Error_ServerReturnIncorrectData, "Error", MessageBoxButton.OK, MessageBoxImage.Hand);
6888            throw new ApiException("?????? ?????? ????? ??????? ????????????.", HttpStatusCode.InternalServerError, "");
6889          }
6890          return this._api.Ping(activeModuleSecureKey);
6891        }
6892      }
6893      catch (ApiException ex)
6894      {
6895        if (string.Equals(ex.StatusDescription, "Secret key not found"))
6896          throw;
6897        else
6898          Logger.WriteError((object) this, "PingSession()", "Error during operation Ping", (Exception) ex);
6899      }
6900      catch (Exception ex)
6901      {
6902        Logger.WriteError((object) this, "PingSession()", "Error during operation Ping", ex);
6903      }
6904      return (PingResponse) null;
6905    }
6906
6907    public void CloseSession()
6908    {
6909      if (this._api != null)
6910        this._api.Close();
6911      this._api = (IAuthApi) null;
6912      this._currentUser = (Man) null;
6913    }
6914
6915    public Statistic[] GetStatistics()
6916    {
6917      Logger.WriteInfo((object) this, "GetStatistics()", "Get Statistics from server");
6918      try
6919      {
6920        return this._api.GetStatistics().Statistics;
6921      }
6922      catch (ApiException ex)
6923      {
6924        return new Statistic[0];
6925      }
6926      catch (EndpointNotFoundException ex)
6927      {
6928        return (Statistic[]) null;
6929      }
6930      catch (Exception ex)
6931      {
6932        Logger.WriteError((object) this, "GetStatistics()", "?????? ??? ????????? ??????????: " + ex.Message, ex);
6933        return (Statistic[]) null;
6934      }
6935    }
6936
6937    public Statistic[] GetStatistics(DateTime periodStart, DateTime periodEnd)
6938    {
6939      Logger.WriteInfo((object) this, "GetStatistics(periodStart, periodEnd)", "Get Statistics from server for period");
6940      try
6941      {
6942        StatisticsResponse statistics = this._api.GetStatistics(periodStart, periodEnd);
6943        return statistics == null ? new Statistic[0] : statistics.Statistics;
6944      }
6945      catch (ApiException ex)
6946      {
6947        return new Statistic[0];
6948      }
6949    }
6950
6951    public Purchase[] GetPurchases()
6952    {
6953      PurchaseResponse purchases;
6954      try
6955      {
6956        purchases = this._api.GetPurchases();
6957      }
6958      catch (ApiException ex)
6959      {
6960        return (Purchase[]) null;
6961      }
6962      catch (EndpointNotFoundException ex)
6963      {
6964        return (Purchase[]) null;
6965      }
6966      catch (Exception ex)
6967      {
6968        Logger.WriteError((object) this, "GetStatistics()", "?????? ??? ????????? ???????: " + ex.Message, ex);
6969        return (Purchase[]) null;
6970      }
6971      return purchases.Purchases;
6972    }
6973
6974    public string Activation(long purchaseId)
6975    {
6976      try
6977      {
6978        return this._api.Activation(new ActivationRequest()
6979        {
6980          PurchaseId = purchaseId
6981        }).PackageSecureKey;
6982      }
6983      catch (Exception ex)
6984      {
6985        Logger.WriteError((object) this, "Activation()", "Error by activation", ex);
6986        throw;
6987      }
6988    }
6989
6990    public string GetAppVersion()
6991    {
6992      try
6993      {
6994        return this._api.GetAppVersion().Version;
6995      }
6996      catch (ApiException ex)
6997      {
6998        Logger.WriteError((object) this, "GetAppVersion()", "Error: ", (Exception) ex);
6999        return string.Empty;
7000      }
7001    }
7002
7003    public ModuleInfo GetModuleInfo(long productId)
7004    {
7005      ModuleInfo moduleInfo1 = new ModuleInfo();
7006      try
7007      {
7008        ModuleInfoResponse moduleInfo2 = this._api.GetModuleInfo(productId);
7009        moduleInfo1.Id = moduleInfo2.Id;
7010        moduleInfo1.ProductId = moduleInfo2.ProductId;
7011        moduleInfo1.Title = moduleInfo2.Title;
7012        moduleInfo1.Version = moduleInfo2.Version;
7013        moduleInfo1.Description = moduleInfo2.Description;
7014        moduleInfo1.Filename = moduleInfo2.Filename;
7015        moduleInfo1.Url = moduleInfo2.Url;
7016      }
7017      catch (ApiException ex)
7018      {
7019        Logger.WriteError((object) this, "GetModuleInfo(productId)", "Error: ", (Exception) ex);
7020        return (ModuleInfo) null;
7021      }
7022      return moduleInfo1;
7023    }
7024
7025    public byte[] GetModuleContent(long productId)
7026    {
7027      CheckPoint checkPoint = Logger.CheckPointStart("GetModuleContent");
7028      try
7029      {
7030        ModuleContentResponse moduleContent = this._api.GetModuleContent(productId);
7031        if (moduleContent != null && !string.IsNullOrEmpty(moduleContent.Source))
7032          return Convert.FromBase64String(moduleContent.Source);
7033        Logger.WriteWarning((object) this, "GetModuleContent()", "the module contents is not received");
7034        return (byte[]) null;
7035      }
7036      catch (Exception ex)
7037      {
7038        Logger.WriteError((object) this, "GetModuleContent(productId)", "Error: ", ex);
7039        return (byte[]) null;
7040      }
7041      finally
7042      {
7043        checkPoint.Close();
7044      }
7045    }
7046
7047    public void UpdateUserAgentString()
7048    {
7049      ConfigurationManager.UpdateUserAgent();
7050      string userAgent = ConfigurationManager.GetUserAgent();
7051      ApiAccess apiAccess = this._api as ApiAccess;
7052      if (apiAccess == null)
7053        return;
7054      string login = string.Empty;
7055      string password = string.Empty;
7056      if (apiAccess.ClientCredentials != null)
7057      {
7058        login = apiAccess.ClientCredentials.UserName.UserName;
7059        password = apiAccess.ClientCredentials.UserName.Password;
7060      }
7061      this._api = Map.Get<IClientFactory>().CreateChannel(login, password, ApplicationSettings.ServiceUri, userAgent);
7062    }
7063  }
7064}
7065?// Decompiled with JetBrains decompiler
7066// Type: WinApp.Managers.ApplicationSettings
7067// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7068// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7069// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7070
7071using Inc.Logging;
7072using IncMap;
7073using Microsoft.Win32;
7074using System;
7075using System.Collections.Generic;
7076using System.Configuration;
7077using System.Globalization;
7078using System.IO;
7079using System.Linq;
7080using System.Reflection;
7081using System.Threading;
7082using System.Xml.Serialization;
7083using WinApp.Data.Security;
7084using WinApp.Managers.Interfaces;
7085using WinApp.Managers.Localization;
7086
7087namespace WinApp.Managers
7088{
7089  public class ApplicationSettings : IApplicationSettings
7090  {
7091    private static readonly string _configFileName = "\\ApplicationSettings.cfg";
7092    private static readonly string _configPath = Environment.CurrentDirectory;
7093    private static object _lockObject = new object();
7094    private static string _serviceUri;
7095
7096    public static string ServiceUri
7097    {
7098      get
7099      {
7100        if (string.IsNullOrEmpty(ApplicationSettings._serviceUri))
7101        {
7102          string str = ConfigurationManager.AppSettings["ServiceUri"];
7103          if (string.IsNullOrEmpty(str))
7104          {
7105            Logger.WriteError((object) typeof (ApplicationSettings), "ServiceUri", "ServiceUri not specified in settings app.config");
7106            str = "https://cabinet.kairosplanet.com";
7107          }
7108          ApplicationSettings._serviceUri = str;
7109        }
7110        return ApplicationSettings._serviceUri;
7111      }
7112    }
7113
7114    public bool IsHttpUsed { get; set; }
7115
7116    public string LocalizationKey { get; set; }
7117
7118    [XmlIgnore]
7119    public string Email
7120    {
7121      get
7122      {
7123        return Cryptography.UnprotectUserData(this.ProtectedEmail);
7124      }
7125      set
7126      {
7127        this.ProtectedEmail = Cryptography.ProtectedUserData(value);
7128      }
7129    }
7130
7131    [XmlIgnore]
7132    public string Password
7133    {
7134      get
7135      {
7136        return Cryptography.UnprotectUserData(this.ProtectedPassword);
7137      }
7138      set
7139      {
7140        this.ProtectedPassword = Cryptography.ProtectedUserData(value);
7141      }
7142    }
7143
7144    public string ProtectedEmail { get; set; }
7145
7146    public string ProtectedPassword { get; set; }
7147
7148    public bool IsAutoLogin { get; set; }
7149
7150    public long ActiveProductId { get; set; }
7151
7152    public bool UseHttpPing { get; set; }
7153
7154    [XmlIgnore]
7155    public bool RunAtStartup
7156    {
7157      get
7158      {
7159        return this.GetRunAtStartup();
7160      }
7161      set
7162      {
7163        this.SetRunAtStartup(value);
7164      }
7165    }
7166
7167    public bool IsRemeberMe { get; set; }
7168
7169    private static string ConfigFileFullName
7170    {
7171      get
7172      {
7173        return ApplicationSettings._configPath + ApplicationSettings._configFileName;
7174      }
7175    }
7176
7177    public ApplicationSettings()
7178    {
7179      Logger.WriteInfo(typeof (ApplicationSettings), "ApplicationSettings()", "????????????? ????? ????????...");
7180      this.LocalizationKey = CultureInfo.CurrentUICulture.Name;
7181      Logger.WriteInfo(typeof (ApplicationSettings), "ApplicationSettings()", "????? ????????? ????????????????");
7182    }
7183
7184    public static ApplicationSettings GetClientSettings()
7185    {
7186      return ApplicationSettings.ReadConfigSettingFromFile(true);
7187    }
7188
7189    public void SetLocalization(LocalizationObject localizationObject)
7190    {
7191      this.LocalizationKey = localizationObject.LocalizationKey;
7192      Logger.WriteInfo(typeof (ApplicationSettings), "SetLocalization()", string.Format("??????????? ???????? ?? {0}", (object) this.LocalizationKey));
7193      this.Save();
7194    }
7195
7196    public void SetRunAtStartup(bool isRunAtStartup)
7197    {
7198      Logger.WriteInfo(typeof (ApplicationSettings), "SetRunAtStartup()", "????? ???????? ??????? ??? ??????...");
7199      RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
7200      if (registryKey == null)
7201      {
7202        Logger.WriteWarning(typeof (ApplicationSettings), "SetRunAtStartup()", "??????????? ???? null");
7203      }
7204      else
7205      {
7206        Assembly executingAssembly = Assembly.GetExecutingAssembly();
7207        try
7208        {
7209          if (isRunAtStartup)
7210          {
7211            registryKey.SetValue(executingAssembly.GetName().Name, (object) executingAssembly.Location);
7212            Logger.WriteInfo(typeof (ApplicationSettings), "SetRunAtStartup()", "?????? ?????????? ??? ?????? ???????");
7213          }
7214          else
7215          {
7216            registryKey.DeleteValue(executingAssembly.GetName().Name, false);
7217            Logger.WriteInfo(typeof (ApplicationSettings), "SetRunAtStartup()", "?????? ?????????? ??? ?????? ????????");
7218          }
7219        }
7220        catch (Exception ex)
7221        {
7222          Logger.WriteError(typeof (ApplicationSettings), "SetRunAtStartup()", "?????? ??? ????? ????????? ??????? ?????????? ??? ??????", ex);
7223        }
7224      }
7225    }
7226
7227    public bool GetRunAtStartup()
7228    {
7229      Logger.WriteInfo(typeof (ApplicationSettings), "GetRunAtStartup()", "????????? ???????? ??????? ??? ??????...");
7230      RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", false);
7231      if (registryKey == null)
7232      {
7233        Logger.WriteWarning(typeof (ApplicationSettings), "GetRunAtStartup()", "??????????? ???? null");
7234        return false;
7235      }
7236      Assembly executingAssembly = Assembly.GetExecutingAssembly();
7237      try
7238      {
7239        return registryKey.GetValue(executingAssembly.GetName().Name) != null;
7240      }
7241      catch (Exception ex)
7242      {
7243        Logger.WriteError(typeof (ApplicationSettings), "GetRunAtStartup()", "?????? ??? ????????? ????????? ??????? ?????????? ??? ??????", ex);
7244        return false;
7245      }
7246    }
7247
7248    public void SetIsAutoLogin(bool isAutoLogin)
7249    {
7250      this.IsAutoLogin = isAutoLogin;
7251      Logger.WriteInfo(typeof (ApplicationSettings), "SetIsAutoLogin()", string.Format("???????? ?????????? ???????? ?? {0}", (object) (bool) (isAutoLogin ? 1 : 0)));
7252      this.Save();
7253    }
7254
7255    public void SetHttpPingUsed(bool isHttpPingUsed)
7256    {
7257      this.IsHttpUsed = isHttpPingUsed;
7258      Logger.WriteInfo(typeof (ApplicationSettings), "SetHttpPingUsed()", string.Format("???????? ????????????? http ping'a ?? {0}", (object) (bool) (isHttpPingUsed ? 1 : 0)));
7259      this.Save();
7260    }
7261
7262    public LocalizationObject GetLocalizationObject()
7263    {
7264      return Enumerable.SingleOrDefault<LocalizationObject>((IEnumerable<LocalizationObject>) Map.Get<ILocalizationManager>().LanguagesCollection, (Func<LocalizationObject, bool>) (lco => lco.LocalizationKey.Contains(this.LocalizationKey))) ?? Map.Get<ILocalizationManager>().LanguagesCollection[0];
7265    }
7266
7267    public void RemeberMe(string email, string password)
7268    {
7269      this.Email = email;
7270      this.Password = password;
7271      this.IsRemeberMe = true;
7272      Logger.WriteInfo(typeof (ApplicationSettings), "RememberMe()", "????????? ?????? ??? ?????");
7273      this.Save();
7274    }
7275
7276    public void ForgetMe()
7277    {
7278      this.IsAutoLogin = false;
7279      this.IsRemeberMe = false;
7280      this.Password = string.Empty;
7281      Logger.WriteInfo(typeof (ApplicationSettings), "ForgetMe()", "???????? ?????????, ?????? ??????");
7282      this.Save();
7283    }
7284
7285    public void Save()
7286    {
7287      Logger.WriteInfo(typeof (ApplicationSettings), "SaveCredential()", "?????????? ????? ????????...");
7288      string configFileFullName = ApplicationSettings.ConfigFileFullName;
7289      try
7290      {
7291        lock (ApplicationSettings._lockObject)
7292        {
7293          using (FileStream resource_0 = new FileStream(configFileFullName, FileMode.Create))
7294          {
7295            new XmlSerializer(typeof (ApplicationSettings)).Serialize((Stream) resource_0, (object) this);
7296            Logger.WriteInfo(typeof (ApplicationSettings), "SaveCredential()", "????????? ??????? ?????????");
7297          }
7298        }
7299      }
7300      catch (Exception ex)
7301      {
7302        Logger.WriteError(typeof (ApplicationSettings), "SaveCredential()", "?????? ??? ?????????? ????? ???????? ??????????", ex);
7303      }
7304    }
7305
7306    private static ApplicationSettings CreateNewSettings()
7307    {
7308      Logger.WriteInfo(typeof (ApplicationSettings), "CreateNewSettings()", "???????? ?????? ????? ????????...");
7309      ApplicationSettings applicationSettings = new ApplicationSettings();
7310      applicationSettings.Save();
7311      Logger.WriteInfo(typeof (ApplicationSettings), "CreateNewSettings()", "????? ???? ???????? ??????");
7312      return applicationSettings;
7313    }
7314
7315    private static ApplicationSettings ReadConfigSettingFromFile(bool isEnableTryRead)
7316    {
7317      try
7318      {
7319        string configFileFullName = ApplicationSettings.ConfigFileFullName;
7320        if (!File.Exists(configFileFullName))
7321          return ApplicationSettings.CreateNewSettings();
7322        lock (ApplicationSettings._lockObject)
7323        {
7324          using (FileStream resource_0 = File.OpenRead(configFileFullName))
7325          {
7326            Logger.WriteError((object) typeof (ApplicationSettings), "ReadConfigSettingFromFile()", "file opened. Start XmlSerializer.");
7327            return (ApplicationSettings) new XmlSerializer(typeof (ApplicationSettings)).Deserialize((Stream) resource_0);
7328          }
7329        }
7330      }
7331      catch (Exception ex)
7332      {
7333        Logger.WriteError(typeof (ApplicationSettings), "ReadConfigSettingFromFile()", "?????? ??? ????????? ???????? , ??????: " + ex.Message, ex);
7334        if (!isEnableTryRead)
7335          throw new FileLoadException("?????? ??? ????????? ????????");
7336        Thread.Sleep(1000);
7337        return ApplicationSettings.ReadConfigSettingFromFile(false);
7338      }
7339    }
7340  }
7341}
7342?// Decompiled with JetBrains decompiler
7343// Type: WinApp.Managers.ScreenManager
7344// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7345// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7346// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7347
7348using Inc.Logging;
7349using IncMap;
7350using System;
7351using System.Collections.Generic;
7352using System.Drawing;
7353using System.Threading;
7354using System.Windows;
7355using System.Windows.Controls;
7356using System.Windows.Forms;
7357using System.Windows.Interop;
7358using Telerik.Windows.Controls;
7359using WinApp.Data.Model;
7360using WinApp.Managers.Interfaces;
7361using WinApp.Module;
7362using WinApp.Service.Repository.Interface;
7363using WinApp.View;
7364using WinApp.View.Base;
7365using WinApp.ViewModel;
7366using WinApp.ViewModel.Services;
7367
7368namespace WinApp.Managers
7369{
7370  internal class ScreenManager : IScreenManager
7371  {
7372    private readonly Stack<System.Windows.Controls.UserControl> _controlsHistory = new Stack<System.Windows.Controls.UserControl>();
7373    private Thread _statusEndThread;
7374
7375    public MainViewUC MainView { get; private set; }
7376
7377    public void DoVisualSafe(Action action)
7378    {
7379      System.Windows.Application.Current.Dispatcher.BeginInvoke((Delegate) action);
7380    }
7381
7382    public void SwitchBack()
7383    {
7384      Logger.WriteInfo(typeof (ScreenManager), "SwitchBack()", "??????????? ??????? ?? ?????????? ????????...");
7385      if (!this.CanSwitchBack())
7386      {
7387        Logger.WriteWarning(typeof (ScreenManager), "SwitchBack()", "??? ??????????? ????????? ?? ?????????? ????????");
7388      }
7389      else
7390      {
7391        this._controlsHistory.Pop();
7392        MainWindowVM viewModel = Map.Get<IMainWindow>().ViewModel;
7393        if (viewModel == null)
7394        {
7395          Logger.WriteWarning(typeof (ScreenManager), "SwitchBack()", "???????? ?????? ???? ???????????");
7396        }
7397        else
7398        {
7399          viewModel.Content = this._controlsHistory.Peek();
7400          Logger.WriteInfo(typeof (ScreenManager), "SwitchBack()", "??????? ?? ?????????? ???????? ???????? ???????");
7401        }
7402      }
7403    }
7404
7405    public bool CanSwitchBack()
7406    {
7407      return this._controlsHistory.Count > 1;
7408    }
7409
7410    public void SwitchToLogin()
7411    {
7412      try
7413      {
7414        Logger.WriteInfo(typeof (ScreenManager), "SwitchToLogin()", "?????????? ???????? ?? ???????? ??????...");
7415        this.MainView = (MainViewUC) null;
7416        this._controlsHistory.Clear();
7417        this.SwitchTo((System.Windows.Controls.UserControl) new LoginUC(), false);
7418        Logger.WriteInfo(typeof (ScreenManager), "SwitchToLogin()", "??????? ?? ???????? ?????? ??????? ????????");
7419      }
7420      catch (Exception ex)
7421      {
7422        Logger.WriteError((object) this, "SwitchToLogin()", "?????? ??? ???????? ?? ????? ??????: " + ex.Message);
7423      }
7424    }
7425
7426    public void SwitchToNewVersionAvailableWindow(Version appVersionOnSite, Version appVersionCurrent)
7427    {
7428      Logger.WriteInfo(typeof (ScreenManager), "SwitchToNewVersionAvailableWindow()", "?????????? ???????? ?? ???? ??????????? ??????????? ????? ??????");
7429      this.MainView = (MainViewUC) null;
7430      this._controlsHistory.Clear();
7431      this.SwitchTo((System.Windows.Controls.UserControl) new VersionUC(appVersionOnSite, appVersionCurrent), false);
7432      Logger.WriteInfo(typeof (ScreenManager), "SwitchToNewVersionAvailableWindow()", "??????? ?? ???? ??????????? ??????????? ????? ?????? ??????? ????????");
7433    }
7434
7435    public void SwitchToMain()
7436    {
7437      Logger.WriteInfo(typeof (ScreenManager), "SwitchToMain()", "?????????? ???????? ?? ??????? ????????...");
7438      this.MainView = new MainViewUC();
7439      this.SwitchTo((System.Windows.Controls.UserControl) this.MainView, true);
7440      Logger.WriteInfo(typeof (ScreenManager), "SwitchToMain()", "??????? ?? ??????? ???????? ??????? ????????");
7441    }
7442
7443    public void SwitchToInstall(InstallModuleUC installModuleUc, ServiceVM serviceVm, Action<bool> onInstalledAction)
7444    {
7445      Logger.WriteInfo((object) this, "SwitchToInstall", "Action to install started");
7446      System.Windows.Controls.Control oldControl = this.MainView.ViewModel.Content;
7447      this.MainView.ViewModel.Content = (System.Windows.Controls.Control) installModuleUc;
7448      installModuleUc.get_ViewModel().set_CloseAction((Action) (() =>
7449      {
7450        if (!installModuleUc.get_ViewModel().get_IsInstalled())
7451        {
7452          Logger.WriteInfo((object) this, "Install", "Action to install closed without installed");
7453        }
7454        else
7455        {
7456          Logger.WriteInfo((object) this, "Install", "Action to install closed with successful");
7457          this.MainView.ViewModel.Content = oldControl;
7458          Module moduleByProductId = Map.Get<IModuleRepository>().GetModuleByProductId(serviceVm.ProductId);
7459          moduleByProductId.StateEnum = ModuleState.Installed;
7460          Map.Get<IModuleRepository>().Save(moduleByProductId);
7461          serviceVm.RefreshButtonContent();
7462          onInstalledAction(installModuleUc.get_ViewModel().get_IsInstalled());
7463        }
7464      }));
7465    }
7466
7467    public void ShowAlert(string message, string title)
7468    {
7469      TextBlock textBlock1 = new TextBlock();
7470      textBlock1.Text = message;
7471      textBlock1.TextWrapping = TextWrapping.Wrap;
7472      textBlock1.Width = 400.0;
7473      TextBlock textBlock2 = textBlock1;
7474      DialogParameters dialogParameters = new DialogParameters();
7475      dialogParameters.set_Content((object) textBlock2);
7476      dialogParameters.set_Header((object) title);
7477      dialogParameters.set_DialogStartupLocation(WindowStartupLocation.CenterOwner);
7478      dialogParameters.set_OkButtonContent((object) "OK");
7479      RadWindow.Alert(dialogParameters);
7480    }
7481
7482    public Action ShowStatusMessage(string message, int timeInSeconds, bool isInProgress)
7483    {
7484      if (this.MainView == null)
7485        return (Action) (() => {});
7486      this.MainView.ViewModel.StatusMessage = message;
7487      if (this._statusEndThread != null && this._statusEndThread.IsAlive)
7488        this._statusEndThread.Abort();
7489      if (isInProgress)
7490      {
7491        this.DoVisualSafe((Action) (() => this.MainView.ViewModel.IsStatusInProgress = Visibility.Visible));
7492        return (Action) (() => this.DoVisualSafe((Action) (() =>
7493        {
7494          this.MainView.ViewModel.IsStatusInProgress = Visibility.Collapsed;
7495          this.MainView.ViewModel.StatusMessage = string.Empty;
7496        })));
7497      }
7498      this._statusEndThread = new Thread((ThreadStart) (() =>
7499      {
7500        Thread.Sleep(1000 * timeInSeconds);
7501        if (this.MainView == null)
7502          return;
7503        this.DoVisualSafe((Action) (() => this.MainView.ViewModel.StatusMessage = string.Empty));
7504      }));
7505      this._statusEndThread.Start();
7506      this.DoVisualSafe((Action) (() => this.MainView.ViewModel.IsStatusInProgress = Visibility.Collapsed));
7507      return (Action) (() => {});
7508    }
7509
7510    private void SwitchTo(System.Windows.Controls.UserControl control, bool pushToHistory = true)
7511    {
7512      CheckPoint checkPoint = Logger.CheckPointStart("SwithTo " + control.Name);
7513      try
7514      {
7515        MainWindowVM viewModel = Map.Get<IMainWindow>().ViewModel;
7516        if (viewModel == null)
7517          return;
7518        IWindowArrangeView windowArrangeView = control as IWindowArrangeView;
7519        if (windowArrangeView != null)
7520        {
7521          WindowCommon windowCommon = Map.Get<IMainWindow>() as WindowCommon;
7522          if (windowCommon != null)
7523          {
7524            ((UIElement) windowCommon).Visibility = Visibility.Hidden;
7525            ((UIElement) windowCommon).UpdateLayout();
7526            ((FrameworkElement) windowCommon).Width = windowArrangeView.WindowWidth;
7527            ((FrameworkElement) windowCommon).Height = windowArrangeView.WindowHeight;
7528            ((WindowBase) windowCommon).set_ResizeMode(windowArrangeView.ResizeMode);
7529            ((UIElement) windowCommon).UpdateLayout();
7530            Screen screen = Screen.FromHandle(new WindowInteropHelper(windowCommon.ParentWindow).Handle);
7531            Graphics graphics = Graphics.FromHwnd(IntPtr.Zero);
7532            double num1 = 96.0 / (double) graphics.DpiX;
7533            double num2 = 96.0 / (double) graphics.DpiY;
7534            ((WindowBase) windowCommon).set_Left(Math.Round(((double) screen.Bounds.X + ((double) screen.WorkingArea.Width - ((FrameworkElement) windowCommon).ActualWidth / num1) / 2.0) * num1));
7535            ((WindowBase) windowCommon).set_Top(Math.Round(((double) screen.Bounds.Y + ((double) screen.WorkingArea.Height - ((FrameworkElement) windowCommon).ActualHeight / num2) / 2.0) * num2));
7536            ((UIElement) windowCommon).Visibility = Visibility.Visible;
7537          }
7538        }
7539        viewModel.Content = control;
7540        if (!pushToHistory)
7541          return;
7542        this._controlsHistory.Push(control);
7543      }
7544      finally
7545      {
7546        checkPoint.Close();
7547      }
7548    }
7549  }
7550}
7551?// Decompiled with JetBrains decompiler
7552// Type: WinApp.Bootstrapper
7553// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7554// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7555// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7556
7557using Inc.Logging;
7558using IncMap;
7559using KairosPlanet.Managers.Data;
7560using KairosPlanet.Managers.Interfaces;
7561using System;
7562using WinApp.Api;
7563using WinApp.Managers;
7564using WinApp.Managers.Interfaces;
7565using WinApp.Managers.Localization;
7566using WinApp.Service;
7567using WinApp.View;
7568
7569namespace WinApp
7570{
7571  internal class Bootstrapper
7572  {
7573    public static void Bootstrap()
7574    {
7575      Logger.WriteInfo(typeof (Bootstrapper), "Bootstrap()", "????????????? ??????????? Bootstrapper...");
7576      Map.Inject<IApplicationSettings>((IApplicationSettings) ApplicationSettings.GetClientSettings());
7577      Map.Inject<IScreenManager>((IScreenManager) new ScreenManager());
7578      Map.InjectLazy<IAppTray>((Func<object>) (() => (object) new AppTray()));
7579      Map.InjectLazy<IMainWindow>((Func<object>) (() => (object) new MainWindow()));
7580      Map.Inject<ILocalizationManager>((ILocalizationManager) new LocalizationManager());
7581      Map.Inject<ICountriesManager>((ICountriesManager) new CountriesManager());
7582      Map.Inject<IModuleResolver>((IModuleResolver) new ModuleResolver());
7583      Map.Inject<ISessionManager>((ISessionManager) new SessionManager());
7584      Map.Inject<IPurchaseManager>((IPurchaseManager) new PurchaseManager());
7585      Logger.WriteInfo(typeof (Bootstrapper), "Bootstrap()", "?????????? Bootstrapper ??????? ???????????????");
7586      ServiceBootstrapper.Bootstrap();
7587      ApiBootstrapper.Bootstrap();
7588    }
7589  }
7590}
7591?// Decompiled with JetBrains decompiler
7592// Type: WinApp.ViewModel.Tray.TrayStateVM
7593// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7594// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7595// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7596
7597using KairosPlanet.Properties;
7598using WinApp.ViewModel.Base;
7599
7600namespace WinApp.ViewModel.Tray
7601{
7602  public class TrayStateVM : ViewModelBase
7603  {
7604    public static TrayStateVM None = new TrayStateVM(Resources.NetworkState_None, "/Assets/Images/None.ico");
7605    public static TrayStateVM Offline = new TrayStateVM(Resources.NetworkState_Offline, "/Assets/Images/Offline.ico");
7606    public static TrayStateVM Online = new TrayStateVM(Resources.NetworkState_Online, "/Assets/Images/Online.ico");
7607
7608    public string ToolTipText { get; private set; }
7609
7610    public string IconPath { get; private set; }
7611
7612    private TrayStateVM(string toolTipText, string iconPath)
7613    {
7614      this.ToolTipText = toolTipText;
7615      this.IconPath = iconPath;
7616    }
7617  }
7618}
7619?// Decompiled with JetBrains decompiler
7620// Type: WinApp.ViewModel.Tray.AppTrayVM
7621// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7622// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7623// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7624
7625using IncMap;
7626using System;
7627using System.Linq.Expressions;
7628using System.Windows.Controls;
7629using System.Windows.Input;
7630using WinApp;
7631using WinApp.Managers.Interfaces;
7632using WinApp.View;
7633using WinApp.ViewModel;
7634using WinApp.ViewModel.Base;
7635using WinApp.ViewModel.MainMenu;
7636
7637namespace WinApp.ViewModel.Tray
7638{
7639  public class AppTrayVM : ViewModelBase
7640  {
7641    public TrayStateVM TrayState
7642    {
7643      get
7644      {
7645        switch (AppVM.Instance.NetworkState)
7646        {
7647          case NetworkState.None:
7648            return TrayStateVM.None;
7649          case NetworkState.NetworkNotFound:
7650          case NetworkState.ServerNotFound:
7651            return TrayStateVM.Offline;
7652          case NetworkState.ServerOnline:
7653            return TrayStateVM.Online;
7654          default:
7655            return (TrayStateVM) null;
7656        }
7657      }
7658    }
7659
7660    public ICommand ShowWindowCommand
7661    {
7662      get
7663      {
7664        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.ShowWindowCommand), new Action(Map.Get<IMainWindow>().Open));
7665      }
7666    }
7667
7668    public ICommand ServicesCommand
7669    {
7670      get
7671      {
7672        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.ServicesCommand), (Action) (() => this.SwitchToMenuItem((Func<MainMenuCollection, MainMenuItem>) (x => (MainMenuItem) x.Services))));
7673      }
7674    }
7675
7676    public ICommand StatisticsCommand
7677    {
7678      get
7679      {
7680        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.StatisticsCommand), (Action) (() => this.SwitchToMenuItem((Func<MainMenuCollection, MainMenuItem>) (x => (MainMenuItem) x.Statistics))));
7681      }
7682    }
7683
7684    public ICommand ProfileCommand
7685    {
7686      get
7687      {
7688        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.ProfileCommand), (Action) (() => this.SwitchToMenuItem((Func<MainMenuCollection, MainMenuItem>) (x => (MainMenuItem) x.Profile))));
7689      }
7690    }
7691
7692    public ICommand SettingsCommand
7693    {
7694      get
7695      {
7696        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.SettingsCommand), (Action) (() => this.SwitchToMenuItem((Func<MainMenuCollection, MainMenuItem>) (x => (MainMenuItem) x.Settings))));
7697      }
7698    }
7699
7700    public ICommand LogInCommand
7701    {
7702      get
7703      {
7704        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.LogInCommand), new Action(Map.Get<IMainWindow>().Open));
7705      }
7706    }
7707
7708    public ICommand LogOutCommand
7709    {
7710      get
7711      {
7712        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.LogOutCommand), new Action(this.LogOutAction));
7713      }
7714    }
7715
7716    public ICommand ExitCommand
7717    {
7718      get
7719      {
7720        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.ExitCommand), new Action(Map.Get<IMainWindow>().ViewModel.Exit));
7721      }
7722    }
7723
7724    public ContextMenu ContextMenu
7725    {
7726      get
7727      {
7728        switch (AppVM.Instance.LoginState)
7729        {
7730          case LoginState.NoLogin:
7731            return this.NoLoginContextMenu;
7732          case LoginState.Done:
7733            return this.FullContextMenu;
7734          default:
7735            return (ContextMenu) null;
7736        }
7737      }
7738    }
7739
7740    public ContextMenu NoLoginContextMenu { get; set; }
7741
7742    public ContextMenu FullContextMenu { get; set; }
7743
7744    public void Refresh()
7745    {
7746      this.OnPropertyChanged("TrayState");
7747      this.OnPropertyChanged("ContextMenu");
7748    }
7749
7750    private void SwitchToMenuItem(Func<MainMenuCollection, MainMenuItem> selector)
7751    {
7752      MainViewUC mainView = Map.Get<IScreenManager>().MainView;
7753      mainView.ViewModel.SwithToMenuItem(selector(mainView.ViewModel.MenuItems));
7754      Map.Get<IMainWindow>().Open();
7755    }
7756
7757    private void LogOutAction()
7758    {
7759      Map.Get<IApplicationSettings>().ForgetMe();
7760      AppVM.Instance.ProcedeLogOut();
7761      Map.Get<IMainWindow>().Open();
7762    }
7763  }
7764}
7765?// Decompiled with JetBrains decompiler
7766// Type: WinApp.ViewModel.Base.EntityVM`1
7767// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7768// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7769// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7770
7771using System.Collections.Generic;
7772using WinApp.Data.Model;
7773
7774namespace WinApp.ViewModel.Base
7775{
7776  public abstract class EntityVM<T> : ViewModelBase where T : Entity, new()
7777  {
7778    private T _model;
7779
7780    public long Id
7781    {
7782      get
7783      {
7784        return this.Model.Id;
7785      }
7786    }
7787
7788    public T Model
7789    {
7790      get
7791      {
7792        return this._model;
7793      }
7794      set
7795      {
7796        this._model = value;
7797        this.OnPropertyChanged("Model");
7798        foreach (string propertyName in this.GetFieldNames())
7799          this.OnPropertyChanged(propertyName);
7800      }
7801    }
7802
7803    protected EntityVM(T model)
7804    {
7805      this.Model = model;
7806    }
7807
7808    protected abstract IEnumerable<string> GetFieldNames();
7809  }
7810}
7811?// Decompiled with JetBrains decompiler
7812// Type: WinApp.ViewModel.Base.SymbolHelpers
7813// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7814// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7815// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7816
7817using System;
7818using System.Linq.Expressions;
7819
7820namespace WinApp.ViewModel.Base
7821{
7822  public static class SymbolHelpers
7823  {
7824    public static string GetPropertyName<T>(Expression<Func<T>> propertyExpression)
7825    {
7826      if (propertyExpression == null || propertyExpression.Body == null)
7827        return string.Empty;
7828      return (propertyExpression.Body as MemberExpression).Member.Name;
7829    }
7830  }
7831}
7832?// Decompiled with JetBrains decompiler
7833// Type: WinApp.ViewModel.Base.CommandHolder
7834// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7835// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7836// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7837
7838using System;
7839using System.Collections.Generic;
7840using System.Linq.Expressions;
7841using System.Windows.Input;
7842
7843namespace WinApp.ViewModel.Base
7844{
7845  public class CommandHolder
7846  {
7847    private readonly Dictionary<string, ICommand> _commands = new Dictionary<string, ICommand>();
7848
7849    public ICommand GetOrCreateCommand<T>(Expression<Func<T>> commandNameExpression, Action executeCommandAction)
7850    {
7851      return this.GetOrCreateCommand<T>(commandNameExpression, executeCommandAction, (Func<bool>) (() => true));
7852    }
7853
7854    public ICommand GetOrCreateCommand<T>(Expression<Func<T>> commandNameExpression, Action<object> executeCommandAction)
7855    {
7856      string propertyName = SymbolHelpers.GetPropertyName<T>(commandNameExpression);
7857      if (!this._commands.ContainsKey(propertyName))
7858      {
7859        RelayCommand relayCommand = new RelayCommand(executeCommandAction);
7860        this._commands.Add(propertyName, (ICommand) relayCommand);
7861      }
7862      return this._commands[propertyName];
7863    }
7864
7865    public ICommand GetOrCreateCommand<T>(Expression<Func<T>> commandNameExpression, Action executeCommandAction, Func<bool> canExecutePredicate)
7866    {
7867      return this.GetOrCreateCommand<T>(commandNameExpression, (Action<object>) (parameter => executeCommandAction()), (Func<object, bool>) (parameter => canExecutePredicate()));
7868    }
7869
7870    public ICommand GetOrCreateCommand<T>(Expression<Func<T>> commandNameExpression, Action<object> executeCommandAction, Func<object, bool> canExecutePredicate)
7871    {
7872      string propertyName = SymbolHelpers.GetPropertyName<T>(commandNameExpression);
7873      if (!this._commands.ContainsKey(propertyName))
7874      {
7875        RelayCommand relayCommand = new RelayCommand(executeCommandAction, canExecutePredicate);
7876        this._commands.Add(propertyName, (ICommand) relayCommand);
7877      }
7878      return this._commands[propertyName];
7879    }
7880  }
7881}
7882?// Decompiled with JetBrains decompiler
7883// Type: WinApp.ViewModel.Base.ViewModelBase
7884// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7885// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7886// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7887
7888using System;
7889using System.ComponentModel;
7890
7891namespace WinApp.ViewModel.Base
7892{
7893  public class ViewModelBase : INotifyPropertyChanged, IDataErrorInfo
7894  {
7895    private CommandHolder _commands;
7896
7897    public CommandHolder Commands
7898    {
7899      get
7900      {
7901        return this._commands ?? (this._commands = new CommandHolder());
7902      }
7903    }
7904
7905    public virtual string Error
7906    {
7907      get
7908      {
7909        return string.Empty;
7910      }
7911    }
7912
7913    public virtual string this[string columnName]
7914    {
7915      get
7916      {
7917        return string.Empty;
7918      }
7919    }
7920
7921    public event PropertyChangedEventHandler PropertyChanged;
7922
7923    protected void OnPropertyChanged(string propertyName)
7924    {
7925      if (this.PropertyChanged == null)
7926        return;
7927      try
7928      {
7929        this.PropertyChanged((object) this, new PropertyChangedEventArgs(propertyName));
7930      }
7931      catch (Exception ex)
7932      {
7933      }
7934    }
7935  }
7936}
7937?// Decompiled with JetBrains decompiler
7938// Type: WinApp.ViewModel.Base.RelayCommand
7939// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
7940// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
7941// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
7942
7943using System;
7944using System.Windows;
7945using System.Windows.Input;
7946using System.Windows.Threading;
7947
7948namespace WinApp.ViewModel.Base
7949{
7950  public class RelayCommand : ICommand
7951  {
7952    private readonly Action<object> _execute;
7953    private readonly Func<object, bool> _canExecute;
7954    private EventHandler _internalCanExecuteChanged;
7955
7956    public event EventHandler CanExecuteChanged
7957    {
7958      add
7959      {
7960        this._internalCanExecuteChanged += value;
7961        CommandManager.RequerySuggested += value;
7962      }
7963      remove
7964      {
7965        this._internalCanExecuteChanged += value;
7966        CommandManager.RequerySuggested -= value;
7967      }
7968    }
7969
7970    public RelayCommand(Action<object> execute)
7971      : this(execute, (Func<object, bool>) null)
7972    {
7973    }
7974
7975    public RelayCommand(Action<object> execute, Func<object, bool> canExecute)
7976    {
7977      if (execute == null)
7978        throw new ArgumentNullException("execute");
7979      this._execute = execute;
7980      this._canExecute = canExecute;
7981    }
7982
7983    public bool CanExecute(object parameter)
7984    {
7985      if (this._canExecute != null)
7986        return this._canExecute(parameter);
7987      return true;
7988    }
7989
7990    public void Execute(object parameter)
7991    {
7992      this._execute(parameter);
7993    }
7994
7995    public void RaiseCanExecuteChanged()
7996    {
7997      if (this._canExecute == null)
7998        return;
7999      Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, (Delegate) (() => this.OnCanExecuteChanged()));
8000    }
8001
8002    protected virtual void OnCanExecuteChanged()
8003    {
8004      EventHandler eventHandler = this._internalCanExecuteChanged;
8005      if (eventHandler == null)
8006        return;
8007      eventHandler((object) this, EventArgs.Empty);
8008    }
8009  }
8010}
8011?// Decompiled with JetBrains decompiler
8012// Type: WinApp.ViewModel.Services.ServiceVM
8013// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
8014// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
8015// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
8016
8017using Inc.Logging;
8018using IncMap;
8019using KairosPlanet;
8020using KairosPlanet.Managers.Interfaces;
8021using KairosPlanet.Properties;
8022using KairosPlanet.ViewModel.Services;
8023using System;
8024using System.Collections.Generic;
8025using System.Diagnostics;
8026using System.Globalization;
8027using System.IO;
8028using System.Threading;
8029using System.Windows;
8030using System.Windows.Documents;
8031using System.Windows.Input;
8032using System.Windows.Markup;
8033using System.Windows.Media;
8034using System.Windows.Media.Imaging;
8035using System.Windows.Threading;
8036using Telerik.Windows.Controls;
8037using WinApp.Data.Model;
8038using WinApp.Managers;
8039using WinApp.Managers.Interfaces;
8040using WinApp.Module;
8041using WinApp.Service.Repository.Interface;
8042using WinApp.View.Helpers;
8043using WinApp.ViewModel;
8044using WinApp.ViewModel.Base;
8045
8046namespace WinApp.ViewModel.Services
8047{
8048  internal class ServiceVM : ViewModelBase
8049  {
8050    private static object _lockObject = new object();
8051    private readonly Product _product;
8052    private Purchase _purchase;
8053    private Module _module;
8054    private bool _isDisabledProduct;
8055    private TileViewItemState _state;
8056    private FlowDocument _richDescription;
8057    private ImageSource _image;
8058    private IModuleManager _manager;
8059    private IModuleResolver _moduleResolver;
8060
8061    public long ProductId
8062    {
8063      get
8064      {
8065        return this._product.Id;
8066      }
8067    }
8068
8069    public Purchase Purchase
8070    {
8071      get
8072      {
8073        return this._purchase;
8074      }
8075    }
8076
8077    public string ServiceButtonContent
8078    {
8079      get
8080      {
8081        if (!this._isDisabledProduct)
8082        {
8083          switch (this._module.StateEnum)
8084          {
8085            case ModuleState.Buy:
8086              return Resources.ServiceVM_Buy;
8087            case ModuleState.Install:
8088              return Resources.ServiceVM_Install;
8089            case ModuleState.Installed:
8090              return Resources.ServiceVM_Activate;
8091            case ModuleState.InstalledAndActivated:
8092            case ModuleState.ValidityCompleted:
8093            case ModuleState.Blocked:
8094              return Resources.ServiceVM_Details;
8095            case ModuleState.Order:
8096              return Resources.ServiceVM_Order;
8097          }
8098        }
8099        return Resources.ServiceVM_Details;
8100      }
8101    }
8102
8103    public TileViewItemState State
8104    {
8105      get
8106      {
8107        return this._state;
8108      }
8109      set
8110      {
8111        this._state = value;
8112        this.OnPropertyChanged("State");
8113        this.OnPropertyChanged("RichDescription");
8114      }
8115    }
8116
8117    public string Title
8118    {
8119      get
8120      {
8121        return this._product.Title;
8122      }
8123      set
8124      {
8125        this._product.Title = value;
8126        this.OnPropertyChanged("Title");
8127      }
8128    }
8129
8130    public double Price
8131    {
8132      get
8133      {
8134        return this._product.Price;
8135      }
8136      set
8137      {
8138        this._product.Price = value;
8139        this.OnPropertyChanged("Price");
8140      }
8141    }
8142
8143    public ImageSource Image
8144    {
8145      get
8146      {
8147        return this._image;
8148      }
8149      private set
8150      {
8151        this._image = value;
8152        this.OnPropertyChanged("Image");
8153      }
8154    }
8155
8156    public DateTime? PurchaseDate
8157    {
8158      get
8159      {
8160        if (this._purchase == null)
8161          return new DateTime?();
8162        return this._purchase.Date;
8163      }
8164    }
8165
8166    public string BackgroundColor
8167    {
8168      get
8169      {
8170        if (this._module.StateEnum == ModuleState.ValidityCompleted || this._isDisabledProduct)
8171          return "#253A516B";
8172        if (this._module.StateEnum == ModuleState.Order)
8173          return "#55A3AD1D";
8174        return this._module.StateEnum != ModuleState.Buy ? "#553A516B" : "Transparent";
8175      }
8176    }
8177
8178    public double EnableOpacity
8179    {
8180      get
8181      {
8182        return this._module.StateEnum != ModuleState.ValidityCompleted && !this._isDisabledProduct ? 1.0 : 0.65;
8183      }
8184    }
8185
8186    public bool IsEnableMainButton
8187    {
8188      get
8189      {
8190        if (this._module.StateEnum != ModuleState.ValidityCompleted)
8191          return !this._isDisabledProduct;
8192        return false;
8193      }
8194    }
8195
8196    public ICommand RestoreStateCommand
8197    {
8198      get
8199      {
8200        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.RestoreStateCommand), (Action) (() => this.State = (TileViewItemState) 0));
8201      }
8202    }
8203
8204    public FlowDocument RichDescription
8205    {
8206      get
8207      {
8208        if (this._richDescription == null && this._state == 1)
8209          new Thread(new ThreadStart(this.GetDetailedDescription))
8210          {
8211            CurrentCulture = Thread.CurrentThread.CurrentCulture,
8212            CurrentUICulture = Thread.CurrentThread.CurrentUICulture,
8213            IsBackground = true
8214          }.Start();
8215        return this._richDescription;
8216      }
8217    }
8218
8219    public ICommand MainCommand
8220    {
8221      get
8222      {
8223        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.MainCommand), new Action(this.MainAction));
8224      }
8225    }
8226
8227    public ServiceVM(Product product, Purchase purchase)
8228    {
8229      this._product = product;
8230      this._purchase = purchase;
8231      this._module = this.GetModule();
8232      this.UpdateByInnerPurchase();
8233      new Thread(new ThreadStart(this.GetImageFromUrl))
8234      {
8235        IsBackground = true
8236      }.Start();
8237    }
8238
8239    public void RefreshButtonContent()
8240    {
8241      this.OnPropertyChanged("ServiceButtonContent");
8242      this.OnPropertyChanged("IsEnableMainButton");
8243      this.OnPropertyChanged("EnableOpacity");
8244      this.OnPropertyChanged("BackgroundColor");
8245    }
8246
8247    public void DisableProduct()
8248    {
8249      this._isDisabledProduct = true;
8250    }
8251
8252    public void Update(Purchase purchase)
8253    {
8254      if (purchase.ProductId != this.ProductId)
8255        return;
8256      lock (ServiceVM._lockObject)
8257      {
8258        if (this._module == null)
8259          return;
8260        this._purchase = purchase;
8261        this.UpdateByInnerPurchase();
8262      }
8263    }
8264
8265    internal void UpdateByInnerPurchase()
8266    {
8267      if (this._module == null)
8268        return;
8269      lock (ServiceVM._lockObject)
8270      {
8271        ModuleState local_0 = this._module.StateEnum;
8272        bool local_1 = true;
8273        if (this._purchase == null)
8274          this._module.StateEnum = this._product.Price <= AppVM.Instance.ActivePackagePrice ? ModuleState.Blocked : ModuleState.Buy;
8275        else if ((this._purchase.PackageStatus == 1 || this._purchase.PackageStatus == 3) && this._purchase.Status == 1)
8276        {
8277          if (AppVM.Instance.ModuleErrorState == ModuleErrorState.CrashOrNotFoundMainFile || AppVM.Instance.ModuleErrorState == ModuleErrorState.ModuleNotInstalledMessage)
8278          {
8279            this._module.StateEnum = ModuleState.Install;
8280            Logger.WriteInfo((object) this, "UpdateByInnerPurchase", string.Concat(new object[4]
8281            {
8282              (object) "Update product '",
8283              (object) this._product.Title,
8284              (object) "': ModuleErrorState = ",
8285              (object) AppVM.Instance.ModuleErrorState
8286            }));
8287            local_1 = false;
8288          }
8289          else
8290            this._module.StateEnum = this.ProductIsInstalledAndActivated() ? ModuleState.InstalledAndActivated : ModuleState.Install;
8291        }
8292        else if ((this._purchase.PackageStatus == 1 || this._purchase.PackageStatus == 3) && this._purchase.Status == 3)
8293          this._module.StateEnum = ModuleState.Order;
8294        else if (this._purchase.PackageStatus == 4)
8295          this._module.StateEnum = ModuleState.ValidityCompleted;
8296        else if (this._purchase.PackageStatus == 5)
8297          this._module.StateEnum = ModuleState.Blocked;
8298        if (local_1 && this._module.StateEnum != local_0)
8299        {
8300          Map.Get<IModuleRepository>().Save(this._module);
8301          Logger.WriteInfo((object) this, "UpdateByInnerPurchase", "Module status changed and saved from '" + (object) local_0 + "' to '" + (string) (object) this._module.StateEnum + "'");
8302        }
8303        this.RefreshButtonContent();
8304      }
8305    }
8306
8307    private bool ProductIsInstalledAndActivated()
8308    {
8309      lock (ServiceVM._lockObject)
8310      {
8311        try
8312        {
8313          return Map.Get<IModuleRepository>().IsInstalledAndActivated(this._product.Id);
8314        }
8315        catch (Exception exception_0)
8316        {
8317          Logger.WriteError((object) this, "ProductIsInstalledAndActivated", "Error by read module info from DB for product '" + this._product.Title + "'", exception_0);
8318          return false;
8319        }
8320      }
8321    }
8322
8323    private Module GetModule()
8324    {
8325      Module moduleByProductId = Map.Get<IModuleRepository>().GetModuleByProductId(this.ProductId);
8326      if (moduleByProductId != null)
8327        return moduleByProductId;
8328      Module entity = new Module()
8329      {
8330        ProductId = this.ProductId,
8331        StateEnum = ModuleState.Buy
8332      };
8333      Map.Get<IModuleRepository>().Save(entity);
8334      return entity;
8335    }
8336
8337    private void GetImageFromUrl()
8338    {
8339      Uri uri;
8340      try
8341      {
8342        Logger.WriteInfo((object) this, "GetImageFromUrl()", "Product " + this._product.Title + " ImageUrl = " + this._product.ImageUrl);
8343        uri = new Uri(string.IsNullOrEmpty(this._product.ImageUrl) ? string.Format("{0}/main/img/{1}.png", (object) ApplicationSettings.ServiceUri, (object) this._product.Title.ToLowerInvariant()) : this._product.ImageUrl);
8344      }
8345      catch (Exception ex)
8346      {
8347        Logger.WriteError((object) this, "GetImageFromUrl()", "Error get uri for product '" + this._product.Title + "'. product.ImageUrl = '" + this._product.ImageUrl + "'", ex);
8348        uri = new Uri(string.Format("{0}/main/img/{1}.png", (object) ApplicationSettings.ServiceUri, (object) this._product.Title.ToLowerInvariant()));
8349      }
8350      try
8351      {
8352        BitmapImage image = new BitmapImage();
8353        image.BeginInit();
8354        image.StreamSource = WebHelper.DownloadImage(uri, Environment.ExpandEnvironmentVariables(string.Format("%TEMP%\\Kairos\\{0}_img.png", (object) this._product.Title.ToLowerInvariant())));
8355        image.EndInit();
8356        image.Freeze();
8357        Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, (Delegate) (() => this.Image = (ImageSource) image));
8358      }
8359      catch (Exception ex)
8360      {
8361        Logger.WriteError((object) this, "GetImageFromUrl()", "Error get uri for product '" + this._product.Title + "'. url = '" + uri.AbsolutePath + "'", ex);
8362      }
8363    }
8364
8365    private void GetDetailedDescription()
8366    {
8367      lock (ServiceVM._lockObject)
8368      {
8369        Stream local_0 = this.GetRtfTextDescription(this._product);
8370        FlowDocument local_1 = new FlowDocument();
8371        new TextRange(local_1.ContentStart, local_1.ContentEnd).Load(local_0, DataFormats.Rtf);
8372        MemoryStream stream = new MemoryStream();
8373        XamlWriter.Save((object) local_1, (Stream) stream);
8374        stream.Position = 0L;
8375        Application.Current.Dispatcher.BeginInvoke((Delegate) (() =>
8376        {
8377          this._richDescription = (FlowDocument) XamlReader.Load((Stream) stream);
8378          this.OnPropertyChanged("RichDescription");
8379        }));
8380      }
8381    }
8382
8383    private Stream GetRtfTextDescription(Product product)
8384    {
8385      lock (ServiceVM._lockObject)
8386      {
8387        string local_4 = RtfReplaseser.Replase(new StreamReader(Application.GetResourceStream(new Uri(Resources.ServicesVM_ProductDescriptionFileName, UriKind.Relative)).Stream).ReadToEnd(), new Dictionary<string, string>()
8388        {
8389          {
8390            "<%ProductTitle%>",
8391            product.Title
8392          },
8393          {
8394            "<%ProductPrice%>",
8395            product.Price.ToString((IFormatProvider) CultureInfo.CurrentCulture)
8396          },
8397          {
8398            "<%Available%>",
8399            product.Attributes.Available
8400          },
8401          {
8402            "<%BasicIncome%>",
8403            product.Attributes.BasicIncome
8404          },
8405          {
8406            "<%BasicIncomePeriod%>",
8407            product.Attributes.BasicIncomePeriod
8408          },
8409          {
8410            "<%DiscSpace%>",
8411            product.Attributes.DiscSpace.ToString()
8412          },
8413          {
8414            "<%InvestmentPeriod%>",
8415            product.Attributes.InvestmentPeriod
8416          },
8417          {
8418            "<%Profit%>",
8419            product.Attributes.Profit
8420          },
8421          {
8422            "<%Start%>",
8423            product.Attributes.Start
8424          },
8425          {
8426            "<%TimeOnline%>",
8427            product.Attributes.TimeOnline
8428          }
8429        });
8430        MemoryStream local_5 = new MemoryStream();
8431        new StreamWriter((Stream) local_5).Write(local_4);
8432        local_5.Position = 0L;
8433        return (Stream) local_5;
8434      }
8435    }
8436
8437    private void MainAction()
8438    {
8439      lock (ServiceVM._lockObject)
8440      {
8441        if (this._module == null)
8442          return;
8443        switch (this._module.StateEnum)
8444        {
8445          case ModuleState.Buy:
8446            Process.Start(this._product.ProductUrl);
8447            break;
8448          case ModuleState.Install:
8449            this.InstallModule();
8450            break;
8451          case ModuleState.Installed:
8452            this.ActivateInstalledModule(true);
8453            break;
8454          case ModuleState.InstalledAndActivated:
8455          case ModuleState.ValidityCompleted:
8456          case ModuleState.Blocked:
8457          case ModuleState.Order:
8458            this.State = (TileViewItemState) 1;
8459            break;
8460        }
8461      }
8462    }
8463
8464    private void InstallModule()
8465    {
8466      lock (ServiceVM._lockObject)
8467      {
8468        try
8469        {
8470          WinApp.Data.Model.ModuleInfo local_0 = Map.Get<IModuleResolver>().GetModuleInfo(this._product.Id);
8471          if (local_0 == null)
8472          {
8473            Logger.WriteError((object) this, "InstallModule", "Module Info not found. exit from install");
8474          }
8475          else
8476          {
8477            if (this._moduleResolver == null)
8478              this._moduleResolver = Map.Get<IModuleResolver>();
8479            if (this._manager == null)
8480            {
8481              Logger.WriteWarning((object) this, "InstallModule", "Module not found. Start get it");
8482              this._manager = this._moduleResolver.GetModuleManager(local_0);
8483            }
8484            if (this._manager == null)
8485              return;
8486            Map.Get<IScreenManager>().SwitchToInstall(this._manager.Install((InvestmentType) 3, this._product.Attributes.DiscSpace, (IModuleCallback) this._moduleResolver), this, new Action<bool>(this.ActivateInstalledModule));
8487          }
8488        }
8489        catch (Exception exception_0)
8490        {
8491          Logger.WriteError((object) this, "InstallModule", "Install module for product '" + this._product.Title + "' error:" + exception_0.Message);
8492          int temp_27 = (int) MessageBox.Show("Product not installed", "Error", MessageBoxButton.OK, MessageBoxImage.Hand);
8493        }
8494      }
8495    }
8496
8497    private void ActivateInstalledModule(bool isInstalled)
8498    {
8499      lock (ServiceVM._lockObject)
8500      {
8501        try
8502        {
8503          if (isInstalled)
8504          {
8505            this._module.StateEnum = ModuleState.Installed;
8506            this.RefreshButtonContent();
8507          }
8508          Logger.WriteInfo((object) this, "ActivateInstalledModule", "Start action of activation");
8509          if (Map.Get<IPurchaseManager>().ActivateModule(this._purchase))
8510          {
8511            this._module.StateEnum = ModuleState.InstalledAndActivated;
8512            AppVM.Instance.SetActivePackage(this._purchase.ProductId);
8513            Logger.WriteInfo((object) this, "ActivateInstalledModule", string.Format(Resources.ScreenManager_ModuleInstalled, (object) this._product.Title));
8514            IScreenManager local_1 = Map.Get<IScreenManager>();
8515            local_1.DoVisualSafe(local_1.ShowStatusMessage(string.Format(Resources.ScreenManager_ModuleInstalled, (object) this._product.Title), 15, false));
8516          }
8517          else
8518          {
8519            this._module.StateEnum = ModuleState.Install;
8520            Map.Get<IScreenManager>().ShowStatusMessage(Resources.ActivationError_TryReinstallModule, 5, false);
8521          }
8522        }
8523        catch (Exception exception_0)
8524        {
8525          Logger.WriteError((object) this, "ModuleInstalled", "Activate module after install for product '" + this._product.Title + "' error:", exception_0);
8526          int temp_32 = (int) MessageBox.Show("Activate installed product problem", "Error", MessageBoxButton.OK, MessageBoxImage.Hand);
8527        }
8528      }
8529      this.RefreshButtonContent();
8530    }
8531  }
8532}
8533?// Decompiled with JetBrains decompiler
8534// Type: WinApp.ViewModel.LoginVM
8535// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
8536// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
8537// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
8538
8539using Inc.Logging;
8540using IncMap;
8541using System;
8542using System.Diagnostics;
8543using System.Windows;
8544using System.Windows.Input;
8545using WinApp;
8546using WinApp.Data.Helpers;
8547using WinApp.Managers;
8548using WinApp.Managers.Interfaces;
8549using WinApp.Managers.Network;
8550
8551namespace WinApp.ViewModel
8552{
8553  internal class LoginVM : LoginBaseVM
8554  {
8555    private Visibility _visibleCheckBoxChangePing = Visibility.Hidden;
8556    private Visibility _visibleHttpWarning = Visibility.Hidden;
8557    private bool _remeberMeEnabled;
8558    private byte _countPing;
8559    private bool _isCheckHttpPing;
8560
8561    public bool RemeberMeEnabled
8562    {
8563      get
8564      {
8565        return this._remeberMeEnabled;
8566      }
8567      set
8568      {
8569        this._remeberMeEnabled = value;
8570        if (this._remeberMeEnabled)
8571          Map.Get<IApplicationSettings>().IsAutoLogin = true;
8572        this.OnPropertyChanged("RemeberMeEnabled");
8573      }
8574    }
8575
8576    public bool IsConnectionAvailable
8577    {
8578      get
8579      {
8580        bool flag = NetworkMonitor.NetworkState == NetworkState.ServerOnline;
8581        if (flag)
8582          this.VisibleCheckBoxChangePing = Visibility.Hidden;
8583        return flag;
8584      }
8585    }
8586
8587    public bool IsCheckHttpPing
8588    {
8589      get
8590      {
8591        this._isCheckHttpPing = Map.Get<IApplicationSettings>().IsHttpUsed;
8592        return this._isCheckHttpPing;
8593      }
8594      set
8595      {
8596        this._isCheckHttpPing = value;
8597        NetworkMonitor.SetPingThrough(this._isCheckHttpPing);
8598        Map.Get<IApplicationSettings>().SetHttpPingUsed(this._isCheckHttpPing);
8599        this.OnPropertyChanged("IsCheckHttpPing");
8600        this.OnPropertyChanged("IsCheckIcmpPing");
8601        this.OnPropertyChanged("VisibleHttpWarning");
8602      }
8603    }
8604
8605    public bool IsCheckIcmpPing
8606    {
8607      get
8608      {
8609        return !this.IsCheckHttpPing;
8610      }
8611      set
8612      {
8613        this.IsCheckHttpPing = false;
8614      }
8615    }
8616
8617    public Visibility VisibleCheckBoxChangePing
8618    {
8619      get
8620      {
8621        if (Map.Get<IApplicationSettings>().IsHttpUsed)
8622          this._visibleCheckBoxChangePing = Visibility.Visible;
8623        return this._visibleCheckBoxChangePing;
8624      }
8625      set
8626      {
8627        this._visibleCheckBoxChangePing = value;
8628        this.OnPropertyChanged("VisibleCheckBoxChangePing");
8629      }
8630    }
8631
8632    public Visibility VisibleHttpWarning
8633    {
8634      get
8635      {
8636        return !this.IsCheckHttpPing ? Visibility.Hidden : Visibility.Visible;
8637      }
8638      set
8639      {
8640        this.OnPropertyChanged("VisibleHttpWarning");
8641      }
8642    }
8643
8644    public ICommand DoRegister
8645    {
8646      get
8647      {
8648        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.DoRegister), (Action) (() => Process.Start(ApplicationSettings.ServiceUri + "/register/")));
8649      }
8650    }
8651
8652    public ICommand DoRestorePassword
8653    {
8654      get
8655      {
8656        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.DoRestorePassword), (Action) (() => Process.Start(ApplicationSettings.ServiceUri + "/resetting/request")));
8657      }
8658    }
8659
8660    public LoginVM()
8661    {
8662      NetworkMonitor.NetworkStateChanged += new EventHandler<NetworkStateEventArgs>(this.NetworkMonitor_NetworkStateChanged);
8663      NetworkMonitor.ConnectionAttemptFailed += new EventHandler<EventArgs>(this.NetworkMonitorOnConnectionAttemptFailed);
8664      if (NetworkMonitor.NetworkState != NetworkState.ServerOnline)
8665        return;
8666      this.TryAutoLogin();
8667    }
8668
8669    public LoginVM(string email, string password)
8670      : base(email, password)
8671    {
8672      NetworkMonitor.NetworkStateChanged += new EventHandler<NetworkStateEventArgs>(this.NetworkMonitor_NetworkStateChanged);
8673      NetworkMonitor.ConnectionAttemptFailed += new EventHandler<EventArgs>(this.NetworkMonitorOnConnectionAttemptFailed);
8674      if (NetworkMonitor.NetworkState != NetworkState.ServerOnline)
8675        return;
8676      this.TryAutoLogin();
8677    }
8678
8679    public void Initialize()
8680    {
8681      try
8682      {
8683        this._remeberMeEnabled = Map.Get<IApplicationSettings>().IsRemeberMe;
8684        this.OnPropertyChanged("RemeberMeEnabled");
8685        string email = Map.Get<IApplicationSettings>().Email;
8686        this.EmailEditable = string.IsNullOrEmpty(email) || !AppVM.Instance.ActivePackageId.HasValue || AppVM.Instance.ActivePackageId.Value < 1L;
8687        this.Email = email;
8688        if (string.IsNullOrEmpty(this.Email) || !this.RemeberMeEnabled)
8689          return;
8690        this.Password = Map.Get<IApplicationSettings>().Password;
8691      }
8692      catch (Exception ex)
8693      {
8694        Logger.WriteError((object) this, "Initialize()", "??????: " + ex.Message);
8695      }
8696    }
8697
8698    protected override void PassAction(bool isAutoLogin)
8699    {
8700      if (!isAutoLogin)
8701      {
8702        if (this.RemeberMeEnabled)
8703        {
8704          Map.Get<IApplicationSettings>().RemeberMe(this.Email, this.Password);
8705        }
8706        else
8707        {
8708          Map.Get<IApplicationSettings>().ForgetMe();
8709          Map.Get<IApplicationSettings>().Email = this.Email;
8710          Map.Get<IApplicationSettings>().Save();
8711        }
8712      }
8713      AppVM.Instance.LogIn();
8714    }
8715
8716    protected override LoginResponce RequestLogin(string email, string password)
8717    {
8718      Logger.WriteInfo(typeof (LoginVM), "RequestLogin()", "?????? ?? ???? ? ???????");
8719      LoginResponce loginResponce = Map.Get<ISessionManager>().Login(email.ToLower(), password);
8720      Logger.WriteInfo(typeof (LoginVM), "RequestLogin()", string.Format("????? ?? ??????: '{0}'", (object) loginResponce.Result));
8721      return loginResponce;
8722    }
8723
8724    private void NetworkMonitor_NetworkStateChanged(object sender, NetworkStateEventArgs e)
8725    {
8726      this.OnPropertyChanged("IsConnectionAvailable");
8727      if (!this.IsConnectionAvailable)
8728        return;
8729      this.TryAutoLogin();
8730    }
8731
8732    private void TryAutoLogin()
8733    {
8734      try
8735      {
8736        if (!Map.Get<IApplicationSettings>().IsAutoLogin)
8737          return;
8738        Logger.WriteInfo((object) this, "TryAutoLogin()", "??????? ?????????. ????? ??????? ????? ? ???????");
8739        Application.Current.Dispatcher.BeginInvoke((Delegate) (() => this.ExecuteLogin(true)));
8740      }
8741      catch (Exception ex)
8742      {
8743        Logger.WriteError((object) this, "TryAutoLogin()", "?????? ??? ??????? ?????????? ??????" + ex.ToString(), ex);
8744      }
8745    }
8746
8747    private void NetworkMonitorOnConnectionAttemptFailed(object sender, EventArgs eventArgs)
8748    {
8749      this.VisibleCheckBoxChangePing = Visibility.Visible;
8750    }
8751  }
8752}
8753?// Decompiled with JetBrains decompiler
8754// Type: WinApp.ViewModel.SessionChartItemVM
8755// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
8756// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
8757// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
8758
8759using System;
8760using WinApp.ViewModel.Base;
8761
8762namespace WinApp.ViewModel
8763{
8764  public class SessionChartItemVM : ViewModelBase
8765  {
8766    private DateTime _date;
8767    private double _duration;
8768
8769    public DateTime Date
8770    {
8771      get
8772      {
8773        return this._date;
8774      }
8775      set
8776      {
8777        this._date = value;
8778        this.OnPropertyChanged("EndTime");
8779      }
8780    }
8781
8782    public double Duration
8783    {
8784      get
8785      {
8786        return this._duration;
8787      }
8788      set
8789      {
8790        this._duration = value;
8791        this.OnPropertyChanged("Duration");
8792      }
8793    }
8794
8795    public SessionChartItemVM(DateTime date, double minutes)
8796    {
8797      this._date = date;
8798      this._duration = minutes;
8799    }
8800  }
8801}
8802?// Decompiled with JetBrains decompiler
8803// Type: WinApp.ViewModel.Controls.SessionStatisticsVM
8804// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
8805// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
8806// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
8807
8808using Inc.Logging;
8809using IncMap;
8810using KairosPlanet.Managers;
8811using KairosPlanet.Managers.Network;
8812using KairosPlanet.Properties;
8813using System;
8814using System.Collections.Generic;
8815using System.Linq;
8816using System.Threading;
8817using System.Timers;
8818using System.Windows;
8819using System.Windows.Input;
8820using WinApp;
8821using WinApp.Api.Data;
8822using WinApp.Data.Helpers;
8823using WinApp.Managers;
8824using WinApp.Managers.Interfaces;
8825using WinApp.Managers.Network;
8826using WinApp.ViewModel;
8827using WinApp.ViewModel.Base;
8828
8829namespace WinApp.ViewModel.Controls
8830{
8831  internal class SessionStatisticsVM : ViewModelBase
8832  {
8833    private static object _lockObject = new object();
8834    private TimeSpan _sessionTime = new TimeSpan();
8835    private object _sessionTimeLock = new object();
8836    private System.Timers.Timer _timer;
8837    private TimeSpan _allSessionTime;
8838    private TimeSpan _today;
8839    private TimeSpan _yesterday;
8840    private TimeSpan _currentMonth;
8841    private TimeSpan _lastMonth;
8842    private TimeSpan _total;
8843    private bool _isStartPing;
8844    private DateTime _lastDateTimeUpdateSessionTime;
8845    private DateTime _currentDate;
8846    private Thread _loadThread;
8847
8848    public string CurrentSession
8849    {
8850      get
8851      {
8852        return TimeSpanExtention.TotalTimeString(this.SessionTime, "{0:00}:{1:00}:{2:00}");
8853      }
8854    }
8855
8856    public string Today
8857    {
8858      get
8859      {
8860        return TimeSpanExtention.TotalTimeString(this._today.Add(this.SessionTime), "{0:00}:{1:00}");
8861      }
8862    }
8863
8864    public string Yesterday
8865    {
8866      get
8867      {
8868        return TimeSpanExtention.TotalTimeString(this._yesterday, "{0:00}:{1:00}");
8869      }
8870    }
8871
8872    public string CurrentMonth
8873    {
8874      get
8875      {
8876        return TimeSpanExtention.TotalTimeString(this._currentMonth.Add(this.SessionTime), "{0:00}:{1:00}");
8877      }
8878    }
8879
8880    public string LastMonth
8881    {
8882      get
8883      {
8884        return TimeSpanExtention.TotalTimeString(this._lastMonth, "{0:00}:{1:00}");
8885      }
8886    }
8887
8888    public string Total
8889    {
8890      get
8891      {
8892        return TimeSpanExtention.TotalTimeString(this._total.Add(this.SessionTime), "{0:00}:{1:00}");
8893      }
8894    }
8895
8896    public string TimeLeftToEarnMoney
8897    {
8898      get
8899      {
8900        return TimeSpanExtention.TotalTimeString(TimeSpan.FromHours(500.0).Subtract(this._currentMonth.Add(this.SessionTime)), "{0:00}:{1:00}");
8901      }
8902    }
8903
8904    public Visibility NotPingVisibility
8905    {
8906      get
8907      {
8908        return !this._isStartPing && !AppVM.Instance.ActivePackageId.HasValue ? Visibility.Visible : Visibility.Collapsed;
8909      }
8910    }
8911
8912    public Visibility NotPingAndRetrievingDataVisibility
8913    {
8914      get
8915      {
8916        return this._isStartPing || !AppVM.Instance.ActivePackageId.HasValue ? Visibility.Collapsed : Visibility.Visible;
8917      }
8918    }
8919
8920    public Visibility PingVisibility
8921    {
8922      get
8923      {
8924        return !this._isStartPing ? Visibility.Collapsed : Visibility.Visible;
8925      }
8926    }
8927
8928    public ICommand RefreshCommand
8929    {
8930      get
8931      {
8932        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.RefreshCommand), new Action(this.DoRefresh), new Func<bool>(this.CanRefresh));
8933      }
8934    }
8935
8936    private TimeSpan SessionTime
8937    {
8938      get
8939      {
8940        return this._sessionTime;
8941      }
8942      set
8943      {
8944        if (this._sessionTime == value)
8945          return;
8946        TimeSpan timeSpan = this._sessionTime;
8947        this._sessionTime = value;
8948        this.OnPropertyChanged("CurrentSession");
8949        if (timeSpan.Minutes == this._sessionTime.Minutes)
8950          return;
8951        this.OnPropertyChanged("Today");
8952        this.OnPropertyChanged("CurrentMonth");
8953        this.OnPropertyChanged("Total");
8954      }
8955    }
8956
8957    public SessionStatisticsVM()
8958    {
8959      NetworkMonitor.NetworkStateChanged += new EventHandler<NetworkStateEventArgs>(this.OnNetworkStateChanged);
8960      this.InitializeTimer();
8961      this.OnNetworkStateChanged((object) this, new NetworkStateEventArgs(AppVM.Instance.NetworkState));
8962      Map.Get<ISessionManager>();
8963      SessionMonitor.Instance.PingEvent += new SessionMonitor.PingEventHandler(this.OnPingEvent);
8964      SessionMonitor.Instance.SessionStateChanged += new EventHandler<SessionStateEventArgs>(this.OnSessionStateChanged);
8965      if (SessionMonitor.Instance.FirstSessionPing == null)
8966        return;
8967      SessionMonitor.Instance.InvokePingEvent(SessionMonitor.Instance.FirstSessionPing.Lifetime);
8968    }
8969
8970    private bool CanRefresh()
8971    {
8972      if (NetworkMonitor.NetworkState != NetworkState.ServerOnline)
8973        return false;
8974      if (this._loadThread != null)
8975        return !this._loadThread.IsAlive;
8976      return true;
8977    }
8978
8979    private void DoRefresh()
8980    {
8981      if (NetworkMonitor.NetworkState != NetworkState.ServerOnline)
8982        return;
8983      Logger.WriteInfo((object) this, "DoRefresh", "?????? ?????? ???????? ??????????");
8984      this.UpdateStatisticsAndStatisticCashe();
8985    }
8986
8987    private void UpdateStatisticsAndStatisticCashe()
8988    {
8989      if (this._loadThread != null && this._loadThread.IsAlive)
8990        return;
8991      Logger.WriteInfo((object) this, "UpdateStatisticsAndStatisticCashe", "????? ???? ? ?????????? ?????????? ? ???????");
8992      this._loadThread = new Thread((ThreadStart) (() =>
8993      {
8994        Action action = Map.Get<IScreenManager>().ShowStatusMessage(Resources.StatusMessage_IsRefreshing, 5, true);
8995        Thread.Sleep(1000);
8996        StatisticManager.Instance.SetNeedRefreshStatistics();
8997        this.UpdateStatistics(true);
8998        action();
8999      }))
9000      {
9001        CurrentUICulture = Thread.CurrentThread.CurrentUICulture,
9002        IsBackground = true
9003      };
9004      this._loadThread.Start();
9005    }
9006
9007    private void OnPingEvent(object sender, PingEventArgs e)
9008    {
9009      lock (this._sessionTimeLock)
9010      {
9011        if (!this._isStartPing)
9012        {
9013          this._isStartPing = true;
9014          this._timer.Start();
9015          this.OnPropertyChanged("NotPingVisibility");
9016          this.OnPropertyChanged("PingVisibility");
9017          this.OnPropertyChanged("NotPingAndRetrievingDataVisibility");
9018        }
9019        this._lastDateTimeUpdateSessionTime = DateTime.Now;
9020        this.SessionTime = new TimeSpan(0, 0, (int) e.LifeTime);
9021      }
9022      this.InitializeTimer();
9023    }
9024
9025    private void UpdateStatistics(bool isRefreshCommand = false)
9026    {
9027      Logger.WriteInfo(typeof (SessionStatisticsVM), "UpdateStatistics()", "????????? ? ?????????? ?????? ??????????...");
9028      if (!isRefreshCommand)
9029        this._currentDate = DateTime.Today;
9030      DateTime dateTime = this._currentDate;
9031      Statistic[] totalStatistics = StatisticManager.Instance.GetStatistics();
9032      if (isRefreshCommand && totalStatistics == null)
9033      {
9034        Logger.WriteError((object) typeof (SessionStatisticsVM), "UpdateStatistics()", "??? ?????????? ??????? ?????????? ?????? ?? ?????????? ?? ???????? ??-?? ?????? ?????????? ? ????????. ??????????? ????????? ????????? ????????? ???????????");
9035        SessionMonitor.Instance.SetSessionStateToSuspended();
9036      }
9037      else
9038      {
9039        if (totalStatistics == null)
9040          totalStatistics = new Statistic[0];
9041        this._today = this.GetTotalTimeByPeriod(new DateTime?(dateTime.Date), new DateTime?(dateTime.Date.AddDays(1.0)), totalStatistics);
9042        this._yesterday = this.GetTotalTimeByPeriod(new DateTime?(dateTime.Date.AddDays(-1.0)), new DateTime?(dateTime.Date), totalStatistics);
9043        this._currentMonth = this.GetTotalTimeByPeriod(new DateTime?(dateTime.Date.AddDays((double) (1 - dateTime.Day))), new DateTime?(dateTime.Date.AddDays((double) (1 - dateTime.Day)).AddMonths(1)), totalStatistics);
9044        this._lastMonth = this.GetTotalTimeByPeriod(new DateTime?(dateTime.Date.AddDays((double) (1 - dateTime.Day)).AddMonths(-1)), new DateTime?(dateTime.Date.AddDays((double) (1 - dateTime.Day))), totalStatistics);
9045        this._total = this.GetTotalTimeByPeriod(new DateTime?(), new DateTime?(), totalStatistics);
9046        Logger.WriteInfo(typeof (SessionStatisticsVM), "UpdateStatistics()", "??? ?????? ???????? ? ?????????");
9047        this.RefreshProperties();
9048      }
9049    }
9050
9051    private void RefreshProperties()
9052    {
9053      this.OnPropertyChanged("CurrentSession");
9054      this.OnPropertyChanged("Today");
9055      this.OnPropertyChanged("Yesterday");
9056      this.OnPropertyChanged("CurrentMonth");
9057      this.OnPropertyChanged("LastMonth");
9058      this.OnPropertyChanged("Total");
9059      this.OnPropertyChanged("TimeLeftToEarnMoney");
9060      this.OnPropertyChanged("NotPingVisibility");
9061      this.OnPropertyChanged("NotPingAndRetrievingDataVisibility");
9062      this.OnPropertyChanged("PingVisibility");
9063      this.RefreshButtonCanExecuteUpdate();
9064    }
9065
9066    private void RefreshButtonCanExecuteUpdate()
9067    {
9068      RelayCommand relayCommand = this.RefreshCommand as RelayCommand;
9069      if (relayCommand == null)
9070        return;
9071      relayCommand.RaiseCanExecuteChanged();
9072    }
9073
9074    private TimeSpan GetTotalTimeByPeriod(DateTime? timeFrom, DateTime? timeTo, Statistic[] totalStatistics)
9075    {
9076      try
9077      {
9078        Statistic[] statisticArray = !timeTo.HasValue || !timeFrom.HasValue ? totalStatistics : Enumerable.ToArray<Statistic>(Enumerable.Where<Statistic>((IEnumerable<Statistic>) totalStatistics, (Func<Statistic, bool>) (ts =>
9079        {
9080          if (ts.CreatedDate >= timeFrom.Value)
9081            return ts.CreatedDate.AddSeconds((double) ts.Lifetime) <= timeTo.Value;
9082          return false;
9083        })));
9084        if (statisticArray == null || statisticArray.Length == 0)
9085          return new TimeSpan(0L);
9086        long num = 0;
9087        foreach (Statistic statistic in statisticArray)
9088        {
9089          if (!statistic.Actual)
9090            num += statistic.Lifetime;
9091        }
9092        return new TimeSpan(0, 0, (int) num);
9093      }
9094      catch (Exception ex)
9095      {
9096        Logger.WriteError((object) this, "InitializeTotalSessionTime", "?????? ??? ????????? ? ???????? ??????? ?? ???? ???????", ex);
9097        return new TimeSpan(0L);
9098      }
9099    }
9100
9101    private void OnNetworkStateChanged(object sender, NetworkStateEventArgs e)
9102    {
9103      switch (e.State)
9104      {
9105        case NetworkState.None:
9106        case NetworkState.NetworkNotFound:
9107        case NetworkState.ServerNotFound:
9108          Logger.WriteInfo(typeof (SessionStatisticsVM), "OnNetworkStateChanged()", "???? ??????? ? ????????? Offline");
9109          this.StopTimer();
9110          this.RefreshProperties();
9111          break;
9112        case NetworkState.ServerOnline:
9113          Logger.WriteInfo(typeof (SessionStatisticsVM), "OnNetworkStateChanged()", "???? ??????? ? ????????? Online");
9114          lock (this._sessionTimeLock)
9115          {
9116            this.UpdateStatistics(false);
9117            if (!this._isStartPing)
9118              break;
9119            this._timer.Start();
9120            break;
9121          }
9122      }
9123    }
9124
9125    private void OnSessionStateChanged(object sender, SessionStateEventArgs e)
9126    {
9127      if (e.State == SessionState.Suspended && this._isStartPing)
9128      {
9129        Logger.WriteInfo(typeof (SessionStatisticsVM), "OnSessionStateChanged()", "?????? ??????? ? ????????? Suspended");
9130        this.StopTimer();
9131      }
9132      else
9133      {
9134        if (e.State != SessionState.InAccrual || !this._isStartPing)
9135          return;
9136        Logger.WriteInfo(typeof (SessionStatisticsVM), "OnSessionStateChanged()", "?????? ??????? ? ????????? Accrual");
9137        this._timer.Start();
9138      }
9139    }
9140
9141    private void StopTimer()
9142    {
9143      if (this._timer == null)
9144        return;
9145      this._timer.Enabled = false;
9146    }
9147
9148    private void InitializeTimer()
9149    {
9150      Logger.WriteInfo(typeof (SessionStatisticsVM), "InitializeTimer()", "????????????? ??????? ?????????? ??????????...");
9151      this._timer = new System.Timers.Timer(40.0);
9152      this._timer.Elapsed += new ElapsedEventHandler(this.TimeTick);
9153      this._timer.AutoReset = false;
9154      Logger.WriteInfo(typeof (SessionStatisticsVM), "InitializeTimer()", "?????? ?????????? ?????????? ???????????????");
9155    }
9156
9157    private void TimeTick(object source, ElapsedEventArgs e)
9158    {
9159      lock (this._sessionTimeLock)
9160      {
9161        DateTime local_0 = DateTime.Now;
9162        if (this._currentDate.Date < local_0.Date)
9163          this.UpdateStatistics(false);
9164        this.SessionTime += local_0.Subtract(this._lastDateTimeUpdateSessionTime);
9165        this._lastDateTimeUpdateSessionTime = local_0;
9166        this._timer.Enabled = true;
9167      }
9168    }
9169  }
9170}
9171?// Decompiled with JetBrains decompiler
9172// Type: WinApp.ViewModel.Controls.VersionControlVM
9173// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
9174// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
9175// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
9176
9177using System;
9178using System.Diagnostics;
9179using System.Linq.Expressions;
9180using System.Windows.Input;
9181using WinApp.Managers;
9182using WinApp.ViewModel;
9183using WinApp.ViewModel.Base;
9184
9185namespace WinApp.ViewModel.Controls
9186{
9187  internal class VersionControlVM : ViewModelBase
9188  {
9189    private Version _appVersionOnSite;
9190    private Version _appVersionCurrent;
9191
9192    public string AppVersionOnSiteText
9193    {
9194      get
9195      {
9196        return this._appVersionOnSite.ToString();
9197      }
9198    }
9199
9200    public string AppVersionCurrentText
9201    {
9202      get
9203      {
9204        return this._appVersionCurrent.ToString();
9205      }
9206    }
9207
9208    public ICommand OpenAppDownloadPageCommand
9209    {
9210      get
9211      {
9212        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.OpenAppDownloadPageCommand), new Action(this.OpenAppDownloadPage));
9213      }
9214    }
9215
9216    public ICommand DownloadNewAppVersionCommand
9217    {
9218      get
9219      {
9220        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.DownloadNewAppVersionCommand), new Action(this.DownloadNewAppVersion));
9221      }
9222    }
9223
9224    public ICommand CloseCommand
9225    {
9226      get
9227      {
9228        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.CloseCommand), new Action(this.CloseWindow));
9229      }
9230    }
9231
9232    public VersionControlVM(Version appVersionOnSite, Version appVersionCurrent)
9233    {
9234      this._appVersionOnSite = appVersionOnSite;
9235      this._appVersionCurrent = appVersionCurrent;
9236    }
9237
9238    public void ButtonOkClick()
9239    {
9240      this.CloseWindow();
9241    }
9242
9243    private void OpenAppDownloadPage()
9244    {
9245      Process.Start(ApplicationSettings.ServiceUri + "/products/my-purchases/");
9246    }
9247
9248    private void DownloadNewAppVersion()
9249    {
9250      Process.Start(ApplicationSettings.ServiceUri + "/products/installer/main/downloader/");
9251    }
9252
9253    private void CloseWindow()
9254    {
9255      AppVM.Instance.ShowMainWindow();
9256    }
9257  }
9258}
9259?// Decompiled with JetBrains decompiler
9260// Type: WinApp.ViewModel.Controls.PersonalInformationVM
9261// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
9262// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
9263// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
9264
9265using Inc.Logging;
9266using IncMap;
9267using KairosPlanet.Properties;
9268using System;
9269using System.Collections.Generic;
9270using System.Linq.Expressions;
9271using System.Windows.Input;
9272using WinApp.Data.Model;
9273using WinApp.Managers.Interfaces;
9274using WinApp.ViewModel.Base;
9275
9276namespace WinApp.ViewModel.Controls
9277{
9278  internal class PersonalInformationVM : ViewModelBase
9279  {
9280    private bool _hasErrors;
9281    private bool _isInEdit;
9282    private string _email;
9283    private string _name;
9284    private int _genderId;
9285    private string _phoneNumber;
9286    private DateTime _birthDate;
9287
9288    public bool IsInEdit
9289    {
9290      get
9291      {
9292        return this._isInEdit;
9293      }
9294      set
9295      {
9296        this._isInEdit = value;
9297        this.OnPropertyChanged("IsInEdit");
9298        this.OnPropertyChanged("SaveEditButtonText");
9299      }
9300    }
9301
9302    public List<string> CountriesCollection { get; private set; }
9303
9304    public string Name
9305    {
9306      get
9307      {
9308        return this._name;
9309      }
9310      set
9311      {
9312        this._name = value;
9313        this.OnPropertyChanged("Name");
9314      }
9315    }
9316
9317    public string Country { get; set; }
9318
9319    public int GenderId
9320    {
9321      get
9322      {
9323        return this._genderId;
9324      }
9325      set
9326      {
9327        this._genderId = value;
9328        this.OnPropertyChanged("Gender");
9329        this.OnPropertyChanged("GenderName");
9330      }
9331    }
9332
9333    public string GenderName
9334    {
9335      get
9336      {
9337        if (this.GenderId != 1)
9338          return Resources.MaleGender;
9339        return Resources.FemaleGender;
9340      }
9341    }
9342
9343    public DateTime CreatedDate { get; set; }
9344
9345    public int UserStatusId { get; set; }
9346
9347    public DateTime BirthDate
9348    {
9349      get
9350      {
9351        return this._birthDate;
9352      }
9353      set
9354      {
9355        this._birthDate = value;
9356        this.OnPropertyChanged("BirthDate");
9357      }
9358    }
9359
9360    public string Email
9361    {
9362      get
9363      {
9364        return this._email;
9365      }
9366      set
9367      {
9368        this._email = value;
9369        this.OnPropertyChanged("Email");
9370      }
9371    }
9372
9373    public string PhoneNumber
9374    {
9375      get
9376      {
9377        return this._phoneNumber;
9378      }
9379      set
9380      {
9381        this._phoneNumber = value;
9382        this.OnPropertyChanged("PhoneNumber");
9383      }
9384    }
9385
9386    public string SaveEditButtonText
9387    {
9388      get
9389      {
9390        if (!this.IsInEdit)
9391          return Resources.SaveEditButton_Edit;
9392        return Resources.SaveEditButton_Save;
9393      }
9394    }
9395
9396    public ICommand SaveEditButtonCommand
9397    {
9398      get
9399      {
9400        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.SaveEditButtonCommand), new Action(this.SaveEditButtonAction));
9401      }
9402    }
9403
9404    public PersonalInformationVM(Man man)
9405    {
9406      this.Name = man.Name;
9407      this.Email = man.Email;
9408      this.CreatedDate = DateTime.Parse(man.CreatedDate);
9409      this.BirthDate = DateTime.Parse(man.BirthDate);
9410      this.GenderId = man.Gender;
9411      this.PhoneNumber = man.PhoneNumber;
9412      this.UserStatusId = man.UserStatus;
9413      this.InitializeCountries();
9414      this.Country = man.Country;
9415    }
9416
9417    private void SaveEditButtonAction()
9418    {
9419      if (this.IsInEdit)
9420      {
9421        Logger.WriteInfo(typeof (ContactInformationVM), "SaveEditButtonAction()", "??????? ?????????? ? ?????? ?????????????? ???????????? ??????????");
9422        this.HideErrors();
9423        this.CheckFields();
9424        if (this._hasErrors)
9425        {
9426          Logger.WriteWarning(typeof (ContactInformationVM), "SaveEditButtonAction()", "?????? ??? ????? ?????? ? ?????? ?????????????? ???????????? ??????????");
9427        }
9428        else
9429        {
9430          this.Save();
9431          Logger.WriteInfo(typeof (ContactInformationVM), "SaveEditButtonAction()", "??????? ? ????? ????????? ???????????? ??????????");
9432          this.IsInEdit = false;
9433        }
9434      }
9435      else
9436      {
9437        Logger.WriteInfo(typeof (ContactInformationVM), "SaveEditButtonAction()", "??????? ? ????? ?????????????? ???????????? ??????????");
9438        this.IsInEdit = true;
9439      }
9440    }
9441
9442    private void Save()
9443    {
9444      Logger.WriteInfo(typeof (ContactInformationVM), "SaveCredential()", "?????????? ????????? ???????????? ??????????...");
9445      Logger.WriteInfo(typeof (ContactInformationVM), "SaveCredential()", "????????? ???????????? ?????????? ??????? ?????????");
9446    }
9447
9448    private void CheckFields()
9449    {
9450    }
9451
9452    private void HideErrors()
9453    {
9454    }
9455
9456    private void InitializeCountries()
9457    {
9458      this.CountriesCollection = Map.Get<ICountriesManager>().GetAllCountries();
9459    }
9460  }
9461}
9462?// Decompiled with JetBrains decompiler
9463// Type: WinApp.ViewModel.Controls.ChangePasswordVM
9464// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
9465// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
9466// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
9467
9468using Inc.Logging;
9469using KairosPlanet.Properties;
9470using System;
9471using System.Windows;
9472using System.Windows.Input;
9473using WinApp.Data.Helpers;
9474using WinApp.ViewModel.Base;
9475
9476namespace WinApp.ViewModel.Controls
9477{
9478  internal class ChangePasswordVM : ViewModelBase
9479  {
9480    private Visibility _currentPasswordErrorVisibility = Visibility.Hidden;
9481    private Visibility _newPasswordErrorVisibility = Visibility.Hidden;
9482    private Visibility _confirmNewPasswordErrorVisibility = Visibility.Hidden;
9483    private string _currentPassword;
9484    private string _newPassword;
9485    private string _confirmNewPassword;
9486    private string _currentPasswordError;
9487    private string _newPasswordError;
9488    private string _confirmNewPasswordError;
9489
9490    public string CurrentPassword
9491    {
9492      get
9493      {
9494        return this._currentPassword;
9495      }
9496      set
9497      {
9498        this._currentPassword = value;
9499        this.OnPropertyChanged("CurrentPassword");
9500      }
9501    }
9502
9503    public string NewPassword
9504    {
9505      get
9506      {
9507        return this._newPassword;
9508      }
9509      set
9510      {
9511        this._newPassword = value;
9512        this.OnPropertyChanged("NewPassword");
9513      }
9514    }
9515
9516    public string ConfirmNewPassword
9517    {
9518      get
9519      {
9520        return this._confirmNewPassword;
9521      }
9522      set
9523      {
9524        this._confirmNewPassword = value;
9525        this.OnPropertyChanged("ConfirmNewPassword");
9526      }
9527    }
9528
9529    public string CurrentPasswordError
9530    {
9531      get
9532      {
9533        return this._currentPasswordError;
9534      }
9535      set
9536      {
9537        this._currentPasswordError = value;
9538        this.OnPropertyChanged("CurrentPasswordError");
9539      }
9540    }
9541
9542    public string NewPasswordError
9543    {
9544      get
9545      {
9546        return this._newPasswordError;
9547      }
9548      set
9549      {
9550        this._newPasswordError = value;
9551        this.OnPropertyChanged("NewPasswordError");
9552      }
9553    }
9554
9555    public string ConfirmNewPasswordError
9556    {
9557      get
9558      {
9559        return this._confirmNewPasswordError;
9560      }
9561      set
9562      {
9563        this._confirmNewPasswordError = value;
9564        this.OnPropertyChanged("ConfirmNewPasswordError");
9565      }
9566    }
9567
9568    public Visibility CurrentPasswordErrorVisibility
9569    {
9570      get
9571      {
9572        return this._currentPasswordErrorVisibility;
9573      }
9574      set
9575      {
9576        this._currentPasswordErrorVisibility = value;
9577        this.OnPropertyChanged("CurrentPasswordErrorVisibility");
9578      }
9579    }
9580
9581    public Visibility NewPasswordErrorVisibility
9582    {
9583      get
9584      {
9585        return this._newPasswordErrorVisibility;
9586      }
9587      set
9588      {
9589        this._newPasswordErrorVisibility = value;
9590        this.OnPropertyChanged("NewPasswordErrorVisibility");
9591      }
9592    }
9593
9594    public Visibility ConfirmNewPasswordErrorVisibility
9595    {
9596      get
9597      {
9598        return this._confirmNewPasswordErrorVisibility;
9599      }
9600      set
9601      {
9602        this._confirmNewPasswordErrorVisibility = value;
9603        this.OnPropertyChanged("ConfirmNewPasswordErrorVisibility");
9604      }
9605    }
9606
9607    public ICommand ChangePasswordCommand
9608    {
9609      get
9610      {
9611        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.ChangePasswordCommand), (Action) (() => this.ExecuteChangePassword()));
9612      }
9613    }
9614
9615    public bool ExecuteChangePassword()
9616    {
9617      Logger.WriteInfo(typeof (ChangePasswordVM), "ExecuteChangePassword()", "??????? ????????? ??????...");
9618      this.HideAllErrors();
9619      if (!this.CheckPasswords())
9620      {
9621        Logger.WriteWarning(typeof (ChangePasswordVM), "ExecuteChangePassword()", "?????? ??? ????? ?????? ??? ????? ??????");
9622        return false;
9623      }
9624      if (!true)
9625      {
9626        Logger.WriteWarning(typeof (ChangePasswordVM), "ExecuteChangePassword()", "?????? ??? ????????? ??????");
9627        this.ShowCurrentPasswordError(Resources.Error_UserPasswordIncorrect);
9628        return false;
9629      }
9630      Logger.WriteInfo(typeof (ChangePasswordVM), "ExecuteChangePassword()", "?????? ??? ??????? ???????");
9631      return true;
9632    }
9633
9634    public bool Cancel()
9635    {
9636      return true;
9637    }
9638
9639    internal bool CheckPasswords()
9640    {
9641      bool flag = false;
9642      if (StringUtil.IsNullOrWhiteSpace(this.CurrentPassword))
9643      {
9644        this.ShowCurrentPasswordError(Resources.Error_EnterCurrentPasswordToChange);
9645        flag = true;
9646      }
9647      if (StringUtil.IsNullOrWhiteSpace(this.NewPassword))
9648      {
9649        this.ShowNewPasswordError(Resources.Error_NewPasswordIsEmpty);
9650        flag = true;
9651      }
9652      if (StringUtil.IsNullOrWhiteSpace(this.ConfirmNewPassword))
9653      {
9654        this.ShowConfirmNewPasswordError(Resources.Error_ConfirmNewPasswordIsEmpty);
9655        flag = true;
9656      }
9657      if (flag)
9658        return false;
9659      if (this.NewPassword.Equals(this.ConfirmNewPassword))
9660        return true;
9661      this.ShowConfirmNewPasswordError(Resources.Error_PasswordsNotIdentical);
9662      return false;
9663    }
9664
9665    private void HideAllErrors()
9666    {
9667      this.CurrentPasswordErrorVisibility = Visibility.Hidden;
9668      this.NewPasswordErrorVisibility = Visibility.Hidden;
9669      this.ConfirmNewPasswordErrorVisibility = Visibility.Hidden;
9670    }
9671
9672    private void ShowCurrentPasswordError(string errorText)
9673    {
9674      this.CurrentPasswordErrorVisibility = Visibility.Visible;
9675      this.CurrentPasswordError = errorText;
9676    }
9677
9678    private void ShowNewPasswordError(string errorText)
9679    {
9680      this.NewPasswordErrorVisibility = Visibility.Visible;
9681      this.NewPasswordError = errorText;
9682    }
9683
9684    private void ShowConfirmNewPasswordError(string errorText)
9685    {
9686      this.ConfirmNewPasswordErrorVisibility = Visibility.Visible;
9687      this.ConfirmNewPasswordError = errorText;
9688    }
9689  }
9690}
9691?// Decompiled with JetBrains decompiler
9692// Type: WinApp.ViewModel.Controls.ContactInformationVM
9693// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
9694// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
9695// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
9696
9697using Inc.Logging;
9698using KairosPlanet.Properties;
9699using System;
9700using System.Linq.Expressions;
9701using System.Windows.Input;
9702using WinApp.Data.Model;
9703using WinApp.ViewModel.Base;
9704
9705namespace WinApp.ViewModel.Controls
9706{
9707  internal class ContactInformationVM : ViewModelBase
9708  {
9709    private bool _hasErrors;
9710    private bool _isInEdit;
9711    private string _email1;
9712    private string _email2;
9713    private string _telephone1;
9714    private string _telephone2;
9715    private string _city;
9716    private string _zipcode;
9717    private string _address;
9718
9719    public bool IsInEdit
9720    {
9721      get
9722      {
9723        return this._isInEdit;
9724      }
9725      set
9726      {
9727        this._isInEdit = value;
9728        this.OnPropertyChanged("IsInEdit");
9729        this.OnPropertyChanged("SaveEditButtonText");
9730      }
9731    }
9732
9733    public string Email1
9734    {
9735      get
9736      {
9737        return this._email1;
9738      }
9739      set
9740      {
9741        this._email1 = value;
9742        this.OnPropertyChanged("Email1");
9743      }
9744    }
9745
9746    public string Email2
9747    {
9748      get
9749      {
9750        return this._email2;
9751      }
9752      set
9753      {
9754        this._email2 = value;
9755        this.OnPropertyChanged("Email2");
9756      }
9757    }
9758
9759    public string Telephone1
9760    {
9761      get
9762      {
9763        return this._telephone1;
9764      }
9765      set
9766      {
9767        this._telephone1 = value;
9768        this.OnPropertyChanged("Telephone1");
9769      }
9770    }
9771
9772    public string Telephone2
9773    {
9774      get
9775      {
9776        return this._telephone2;
9777      }
9778      set
9779      {
9780        this._telephone2 = value;
9781        this.OnPropertyChanged("Telephone2");
9782      }
9783    }
9784
9785    public string City
9786    {
9787      get
9788      {
9789        return this._city;
9790      }
9791      set
9792      {
9793        this._city = value;
9794        this.OnPropertyChanged("City");
9795      }
9796    }
9797
9798    public string Zipcode
9799    {
9800      get
9801      {
9802        return this._zipcode;
9803      }
9804      set
9805      {
9806        this._zipcode = value;
9807        this.OnPropertyChanged("Zipcode");
9808      }
9809    }
9810
9811    public string Address
9812    {
9813      get
9814      {
9815        return this._address;
9816      }
9817      set
9818      {
9819        this._address = value;
9820        this.OnPropertyChanged("Address");
9821      }
9822    }
9823
9824    public string SaveEditButtonText
9825    {
9826      get
9827      {
9828        if (!this.IsInEdit)
9829          return Resources.SaveEditButton_Edit;
9830        return Resources.SaveEditButton_Save;
9831      }
9832    }
9833
9834    public ICommand SaveEditButtonCommand
9835    {
9836      get
9837      {
9838        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.SaveEditButtonCommand), new Action(this.SaveEditButtonAction));
9839      }
9840    }
9841
9842    public ContactInformationVM(Man man)
9843    {
9844      this.Email1 = man.Email;
9845      this.Telephone1 = man.PhoneNumber;
9846    }
9847
9848    private void SaveEditButtonAction()
9849    {
9850      if (this.IsInEdit)
9851      {
9852        Logger.WriteInfo(typeof (ContactInformationVM), "SaveEditButtonAction()", "??????? ?????????? ? ?????? ?????????????? ?????????? ??????????");
9853        this.HideErrors();
9854        this.CheckFields();
9855        if (this._hasErrors)
9856        {
9857          Logger.WriteWarning(typeof (ContactInformationVM), "SaveEditButtonAction()", "?????? ??? ????? ?????? ? ?????? ?????????????? ?????????? ??????????");
9858        }
9859        else
9860        {
9861          this.Save();
9862          Logger.WriteInfo(typeof (ContactInformationVM), "SaveEditButtonAction()", "??????? ? ????? ????????? ?????????? ??????????");
9863          this.IsInEdit = false;
9864        }
9865      }
9866      else
9867      {
9868        Logger.WriteInfo(typeof (ContactInformationVM), "SaveEditButtonAction()", "??????? ? ????? ?????????????? ?????????? ??????????");
9869        this.IsInEdit = true;
9870      }
9871    }
9872
9873    private void Save()
9874    {
9875      Logger.WriteInfo(typeof (ContactInformationVM), "SaveCredential()", "?????????? ????????? ?????????? ??????????...");
9876      Logger.WriteInfo(typeof (ContactInformationVM), "SaveCredential()", "????????? ?????????? ?????????? ??????? ?????????");
9877    }
9878
9879    private void CheckFields()
9880    {
9881    }
9882
9883    private void HideErrors()
9884    {
9885    }
9886  }
9887}
9888?// Decompiled with JetBrains decompiler
9889// Type: WinApp.ViewModel.Controls.ServicesControlVM
9890// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
9891// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
9892// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
9893
9894using Inc.Logging;
9895using IncMap;
9896using KairosPlanet.Managers.Interfaces;
9897using KairosPlanet.Properties;
9898using System;
9899using System.Collections;
9900using System.Collections.Generic;
9901using System.Collections.ObjectModel;
9902using System.Collections.Specialized;
9903using System.Linq;
9904using System.Threading;
9905using System.Windows;
9906using System.Windows.Input;
9907using System.Windows.Threading;
9908using WinApp;
9909using WinApp.Api;
9910using WinApp.Data.Model;
9911using WinApp.Managers.Interfaces;
9912using WinApp.Managers.Network;
9913using WinApp.ViewModel;
9914using WinApp.ViewModel.Base;
9915using WinApp.ViewModel.Services;
9916
9917namespace WinApp.ViewModel.Controls
9918{
9919  internal class ServicesControlVM : ViewModelBase
9920  {
9921    private static object _lockObject = new object();
9922    private Thread _loadThread;
9923
9924    public ObservableCollection<ServiceVM> Services { get; private set; }
9925
9926    public ICommand RefreshCommand
9927    {
9928      get
9929      {
9930        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.RefreshCommand), new Action(this.DoRefresh), new Func<bool>(this.CanRefresh));
9931      }
9932    }
9933
9934    public ServicesControlVM()
9935    {
9936      NetworkMonitor.NetworkStateChanged += new EventHandler<NetworkStateEventArgs>(this.OnNetworkStateChanged);
9937      this.Services = new ObservableCollection<ServiceVM>();
9938      Map.Get<IPurchaseManager>().Purchases.CollectionChanged += new NotifyCollectionChangedEventHandler(this.OnPurchasesChanged);
9939      AppVM.Instance.ErrorStateChanged += new EventHandler(this.AppVmInstance_ErrorStateChanged);
9940      this.DoRefresh();
9941    }
9942
9943    private bool CanRefresh()
9944    {
9945      if (NetworkMonitor.NetworkState != NetworkState.ServerOnline)
9946        return false;
9947      return !this._loadThread.IsAlive;
9948    }
9949
9950    private void OnNetworkStateChanged(object sender, NetworkStateEventArgs e)
9951    {
9952      this.RefreshProperties();
9953    }
9954
9955    private void RefreshProperties()
9956    {
9957      this.RefreshButtonCanExecuteUpdate();
9958    }
9959
9960    private void RefreshButtonCanExecuteUpdate()
9961    {
9962      RelayCommand relayCommand = this.RefreshCommand as RelayCommand;
9963      if (relayCommand == null)
9964        return;
9965      relayCommand.RaiseCanExecuteChanged();
9966    }
9967
9968    private void LoadServices()
9969    {
9970      lock (ServicesControlVM._lockObject)
9971      {
9972        Action local_0 = Map.Get<IScreenManager>().ShowStatusMessage(Resources.StatusMessage_ServicesLoading, 5, true);
9973        try
9974        {
9975          Product[] local_1 = Map.Get<ISessionManager>().Api.GetProducts();
9976          Purchase[] local_2 = Enumerable.ToArray<Purchase>((IEnumerable<Purchase>) Map.Get<IPurchaseManager>().Purchases);
9977          List<ServiceVM> serviceVms = new List<ServiceVM>();
9978          if (local_1 == null)
9979          {
9980            Logger.WriteWarning((object) this, "LoadServices()", "Products is not loaded");
9981            Map.Get<IScreenManager>().ShowStatusMessage(Resources.StatusMessage_CanNotLoadServices, 5, false);
9982            return;
9983          }
9984          Logger.WriteInfo((object) this, "LoadServices()", "Loaded products count: " + (object) local_1.Length);
9985          this.SetActivePackagePrice(local_1);
9986          int local_3 = -1;
9987          foreach (Product item_0 in local_1)
9988          {
9989            Product product = item_0;
9990            Purchase local_4 = Enumerable.FirstOrDefault<Purchase>((IEnumerable<Purchase>) local_2, (Func<Purchase, bool>) (p => p.ProductId == product.Id));
9991            serviceVms.Add(new ServiceVM(product, local_4));
9992            if (local_4 == null)
9993            {
9994              Logger.WriteInfo((object) this, "LoadServices()", string.Format("Product : {0} (product.Status={1}) purchase is not founded", (object) product.Title, (object) product.Status));
9995            }
9996            else
9997            {
9998              if (local_4.PackageStatus == 3)
9999                local_3 = (int) local_4.Price;
10000              Logger.WriteInfo((object) this, "LoadServices()", string.Format("Product : {0} (product.Status={1}) purchase: purchase.PackageStatus={2}, purchase.Status={3}", (object) product.Title, (object) product.Status, (object) local_4.PackageStatus, (object) local_4.Status));
10001            }
10002          }
10003          if (local_3 != -1)
10004          {
10005            foreach (ServiceVM item_1 in serviceVms)
10006            {
10007              if ((double) local_3 > item_1.Price && item_1.Purchase == null)
10008                item_1.DisableProduct();
10009            }
10010          }
10011          Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, (Delegate) (() => Enumerable.ToList<ServiceVM>((IEnumerable<ServiceVM>) Enumerable.OrderBy<ServiceVM, double>((IEnumerable<ServiceVM>) serviceVms, (Func<ServiceVM, double>) (s => s.Price))).ForEach((Action<ServiceVM>) (x => this.Services.Add(x)))));
10012        }
10013        catch (ApiException exception_0)
10014        {
10015          Logger.WriteError((object) this, "LoadServices()", "Error: ", (Exception) exception_0);
10016        }
10017        local_0();
10018      }
10019    }
10020
10021    private void SetActivePackagePrice(Product[] products)
10022    {
10023      lock (ServicesControlVM._lockObject)
10024      {
10025        if (!AppVM.Instance.ActivePackageId.HasValue)
10026        {
10027          AppVM.Instance.ActivePackagePrice = 0.0;
10028        }
10029        else
10030        {
10031          Product local_0 = (Product) null;
10032          if (products != null)
10033            local_0 = Enumerable.FirstOrDefault<Product>((IEnumerable<Product>) products, (Func<Product, bool>) (p => p.Id == AppVM.Instance.ActivePackageId.Value));
10034          AppVM.Instance.ActivePackagePrice = local_0 == null ? 0.0 : local_0.Price;
10035        }
10036      }
10037    }
10038
10039    private void DoRefresh()
10040    {
10041      if (NetworkMonitor.NetworkState != NetworkState.ServerOnline || this._loadThread != null && this._loadThread.IsAlive)
10042        return;
10043      if (this.Services.Count == 0)
10044      {
10045        this._loadThread = new Thread(new ThreadStart(this.LoadServices))
10046        {
10047          CurrentUICulture = Thread.CurrentThread.CurrentUICulture,
10048          IsBackground = true
10049        };
10050        this._loadThread.Start();
10051      }
10052      else
10053      {
10054        this._loadThread = new Thread((ThreadStart) (() =>
10055        {
10056          Action action = Map.Get<IScreenManager>().ShowStatusMessage(Resources.StatusMessage_IsRefreshing, 5, true);
10057          Map.Get<IPurchaseManager>().UpdatePurchases();
10058          this.RefreshServicesState();
10059          action();
10060          this.RefreshProperties();
10061        }))
10062        {
10063          CurrentUICulture = Thread.CurrentThread.CurrentUICulture,
10064          IsBackground = true
10065        };
10066        this._loadThread.Start();
10067      }
10068    }
10069
10070    private void RefreshServicesState()
10071    {
10072      lock (ServicesControlVM._lockObject)
10073      {
10074        Logger.WriteInfo((object) this, "RefreshServicesState", "Execute refresh state for services");
10075        Enumerable.ToList<ServiceVM>((IEnumerable<ServiceVM>) this.Services).ForEach((Action<ServiceVM>) (s => s.UpdateByInnerPurchase()));
10076      }
10077    }
10078
10079    private void AppVmInstance_ErrorStateChanged(object sender, EventArgs e)
10080    {
10081      this.RefreshServicesState();
10082    }
10083
10084    private void ShowUpdateMessage(string productTitle)
10085    {
10086      IScreenManager manager = Map.Get<IScreenManager>();
10087      manager.DoVisualSafe((Action) (() => manager.ShowAlert(string.Format(Resources.Message_NewPackageIsAvailable + productTitle), Resources.Refresh_NewPackage)));
10088    }
10089
10090    private void OnPurchasesChanged(object sender, NotifyCollectionChangedEventArgs e)
10091    {
10092      if (e.Action != NotifyCollectionChangedAction.Add && e.Action != NotifyCollectionChangedAction.Replace)
10093        return;
10094      lock (ServicesControlVM._lockObject)
10095      {
10096        Action local_0 = Map.Get<IScreenManager>().ShowStatusMessage(Resources.StatusMessage_IsRefreshing, 5, true);
10097        try
10098        {
10099          if (e.NewItems.Count > 0)
10100          {
10101            foreach (Purchase item_0 in (IEnumerable) e.NewItems)
10102            {
10103              Purchase purchase = item_0;
10104              ServiceVM local_1 = Enumerable.Single<ServiceVM>((IEnumerable<ServiceVM>) this.Services, (Func<ServiceVM, bool>) (x => x.ProductId == purchase.ProductId));
10105              local_1.Update(purchase);
10106              if (purchase.PackageStatus == 1)
10107                this.ShowUpdateMessage(local_1.Title);
10108            }
10109          }
10110          else
10111            local_0 = Map.Get<IScreenManager>().ShowStatusMessage(Resources.StatusMessage_NoNewPurchases, 5, false);
10112        }
10113        catch (ApiException exception_0)
10114        {
10115          Logger.WriteError((object) this, "OnPurchasesChanged()", "Error: ", (Exception) exception_0);
10116        }
10117        local_0();
10118      }
10119    }
10120  }
10121}
10122?// Decompiled with JetBrains decompiler
10123// Type: WinApp.ViewModel.Controls.SessionHistoryVM
10124// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
10125// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
10126// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
10127
10128using Inc.Logging;
10129using KairosPlanet.Managers;
10130using KairosPlanet.Properties;
10131using System;
10132using System.Collections.Generic;
10133using System.Collections.ObjectModel;
10134using System.Linq;
10135using System.Linq.Expressions;
10136using System.Windows.Input;
10137using WinApp.Api.Data;
10138using WinApp.Data.Helpers;
10139using WinApp.ViewModel;
10140using WinApp.ViewModel.Base;
10141
10142namespace WinApp.ViewModel.Controls
10143{
10144  public class SessionHistoryVM : ViewModelBase
10145  {
10146    private DateTime _periodStart;
10147    private DateTime _periodEnd;
10148    private string _periodTotalString;
10149    private ObservableCollection<SessionRecordVM> _items;
10150    private ObservableCollection<SessionChartItemVM> _chartItems;
10151
10152    public DateTime PeriodStart
10153    {
10154      get
10155      {
10156        return this._periodStart;
10157      }
10158      set
10159      {
10160        this._periodStart = value;
10161        this.OnPropertyChanged("PeriodStart");
10162      }
10163    }
10164
10165    public DateTime PeriodEnd
10166    {
10167      get
10168      {
10169        return this._periodEnd;
10170      }
10171      set
10172      {
10173        this._periodEnd = value.AddDays(1.0).AddSeconds(-1.0);
10174        this.OnPropertyChanged("PeriodEnd");
10175      }
10176    }
10177
10178    public string PeriodTotalString
10179    {
10180      get
10181      {
10182        return this._periodTotalString;
10183      }
10184      private set
10185      {
10186        this._periodTotalString = value;
10187        this.OnPropertyChanged("PeriodTotalString");
10188      }
10189    }
10190
10191    public ObservableCollection<SessionRecordVM> Items
10192    {
10193      get
10194      {
10195        return this._items;
10196      }
10197      private set
10198      {
10199        this._items = value;
10200        this.OnPropertyChanged("Items");
10201      }
10202    }
10203
10204    public ObservableCollection<SessionChartItemVM> ChartItems
10205    {
10206      get
10207      {
10208        return this._chartItems;
10209      }
10210      private set
10211      {
10212        this._chartItems = value;
10213        this.OnPropertyChanged("Items");
10214      }
10215    }
10216
10217    public ICommand ShowPeriodCommand
10218    {
10219      get
10220      {
10221        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.ShowPeriodCommand), new Action(this.ExecuteShowPeriodCommand));
10222      }
10223    }
10224
10225    public SessionHistoryVM()
10226    {
10227      this.PeriodStart = DateTime.Now.Date.AddDays(-7.0);
10228      this.PeriodEnd = DateTime.Now.Date;
10229      this.ExecuteShowPeriodCommand();
10230    }
10231
10232    private void ExecuteShowPeriodCommand()
10233    {
10234      Logger.WriteInfo(typeof (SessionHistoryVM), "ExecuteShowPeriodCommand()", "??????? ???????? ?????? ?? ????????? ??????");
10235      Statistic[] statisticArray = Enumerable.ToArray<Statistic>(Enumerable.Where<Statistic>((IEnumerable<Statistic>) (StatisticManager.Instance.GetStatistics() ?? new Statistic[0]), (Func<Statistic, bool>) (x => x.Lifetime != 0L)));
10236      this.Items = new ObservableCollection<SessionRecordVM>(Enumerable.Where<SessionRecordVM>(Enumerable.Select<Statistic, SessionRecordVM>((IEnumerable<Statistic>) Enumerable.OrderByDescending<Statistic, DateTime>((IEnumerable<Statistic>) statisticArray, (Func<Statistic, DateTime>) (r => r.CreatedDate)), (Func<Statistic, SessionRecordVM>) (x => new SessionRecordVM(x))), (Func<SessionRecordVM, bool>) (y =>
10237      {
10238        DateTime? endTime = y.EndTime;
10239        DateTime periodEnd = this.PeriodEnd;
10240        if ((endTime.HasValue ? (endTime.GetValueOrDefault() < periodEnd ? 1 : 0) : 0) != 0)
10241          return y.StartTime > this.PeriodStart;
10242        return false;
10243      })));
10244      this.ChartItems = new ObservableCollection<SessionChartItemVM>(Enumerable.Select<IGrouping<DateTime, Statistic>, SessionChartItemVM>(Enumerable.GroupBy<Statistic, DateTime>((IEnumerable<Statistic>) statisticArray, (Func<Statistic, DateTime>) (x => x.CreatedDate.Date)), (Func<IGrouping<DateTime, Statistic>, SessionChartItemVM>) (x => new SessionChartItemVM(x.Key, Enumerable.Sum<Statistic>((IEnumerable<Statistic>) x, (Func<Statistic, double>) (y => (double) y.Lifetime / 60.0))))));
10245      Logger.WriteInfo(typeof (SessionHistoryVM), "ExecuteShowPeriodCommand()", "????????? ?????? ??????? ?? ??????...");
10246      string str = TimeSpanExtention.TotalTimeString(TimeSpan.FromMinutes(Enumerable.Sum<SessionChartItemVM>((IEnumerable<SessionChartItemVM>) this.ChartItems, (Func<SessionChartItemVM, double>) (x => x.Duration))), "{0:00}:{1:00}:{2:00}");
10247      Logger.WriteInfo(typeof (SessionHistoryVM), "ExecuteShowPeriodCommand()", "??????? ???????? ????? ????? ?? ????????? ??????");
10248      this.PeriodTotalString = string.Format("{0} {1}", (object) Resources.SessionHistoryUC_Total, (object) str);
10249    }
10250  }
10251}
10252?// Decompiled with JetBrains decompiler
10253// Type: WinApp.ViewModel.Controls.SettingsVM
10254// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
10255// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
10256// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
10257
10258using Inc.Logging;
10259using IncMap;
10260using System;
10261using System.Collections.ObjectModel;
10262using System.Diagnostics;
10263using System.Windows;
10264using System.Windows.Input;
10265using WinApp.Managers.Interfaces;
10266using WinApp.Managers.Localization;
10267using WinApp.Managers.Network;
10268using WinApp.ViewModel.Base;
10269
10270namespace WinApp.ViewModel.Controls
10271{
10272  internal class SettingsVM : ViewModelBase
10273  {
10274    private bool _isRunAtStartup = Map.Get<IApplicationSettings>().RunAtStartup;
10275    private bool _isAutoLogin = Map.Get<IApplicationSettings>().IsAutoLogin;
10276    private bool _isHttpUsed = Map.Get<IApplicationSettings>().IsHttpUsed;
10277    private Visibility _languageSelectedVisibility = Visibility.Hidden;
10278    private Visibility _visibleHttpWarning = Visibility.Hidden;
10279    private LocalizationObject _selectedLanguage;
10280    private bool _isCheckHttpPing;
10281
10282    public bool IsRunAtStartup
10283    {
10284      get
10285      {
10286        return this._isRunAtStartup;
10287      }
10288      set
10289      {
10290        this._isRunAtStartup = value;
10291        Map.Get<IApplicationSettings>().SetRunAtStartup(this._isRunAtStartup);
10292        this.OnPropertyChanged("IsRunAtStartup");
10293      }
10294    }
10295
10296    public bool IsAutoLogin
10297    {
10298      get
10299      {
10300        return this._isAutoLogin;
10301      }
10302      set
10303      {
10304        this._isAutoLogin = value;
10305        Map.Get<IApplicationSettings>().SetIsAutoLogin(this._isAutoLogin);
10306        this.OnPropertyChanged("IsAutoLogin");
10307      }
10308    }
10309
10310    public bool IsCheckHttpPing
10311    {
10312      get
10313      {
10314        this._isCheckHttpPing = Map.Get<IApplicationSettings>().IsHttpUsed;
10315        return this._isCheckHttpPing;
10316      }
10317      set
10318      {
10319        this._isCheckHttpPing = value;
10320        NetworkMonitor.SetPingThrough(this._isCheckHttpPing);
10321        Map.Get<IApplicationSettings>().SetHttpPingUsed(this._isCheckHttpPing);
10322        this.OnPropertyChanged("IsCheckHttpPing");
10323        this.OnPropertyChanged("IsCheckIcmpPing");
10324        this.OnPropertyChanged("VisibleHttpWarning");
10325      }
10326    }
10327
10328    public bool IsCheckIcmpPing
10329    {
10330      get
10331      {
10332        return !this.IsCheckHttpPing;
10333      }
10334      set
10335      {
10336        this.IsCheckHttpPing = false;
10337      }
10338    }
10339
10340    public Visibility VisibleHttpWarning
10341    {
10342      get
10343      {
10344        return !this.IsCheckHttpPing ? Visibility.Hidden : Visibility.Visible;
10345      }
10346      set
10347      {
10348        this.OnPropertyChanged("VisibleHttpWarning");
10349      }
10350    }
10351
10352    public bool IsAutoLoginEnabled
10353    {
10354      get
10355      {
10356        return Map.Get<IApplicationSettings>().IsRemeberMe;
10357      }
10358    }
10359
10360    public ObservableCollection<LocalizationObject> LanguagesCollection
10361    {
10362      get
10363      {
10364        return Map.Get<ILocalizationManager>().LanguagesCollection;
10365      }
10366    }
10367
10368    public LocalizationObject SelectedLanguage
10369    {
10370      get
10371      {
10372        return this._selectedLanguage;
10373      }
10374      set
10375      {
10376        this._selectedLanguage = value;
10377        if (this._selectedLanguage == null)
10378          return;
10379        Map.Get<IApplicationSettings>().SetLocalization(this._selectedLanguage);
10380        this.LanguageSelectedVisibility = Visibility.Visible;
10381        this.OnPropertyChanged("SelectedLanguage");
10382      }
10383    }
10384
10385    public Visibility LanguageSelectedVisibility
10386    {
10387      get
10388      {
10389        return this._languageSelectedVisibility;
10390      }
10391      set
10392      {
10393        this._languageSelectedVisibility = value;
10394        this.OnPropertyChanged("LanguageSelectedVisibility");
10395      }
10396    }
10397
10398    public ICommand RestartCommand
10399    {
10400      get
10401      {
10402        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.RestartCommand), new Action(this.Restart));
10403      }
10404    }
10405
10406    internal SettingsVM()
10407    {
10408      this.IsRunAtStartup = Map.Get<IApplicationSettings>().RunAtStartup;
10409      this._selectedLanguage = Map.Get<IApplicationSettings>().GetLocalizationObject();
10410    }
10411
10412    private void Restart()
10413    {
10414      Logger.WriteInfo(typeof (SettingsVM), "Restart()", "???????????? ??????????...");
10415      Process.Start(Application.ResourceAssembly.Location);
10416      Application.Current.Shutdown();
10417    }
10418  }
10419}
10420?// Decompiled with JetBrains decompiler
10421// Type: WinApp.ViewModel.Controls.CaptionListVM
10422// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
10423// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
10424// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
10425
10426using Inc.Logging;
10427using IncMap;
10428using System;
10429using System.Linq.Expressions;
10430using System.Windows.Input;
10431using WinApp.Managers.Interfaces;
10432using WinApp.ViewModel.Base;
10433using WinApp.ViewModel.MainMenu;
10434
10435namespace WinApp.ViewModel.Controls
10436{
10437  internal class CaptionListVM : ViewModelBase
10438  {
10439    public CaptionMenuItem MenuItem { get; set; }
10440
10441    public ICommand OpenCommand
10442    {
10443      get
10444      {
10445        return this.Commands.GetOrCreateCommand<ICommand>((Expression<Func<ICommand>>) (() => this.OpenCommand), new Action<object>(this.OpenTab));
10446      }
10447    }
10448
10449    public CaptionListVM(CaptionMenuItem menuItem)
10450    {
10451      this.MenuItem = menuItem;
10452    }
10453
10454    private void OpenTab(object obj)
10455    {
10456      MainMenuItem menuItem = obj as MainMenuItem;
10457      if (menuItem == null)
10458        return;
10459      Logger.WriteInfo(typeof (CaptionListVM), "OpenTab()", string.Format("??????????? ??????? ?? ???????? '{0}'...", (object) menuItem.Name));
10460      Map.Get<IScreenManager>().MainView.ViewModel.SwithToMenuItem(menuItem);
10461      Logger.WriteInfo(typeof (CaptionListVM), "OpenTab()", string.Format("??????? ?? ???????? '{0}' ???????? ???????", (object) menuItem.Name));
10462    }
10463  }
10464}
10465?// Decompiled with JetBrains decompiler
10466// Type: WinApp.ViewModel.MainViewVM
10467// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
10468// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
10469// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
10470
10471using Inc.Logging;
10472using IncMap;
10473using KairosPlanet;
10474using KairosPlanet.Properties;
10475using System;
10476using System.Collections.Generic;
10477using System.Linq;
10478using System.Windows;
10479using System.Windows.Controls;
10480using System.Windows.Documents;
10481using System.Windows.Media;
10482using System.Windows.Media.Imaging;
10483using WinApp.Managers.Interfaces;
10484using WinApp.View;
10485using WinApp.ViewModel.Base;
10486using WinApp.ViewModel.MainMenu;
10487
10488namespace WinApp.ViewModel
10489{
10490  internal class MainViewVM : ViewModelBase
10491  {
10492    private readonly Stack<Control> _controlsHistory = new Stack<Control>();
10493    private readonly MainMenuCollection _menu = new MainMenuCollection();
10494    private Visibility _visiblityErrorBlock = Visibility.Collapsed;
10495    private Visibility _visibilityStatusBlock = Visibility.Collapsed;
10496    private Visibility _isStatusInProgress = Visibility.Collapsed;
10497    private FlowDocument _errorDocument = new FlowDocument();
10498    private MainMenuItem _selectedMenuItem;
10499    private Control _content;
10500    private string _messageErrorBlock;
10501    private string _statusMessage;
10502    private MainViewUC _mainView;
10503
10504    public MainMenuCollection MenuItems
10505    {
10506      get
10507      {
10508        return this._menu;
10509      }
10510    }
10511
10512    public MainMenuItem SelectedMenuItem
10513    {
10514      get
10515      {
10516        return this._selectedMenuItem;
10517      }
10518      set
10519      {
10520        this._selectedMenuItem = value;
10521        if (!object.Equals((object) this.Content, (object) this._selectedMenuItem.Control))
10522          this.SwithToMenuItem(this._selectedMenuItem);
10523        this.OnPropertyChanged("SelectedMenuItem");
10524      }
10525    }
10526
10527    public Control Content
10528    {
10529      get
10530      {
10531        return this._content;
10532      }
10533      set
10534      {
10535        this._content = value;
10536        this.OnPropertyChanged("Content");
10537      }
10538    }
10539
10540    public Visibility VisiblityErrorBlock
10541    {
10542      get
10543      {
10544        return this._visiblityErrorBlock;
10545      }
10546      set
10547      {
10548        this._visiblityErrorBlock = value;
10549        this.OnPropertyChanged("VisiblityErrorBlock");
10550      }
10551    }
10552
10553    public FlowDocument ErrorDocument
10554    {
10555      get
10556      {
10557        return this._errorDocument;
10558      }
10559      set
10560      {
10561        this._errorDocument = value;
10562        this.OnPropertyChanged("ErrorDocument");
10563      }
10564    }
10565
10566    public string MessageErrorBlock
10567    {
10568      get
10569      {
10570        return this._messageErrorBlock;
10571      }
10572      set
10573      {
10574        this._messageErrorBlock = value;
10575        this.OnPropertyChanged("MessageErrorBlock");
10576      }
10577    }
10578
10579    public string StatusMessage
10580    {
10581      get
10582      {
10583        return this._statusMessage;
10584      }
10585      set
10586      {
10587        this._statusMessage = value;
10588        this.VisibilityStatusBlock = !string.IsNullOrEmpty(this.StatusMessage) || this._isStatusInProgress == Visibility.Visible ? Visibility.Visible : Visibility.Collapsed;
10589        this.OnPropertyChanged("StatusMessage");
10590      }
10591    }
10592
10593    public Visibility VisibilityStatusBlock
10594    {
10595      get
10596      {
10597        return this._visibilityStatusBlock;
10598      }
10599      set
10600      {
10601        this._visibilityStatusBlock = value;
10602        this.OnPropertyChanged("VisibilityStatusBlock");
10603      }
10604    }
10605
10606    public Visibility IsStatusInProgress
10607    {
10608      get
10609      {
10610        return this._isStatusInProgress;
10611      }
10612      set
10613      {
10614        this._isStatusInProgress = value;
10615        this.VisibilityStatusBlock = !string.IsNullOrEmpty(this.StatusMessage) || this._isStatusInProgress == Visibility.Visible ? Visibility.Visible : Visibility.Collapsed;
10616        this.OnPropertyChanged("IsStatusInProgress");
10617      }
10618    }
10619
10620    public MainViewVM(MainViewUC mainViewUc)
10621    {
10622      this._mainView = mainViewUc;
10623      this._menu.Services.IsSelected = true;
10624      AppVM.Instance.ErrorStateChanged += new EventHandler(this.OnErrorStateChanged);
10625      this.ErorStateRefresh();
10626    }
10627
10628    ~MainViewVM()
10629    {
10630      AppVM.Instance.ErrorStateChanged -= new EventHandler(this.OnErrorStateChanged);
10631    }
10632
10633    public void SwithToMenuItem(MainMenuItem menuItem)
10634    {
10635      Logger.WriteInfo(typeof (MainViewVM), "SwithToMenuItem()", string.Format("??????? ?? ???????? '{0}'", (object) menuItem.Name));
10636      this._controlsHistory.Clear();
10637      this.SwithTo(menuItem.Control, true);
10638      MainMenuItem mainMenuItem1;
10639      if (menuItem is CaptionMenuItem)
10640      {
10641        menuItem.IsExpanded = true;
10642        mainMenuItem1 = menuItem;
10643      }
10644      else
10645        mainMenuItem1 = menuItem.Parent;
10646      foreach (MainMenuItem mainMenuItem2 in Enumerable.Except<MainMenuItem>((IEnumerable<MainMenuItem>) this.MenuItems, (IEnumerable<MainMenuItem>) new MainMenuItem[1]
10647      {
10648        mainMenuItem1
10649      }))
10650        mainMenuItem2.IsExpanded = false;
10651      if (menuItem.IsSelected)
10652        return;
10653      menuItem.IsSelected = true;
10654    }
10655
10656    public void SwitchBack()
10657    {
10658      if (!this.CanSwitchBack())
10659        return;
10660      this._controlsHistory.Pop();
10661      this.Content = this._controlsHistory.Peek();
10662    }
10663
10664    public bool CanSwitchBack()
10665    {
10666      return this._controlsHistory.Count > 1;
10667    }
10668
10669    private void OnErrorStateChanged(object sender, EventArgs eventArgs)
10670    {
10671      this.ErorStateRefresh();
10672    }
10673
10674    private void ErorStateRefresh()
10675    {
10676      switch (AppVM.Instance.ModuleErrorState)
10677      {
10678        case ModuleErrorState.NoError:
10679          this._visiblityErrorBlock = Visibility.Collapsed;
10680          this._messageErrorBlock = string.Empty;
10681          break;
10682        case ModuleErrorState.CrashOrNotFoundMainFile:
10683          this.ShowError(Resources.Tray_ModuleCrashOrNotFoundMainFiledMessage);
10684          break;
10685        case ModuleErrorState.ModuleNotInstalledMessage:
10686          this.ShowError(Resources.Tray_ModuleNotInstalledMessage);
10687          break;
10688      }
10689      this.OnPropertyChanged("VisiblityErrorBlock");
10690      this.OnPropertyChanged("MessageErrorBlock");
10691      this.OnPropertyChanged("ErrorDocument");
10692    }
10693
10694    private void SwithTo(Control control, bool pushToHistory = true)
10695    {
10696      this.Content = control;
10697      if (!pushToHistory)
10698        return;
10699      this._controlsHistory.Push(control);
10700    }
10701
10702    private void ShowError(string message)
10703    {
10704      this._messageErrorBlock = message;
10705      this._visiblityErrorBlock = Visibility.Visible;
10706      Map.Get<IScreenManager>().DoVisualSafe((Action) (() => this.ErrorDocument = this.CreateFlowDocument(message)));
10707    }
10708
10709    private FlowDocument CreateFlowDocument(string message)
10710    {
10711      FlowDocument flowDocument = new FlowDocument()
10712      {
10713        PagePadding = new Thickness(0.0)
10714      };
10715      Paragraph paragraph = new Paragraph();
10716      BitmapImage bitmapImage = new BitmapImage();
10717      bitmapImage.BeginInit();
10718      bitmapImage.UriSource = new Uri("pack://application:,,,/KairosPlanet;component/Assets/Images/Offline.ico", UriKind.Absolute);
10719      bitmapImage.EndInit();
10720      Image image = new Image();
10721      image.Source = (ImageSource) bitmapImage;
10722      image.Height = 40.0;
10723      image.Width = 40.0;
10724      BlockUIContainer blockUiContainer = new BlockUIContainer((UIElement) image);
10725      blockUiContainer.Margin = new Thickness(0.0);
10726      Figure figure1 = new Figure((Block) blockUiContainer);
10727      figure1.HorizontalAnchor = FigureHorizontalAnchor.PageLeft;
10728      figure1.Width = new FigureLength(40.0);
10729      figure1.Margin = new Thickness(0.0, 0.0, 10.0, 0.0);
10730      figure1.Padding = new Thickness(0.0);
10731      Figure figure2 = figure1;
10732      paragraph.Inlines.Add((Inline) figure2);
10733      paragraph.Margin = new Thickness(0.0);
10734      paragraph.Padding = new Thickness(0.0);
10735      paragraph.LineHeight = 0.6;
10736      paragraph.TextAlignment = TextAlignment.Justify;
10737      paragraph.Foreground = (Brush) new SolidColorBrush(Color.FromRgb((byte) 102, (byte) 102, (byte) 102));
10738      paragraph.FontFamily = (FontFamily) this._mainView.FindResource((object) "OpenSans");
10739      paragraph.Inlines.Add(message);
10740      flowDocument.Blocks.Add((Block) paragraph);
10741      return flowDocument;
10742    }
10743  }
10744}
10745?// Decompiled with JetBrains decompiler
10746// Type: WinApp.ViewModel.LoginBaseVM
10747// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
10748// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
10749// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
10750
10751using Inc.Logging;
10752using IncMap;
10753using KairosPlanet.Properties;
10754using System;
10755using System.Windows;
10756using System.Windows.Input;
10757using WinApp.Data.Helpers;
10758using WinApp.Managers.Interfaces;
10759using WinApp.ViewModel.Base;
10760
10761namespace WinApp.ViewModel
10762{
10763  internal abstract class LoginBaseVM : ViewModelBase
10764  {
10765    private Visibility _screenVisibility = Visibility.Hidden;
10766    private Visibility _emailErrorVisibility = Visibility.Hidden;
10767    private Visibility _passwordErrorVisibility = Visibility.Hidden;
10768    private bool _emailEditable = true;
10769    private string _email;
10770    private string _password;
10771    private string _emailError;
10772    private string _passwordError;
10773
10774    public string Password
10775    {
10776      get
10777      {
10778        return this._password;
10779      }
10780      set
10781      {
10782        this._password = value;
10783        this.OnPropertyChanged("Password");
10784      }
10785    }
10786
10787    public string Email
10788    {
10789      get
10790      {
10791        return this._email;
10792      }
10793      set
10794      {
10795        this._email = value;
10796        this.OnPropertyChanged("Email");
10797      }
10798    }
10799
10800    public Visibility ScreenVisibility
10801    {
10802      get
10803      {
10804        return this._screenVisibility;
10805      }
10806      set
10807      {
10808        this._screenVisibility = value;
10809        this.OnPropertyChanged("ScreenVisibility");
10810      }
10811    }
10812
10813    public Visibility EmailErrorVisibility
10814    {
10815      get
10816      {
10817        return this._emailErrorVisibility;
10818      }
10819      set
10820      {
10821        this._emailErrorVisibility = value;
10822        this.OnPropertyChanged("EmailErrorVisibility");
10823      }
10824    }
10825
10826    public Visibility PasswordErrorVisibility
10827    {
10828      get
10829      {
10830        return this._passwordErrorVisibility;
10831      }
10832      set
10833      {
10834        this._passwordErrorVisibility = value;
10835        this.OnPropertyChanged("PasswordErrorVisibility");
10836      }
10837    }
10838
10839    public string EmailError
10840    {
10841      get
10842      {
10843        return this._emailError;
10844      }
10845      set
10846      {
10847        this._emailError = value;
10848        this.OnPropertyChanged("EmailError");
10849      }
10850    }
10851
10852    public string PasswordError
10853    {
10854      get
10855      {
10856        return this._passwordError;
10857      }
10858      set
10859      {
10860        this._passwordError = value;
10861        this.OnPropertyChanged("PasswordError");
10862      }
10863    }
10864
10865    public bool EmailEditable
10866    {
10867      get
10868      {
10869        return this._emailEditable;
10870      }
10871      set
10872      {
10873        this._emailEditable = value;
10874        this.OnPropertyChanged("EmailEditable");
10875      }
10876    }
10877
10878    public ICommand DoLogin
10879    {
10880      get
10881      {
10882        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.DoLogin), (Action) (() => this.ExecuteLogin(false)));
10883      }
10884    }
10885
10886    protected LoginBaseVM(string email, string password)
10887    {
10888      this.Email = email;
10889      this.Password = password;
10890    }
10891
10892    protected LoginBaseVM()
10893    {
10894    }
10895
10896    protected void ExecuteLogin(bool autoLogin = false)
10897    {
10898      Logger.WriteInfo(typeof (LoginBaseVM), "ExecuteLogin()", "??????? ????? ? ??????? ?????????????...");
10899      if (!autoLogin)
10900      {
10901        if (this.HasAnyError())
10902        {
10903          Logger.WriteWarning(typeof (LoginBaseVM), "ExecuteLogin()", "?????? ??? ?????????? ?????? ??? ????? ? ???????");
10904          return;
10905        }
10906      }
10907      try
10908      {
10909        switch (this.RequestLogin(this.Email, this.Password).Result)
10910        {
10911          case LoginResult.NoResponce:
10912            this.HideAllErrors();
10913            Logger.WriteWarning(typeof (LoginBaseVM), "ExecuteLogin()", "?????? ??? ????? ???????????? ? ???????. ?? ??????? ??????????? ? ???????????? ???????");
10914            this.ShowConnectionError();
10915            break;
10916          case LoginResult.WrongInput:
10917            this.EmailErrorVisibility = Visibility.Visible;
10918            this.PasswordErrorVisibility = Visibility.Visible;
10919            this.EmailError = Resources.Error_PasswordOrEmailInvalid;
10920            Logger.WriteWarning(typeof (LoginBaseVM), "ExecuteLogin()", "?????? ??? ????? ???????????? ? ???????. ???????? ???? ??????");
10921            break;
10922          case LoginResult.UserDeleted:
10923            Logger.WriteWarning(typeof (LoginBaseVM), "ExecuteLogin()", "?????? ??? ????? ???????????? ? ???????. ??????? ??????");
10924            this.ShowUserDeletedError();
10925            break;
10926          case LoginResult.Pass:
10927            this.PassAction(autoLogin);
10928            Logger.WriteInfo(typeof (LoginBaseVM), "ExecuteLogin()", "???? ??????? ????????");
10929            break;
10930        }
10931      }
10932      catch (Exception ex)
10933      {
10934        Logger.WriteError((object) this, "ExecuteLogin()", "?????? ??? ???????? ?????? ? ???????: " + ex.Message);
10935      }
10936    }
10937
10938    protected abstract void PassAction(bool isAutoLogin);
10939
10940    protected abstract LoginResponce RequestLogin(string email, string password);
10941
10942    private bool HasAnyError()
10943    {
10944      this.HideAllErrors();
10945      bool flag = false;
10946      if (StringUtil.IsNullOrWhiteSpace(this.Email))
10947      {
10948        this.ShowEmailEmptyError();
10949        flag = true;
10950      }
10951      if (StringUtil.IsNullOrWhiteSpace(this.Password))
10952      {
10953        this.ShowPasswordEmptyError();
10954        flag = true;
10955      }
10956      return flag;
10957    }
10958
10959    private void HideAllErrors()
10960    {
10961      this.EmailError = string.Empty;
10962      this.PasswordError = string.Empty;
10963      this.EmailErrorVisibility = Visibility.Hidden;
10964      this.PasswordErrorVisibility = Visibility.Hidden;
10965    }
10966
10967    private void ShowPasswordEmptyError()
10968    {
10969      this.PasswordErrorVisibility = Visibility.Visible;
10970      this.PasswordError = Resources.Error_PasswordIsEmpty;
10971    }
10972
10973    private void ShowEmailEmptyError()
10974    {
10975      this.EmailErrorVisibility = Visibility.Visible;
10976      this.EmailError = Resources.Error_EmailIsEmpty;
10977    }
10978
10979    private void ShowUserDeletedError()
10980    {
10981      Map.Get<IScreenManager>().ShowAlert(Resources.Error_UserDeletedError, Resources.Error);
10982    }
10983
10984    private void ShowConnectionError()
10985    {
10986      Map.Get<IScreenManager>().ShowAlert(Resources.Error_ConnectionError, Resources.Error);
10987    }
10988  }
10989}
10990?// Decompiled with JetBrains decompiler
10991// Type: WinApp.ViewModel.AppVM
10992// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
10993// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
10994// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
10995
10996using Inc.Logging;
10997using IncMap;
10998using KairosPlanet;
10999using KairosPlanet.Managers.Network;
11000using System;
11001using System.Configuration;
11002using System.Reflection;
11003using System.Windows;
11004using Telerik.Windows.Controls;
11005using WinApp;
11006using WinApp.Managers.Interfaces;
11007using WinApp.Managers.Localization;
11008using WinApp.Managers.Network;
11009using WinApp.Service.Core;
11010using WinApp.View.Helpers;
11011
11012namespace WinApp.ViewModel
11013{
11014  internal class AppVM
11015  {
11016    private static readonly object _createLock = new object();
11017    private static AppVM _instance;
11018    private NetworkState _networkState;
11019    private ModuleErrorState _moduleErrorState;
11020    private long? _activePackageId;
11021    private double _activePackagePrice;
11022    private bool _isLoadedPackageId;
11023    private bool _isHttpUsed;
11024
11025    public static AppVM Instance
11026    {
11027      get
11028      {
11029        if (AppVM._instance == null)
11030          AppVM.InitializeAppVM();
11031        return AppVM._instance;
11032      }
11033    }
11034
11035    public NetworkState NetworkState
11036    {
11037      get
11038      {
11039        return this._networkState;
11040      }
11041      set
11042      {
11043        if (this._networkState == value)
11044          return;
11045        this._networkState = value;
11046        try
11047        {
11048          Map.Get<IAppTray>().Refresh();
11049        }
11050        catch (Exception ex)
11051        {
11052          throw;
11053        }
11054      }
11055    }
11056
11057    public ModuleErrorState ModuleErrorState
11058    {
11059      get
11060      {
11061        return this._moduleErrorState;
11062      }
11063      set
11064      {
11065        if (this._moduleErrorState == value)
11066          return;
11067        Logger.WriteWarning((object) this, "ModuleErrorState", "ModuleErrorState changed from '" + (object) this._moduleErrorState + "' on '" + (string) (object) value + "'");
11068        this._moduleErrorState = value;
11069        if (this.ErrorStateChanged == null)
11070          return;
11071        this.ErrorStateChanged((object) this, new EventArgs());
11072      }
11073    }
11074
11075    public LoginState LoginState { get; private set; }
11076
11077    public long? ActivePackageId
11078    {
11079      get
11080      {
11081        if (!this._isLoadedPackageId)
11082        {
11083          this._activePackageId = new long?(Map.Get<IApplicationSettings>().ActiveProductId);
11084          this._isLoadedPackageId = true;
11085        }
11086        return this._activePackageId;
11087      }
11088      set
11089      {
11090        this._activePackageId = value;
11091      }
11092    }
11093
11094    public bool IsHttpUsed
11095    {
11096      get
11097      {
11098        this._isHttpUsed = Map.Get<IApplicationSettings>().IsHttpUsed;
11099        return this._isHttpUsed;
11100      }
11101      set
11102      {
11103        this._isHttpUsed = value;
11104      }
11105    }
11106
11107    public double ActivePackagePrice
11108    {
11109      get
11110      {
11111        return this._activePackagePrice;
11112      }
11113      set
11114      {
11115        this._activePackagePrice = value;
11116      }
11117    }
11118
11119    internal event EventHandler ErrorStateChanged;
11120
11121    private AppVM()
11122    {
11123    }
11124
11125    public static void Initialize()
11126    {
11127      try
11128      {
11129        Logger.WriteInfo(typeof (AppVM), "Initialize()", "????????????? ??????????...");
11130        AppVM.InitializeAppVM();
11131        AppDomain.CurrentDomain.AppendPrivatePath("Modules\\Rent module");
11132        Logger.WriteInfo((object) typeof (AppVM), "Initialize()", "???????? ????????????? ??????????", "??????? ?????? ?????????? - " + AppVM.Instance.GetCurrentAppVersion().ToString());
11133      }
11134      catch (Exception ex)
11135      {
11136        Logger.WriteError(typeof (AppVM), "Initialize()", "?????? ??? ????????????? ??????????", ex);
11137      }
11138    }
11139
11140    public void OnStartUp()
11141    {
11142      Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "????? ??????????. ????????????? ???????????...");
11143      Bootstrapper.Bootstrap();
11144      TelerikThemeManager.ApplyTheme();
11145      Map.Get<ILocalizationManager>().ApplyLocalization();
11146      Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "ApplyLocalization executed");
11147      NetworkMonitor.NetworkStateChanged += new EventHandler<NetworkStateEventArgs>(this.OnNetworkStateChanged);
11148      NetworkMonitor.StartNetworkMonitoring();
11149      Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "NetworkMonitor started");
11150      try
11151      {
11152        Map.Get<IMainWindow>().Show();
11153        IMainWindow mainWindow = Map.Get<IMainWindow>();
11154        mainWindow.Show();
11155        ((UIElement) (mainWindow as RadWindow)).Focus();
11156        Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "MainWindow Show executed");
11157        Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "MainWindow Show executed");
11158      }
11159      catch (Exception ex)
11160      {
11161        throw;
11162      }
11163      DatabaseInitializer.Initialize();
11164      Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "DatabaseInitializer initialized");
11165      Map.Get<IScreenManager>().SwitchToLogin();
11166      Logger.WriteInfo(typeof (AppVM), "OnStartUp()", "?????????? ????????. ?????????? ????????????????");
11167    }
11168
11169    public void LogIn()
11170    {
11171      Logger.WriteInfo(typeof (AppVM), "LogOut()", "???? ????????????...");
11172      this.LoginState = LoginState.Done;
11173      if (this.IsNewAppVersionAvailable())
11174        return;
11175      this.ShowMainWindow();
11176    }
11177
11178    public void ShowMainWindow()
11179    {
11180      Map.Get<IScreenManager>().SwitchToMain();
11181      Map.Get<IAppTray>().Refresh();
11182    }
11183
11184    public void ProcedeLogOut()
11185    {
11186      Logger.WriteInfo(typeof (AppVM), "LogOut()", "????? ???????? ????????????...");
11187      this.LoginState = LoginState.NoLogin;
11188      Map.Get<ISessionManager>().CloseSession();
11189      Map.Get<IScreenManager>().SwitchToLogin();
11190      Map.Get<IAppTray>().Refresh();
11191    }
11192
11193    internal void SetActivePackage(long productId)
11194    {
11195      this._activePackageId = new long?(productId);
11196      IApplicationSettings applicationSettings = Map.Get<IApplicationSettings>();
11197      applicationSettings.ActiveProductId = productId;
11198      applicationSettings.Save();
11199      SessionMonitor.Instance.SetSessionStateToLogon();
11200    }
11201
11202    internal Version GetCurrentAppVersion()
11203    {
11204      return Assembly.GetAssembly(this.GetType()).GetName().Version;
11205    }
11206
11207    private static void InitializeAppVM()
11208    {
11209      lock (AppVM._createLock)
11210      {
11211        if (AppVM._instance != null)
11212          return;
11213        AppVM._instance = new AppVM();
11214      }
11215    }
11216
11217    private void OnNetworkStateChanged(object sender, NetworkStateEventArgs e)
11218    {
11219      Application.Current.Dispatcher.Invoke((Delegate) (() => AppVM.Instance.NetworkState = e.State));
11220    }
11221
11222    private bool IsNewAppVersionAvailable()
11223    {
11224      try
11225      {
11226        string appVersion = Map.Get<ISessionManager>().GetAppVersion();
11227        if (string.IsNullOrEmpty(appVersion))
11228        {
11229          Logger.WriteError((object) this, "IsNewAppVersionAvailable()", "Empty app version from site");
11230          return false;
11231        }
11232        Version appVersionOnSite = new Version(appVersion);
11233        Version currentAppVersion = this.GetCurrentAppVersion();
11234        bool isShowVersionPage = this.GetIsShowVersionPage();
11235        if (!(currentAppVersion != appVersionOnSite))
11236        {
11237          if (!isShowVersionPage)
11238            goto label_6;
11239        }
11240        Map.Get<IScreenManager>().SwitchToNewVersionAvailableWindow(appVersionOnSite, currentAppVersion);
11241        return true;
11242      }
11243      catch (Exception ex)
11244      {
11245        Logger.WriteError((object) this, "CheckAppVersion()", "Error: ", ex);
11246      }
11247label_6:
11248      return false;
11249    }
11250
11251    private bool GetIsShowVersionPage()
11252    {
11253      string str = ConfigurationManager.AppSettings["ShowVersionPage"];
11254      bool result;
11255      if (string.IsNullOrEmpty(str) || !bool.TryParse(str, out result))
11256        return false;
11257      return result;
11258    }
11259  }
11260}
11261?// Decompiled with JetBrains decompiler
11262// Type: WinApp.ViewModel.MainMenu.MainMenuItem
11263// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11264// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11265// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11266
11267using System;
11268using System.Windows.Controls;
11269using Telerik.Windows.Controls;
11270
11271namespace WinApp.ViewModel.MainMenu
11272{
11273  public class MainMenuItem : ViewModelBase
11274  {
11275    private Control _control;
11276    private Func<Control> _createControl;
11277    private string _name;
11278    private bool _isSelected;
11279    private bool _isExpanded;
11280
11281    public string Name
11282    {
11283      get
11284      {
11285        return this._name;
11286      }
11287      private set
11288      {
11289        this._name = value;
11290        this.OnPropertyChanged("Name");
11291      }
11292    }
11293
11294    public Control Control
11295    {
11296      get
11297      {
11298        return this._control ?? (this._control = this._createControl());
11299      }
11300      protected set
11301      {
11302        this._control = value;
11303        this.OnPropertyChanged("Control");
11304      }
11305    }
11306
11307    public bool IsSelected
11308    {
11309      get
11310      {
11311        return this._isSelected;
11312      }
11313      set
11314      {
11315        this._isSelected = value;
11316        this.OnPropertyChanged("IsSelected");
11317      }
11318    }
11319
11320    public bool IsExpanded
11321    {
11322      get
11323      {
11324        return this._isExpanded;
11325      }
11326      set
11327      {
11328        this._isExpanded = value;
11329        this.OnPropertyChanged("IsExpanded");
11330      }
11331    }
11332
11333    public MainMenuItem Parent { get; set; }
11334
11335    public MainMenuItem(string name, Func<Control> createControl)
11336    {
11337      this.\u002Ector();
11338      this._name = name;
11339      this._createControl = createControl;
11340    }
11341  }
11342}
11343?// Decompiled with JetBrains decompiler
11344// Type: WinApp.ViewModel.MainMenu.CaptionMenuItem
11345// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11346// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11347// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11348
11349using System;
11350using System.Collections;
11351using System.Collections.Generic;
11352using System.Windows.Controls;
11353
11354namespace WinApp.ViewModel.MainMenu
11355{
11356  internal class CaptionMenuItem : MainMenuItem, IEnumerable<MainMenuItem>, IEnumerable
11357  {
11358    private readonly List<MainMenuItem> _children = new List<MainMenuItem>();
11359    private string _icon;
11360
11361    public string Icon
11362    {
11363      get
11364      {
11365        return this._icon;
11366      }
11367      private set
11368      {
11369        this._icon = value;
11370        this.OnPropertyChanged("Icon");
11371      }
11372    }
11373
11374    public List<MainMenuItem> Children
11375    {
11376      get
11377      {
11378        return this._children;
11379      }
11380    }
11381
11382    public CaptionMenuItem(string icon, string name, Func<Control> control)
11383      : base(name, control)
11384    {
11385      this._icon = icon;
11386    }
11387
11388    public void Add(MainMenuItem item)
11389    {
11390      item.Parent = (MainMenuItem) this;
11391      this._children.Add(item);
11392    }
11393
11394    public IEnumerator<MainMenuItem> GetEnumerator()
11395    {
11396      return (IEnumerator<MainMenuItem>) this._children.GetEnumerator();
11397    }
11398
11399    IEnumerator IEnumerable.GetEnumerator()
11400    {
11401      return (IEnumerator) this.GetEnumerator();
11402    }
11403  }
11404}
11405?// Decompiled with JetBrains decompiler
11406// Type: WinApp.ViewModel.MainMenu.MainMenuCollection
11407// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11408// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11409// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11410
11411using KairosPlanet.Properties;
11412using System;
11413using System.Collections;
11414using System.Collections.Generic;
11415using System.Windows.Controls;
11416using WinApp.View;
11417
11418namespace WinApp.ViewModel.MainMenu
11419{
11420  internal class MainMenuCollection : IEnumerable<MainMenuItem>, IEnumerable
11421  {
11422    private readonly CaptionMenuItem _services = new CaptionMenuItem("\xF108", Resources.MainMenu_Services, (Func<Control>) (() => (Control) new ServicesUC()));
11423    private readonly CaptionMenuItem _statistics = new CaptionMenuItem("\xF080", Resources.MainMenu_Statistics, (Func<Control>) (() => (Control) new SessionStatisticsUC()))
11424    {
11425      new MainMenuItem(Resources.MainMenu_SessionHistory, (Func<Control>) (() => (Control) new SessionHistoryUC()))
11426    };
11427    private readonly CaptionMenuItem _profile = new CaptionMenuItem("\xF007", Resources.MainMenu_Profile, (Func<Control>) (() => (Control) new PersonalInformationUC()))
11428    {
11429      new MainMenuItem(Resources.MainMenu_ProfileContact, (Func<Control>) (() => (Control) new ContactInformationUC()))
11430    };
11431    private readonly CaptionMenuItem _settings = new CaptionMenuItem("\xF013", Resources.MainMenu_Settings, (Func<Control>) (() => (Control) new SettingsUC()));
11432    private readonly IEnumerable<MainMenuItem> _items;
11433
11434    public CaptionMenuItem Services
11435    {
11436      get
11437      {
11438        return this._services;
11439      }
11440    }
11441
11442    public CaptionMenuItem Statistics
11443    {
11444      get
11445      {
11446        return this._statistics;
11447      }
11448    }
11449
11450    public CaptionMenuItem Profile
11451    {
11452      get
11453      {
11454        return this._profile;
11455      }
11456    }
11457
11458    public CaptionMenuItem Settings
11459    {
11460      get
11461      {
11462        return this._settings;
11463      }
11464    }
11465
11466    public MainMenuCollection()
11467    {
11468      this._items = (IEnumerable<MainMenuItem>) new MainMenuItem[4]
11469      {
11470        (MainMenuItem) this.Services,
11471        (MainMenuItem) this.Statistics,
11472        (MainMenuItem) this.Profile,
11473        (MainMenuItem) this.Settings
11474      };
11475    }
11476
11477    public IEnumerator<MainMenuItem> GetEnumerator()
11478    {
11479      return this._items.GetEnumerator();
11480    }
11481
11482    IEnumerator IEnumerable.GetEnumerator()
11483    {
11484      return (IEnumerator) this.GetEnumerator();
11485    }
11486  }
11487}
11488?// Decompiled with JetBrains decompiler
11489// Type: WinApp.ViewModel.SessionRecordVM
11490// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11491// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11492// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11493
11494using System;
11495using WinApp.Api.Data;
11496
11497namespace WinApp.ViewModel
11498{
11499  public class SessionRecordVM
11500  {
11501    private readonly Statistic _model;
11502
11503    public DateTime StartTime
11504    {
11505      get
11506      {
11507        return this._model.CreatedDate;
11508      }
11509    }
11510
11511    public DateTime? EndTime
11512    {
11513      get
11514      {
11515        return new DateTime?(this._model.CreatedDate + this.Lifetime);
11516      }
11517    }
11518
11519    public TimeSpan Lifetime
11520    {
11521      get
11522      {
11523        return TimeSpan.FromSeconds((double) this._model.Lifetime);
11524      }
11525    }
11526
11527    public bool Actual
11528    {
11529      get
11530      {
11531        return this._model.Actual;
11532      }
11533    }
11534
11535    public string DateString
11536    {
11537      get
11538      {
11539        return this.StartTime.ToShortDateString();
11540      }
11541    }
11542
11543    public string StartTimeString
11544    {
11545      get
11546      {
11547        return this.StartTime.ToShortDateString() + " " + this.StartTime.ToShortTimeString();
11548      }
11549    }
11550
11551    public string EndTimeString
11552    {
11553      get
11554      {
11555        if (this.EndTime.HasValue)
11556          return this.EndTime.Value.ToShortDateString() + " " + this.EndTime.Value.ToShortTimeString();
11557        return string.Empty;
11558      }
11559    }
11560
11561    public string DurationString
11562    {
11563      get
11564      {
11565        return string.Format("{0:HH:mm:ss}", (object) (DateTime.Today + this.Lifetime));
11566      }
11567    }
11568
11569    public SessionRecordVM(Statistic model)
11570    {
11571      this._model = model;
11572    }
11573  }
11574}
11575?// Decompiled with JetBrains decompiler
11576// Type: WinApp.ViewModel.MainWindowVM
11577// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11578// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11579// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11580
11581using Inc.Logging;
11582using IncMap;
11583using System;
11584using System.Diagnostics;
11585using System.Runtime.InteropServices;
11586using System.Threading;
11587using System.Windows;
11588using System.Windows.Controls;
11589using System.Windows.Input;
11590using System.Windows.Interop;
11591using System.Windows.Media;
11592using WinApp.Managers.Interfaces;
11593using WinApp.View;
11594using WinApp.ViewModel.Base;
11595
11596namespace WinApp.ViewModel
11597{
11598  internal class MainWindowVM : ViewModelBase
11599  {
11600    private static int _messageCloseAppCode = 170;
11601    private string _header = "KairosPlanet";
11602    private UserControl _content;
11603    private MainWindow _mainWindow;
11604    private HwndSource _source;
11605
11606    public string Header
11607    {
11608      get
11609      {
11610        return this._header;
11611      }
11612      set
11613      {
11614        this._header = value;
11615        this.OnPropertyChanged("Header");
11616      }
11617    }
11618
11619    public UserControl Content
11620    {
11621      get
11622      {
11623        return this._content;
11624      }
11625      set
11626      {
11627        this._content = value;
11628        this.OnPropertyChanged("Content");
11629      }
11630    }
11631
11632    public ICommand LogOutCommand
11633    {
11634      get
11635      {
11636        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.LogOutCommand), new Action(this.LogOut));
11637      }
11638    }
11639
11640    public ICommand ExitCommand
11641    {
11642      get
11643      {
11644        return this.Commands.GetOrCreateCommand<ICommand>((System.Linq.Expressions.Expression<Func<ICommand>>) (() => this.ExitCommand), new Action(this.Exit));
11645      }
11646    }
11647
11648    public MainWindowVM(MainWindow mainWindow)
11649    {
11650      this._mainWindow = mainWindow;
11651      this._header = "KairosPlanet. " + (object) AppVM.Instance.GetCurrentAppVersion();
11652    }
11653
11654    public void Exit()
11655    {
11656      Logger.WriteInfo(typeof (MainWindowVM), "Exit()", "???????? ??????????...");
11657      Map.Get<IMainWindow>().CloseToTray = false;
11658      Map.Get<ISessionManager>().CloseSession();
11659      Application.Current.Shutdown();
11660      this.CloseProcess();
11661    }
11662
11663    internal void MainWindowLoaded()
11664    {
11665      this._source = PresentationSource.FromVisual((Visual) this._mainWindow) as HwndSource;
11666      this._source.AddHook(new HwndSourceHook(this.WndProc));
11667    }
11668
11669    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
11670    private static extern uint RegisterWindowMessage(string lpString);
11671
11672    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
11673    {
11674      uint num = MainWindowVM.RegisterWindowMessage("KairosPlanetMessage");
11675      if ((long) msg == (long) num)
11676      {
11677        Marshal.PtrToStringAuto(wParam);
11678        if (wParam == new IntPtr(MainWindowVM._messageCloseAppCode))
11679        {
11680          this.Exit();
11681          return IntPtr.Zero;
11682        }
11683        Map.Get<IMainWindow>().Open();
11684      }
11685      return IntPtr.Zero;
11686    }
11687
11688    private void CloseProcess()
11689    {
11690      new Thread(new ThreadStart(this.CloseProcessThread))
11691      {
11692        IsBackground = true
11693      }.Start();
11694    }
11695
11696    private void CloseProcessThread()
11697    {
11698      Thread.Sleep(400);
11699      Process.GetCurrentProcess().Kill();
11700    }
11701
11702    private void LogOut()
11703    {
11704      AppVM.Instance.ProcedeLogOut();
11705    }
11706  }
11707}
11708?// Decompiled with JetBrains decompiler
11709// Type: WinApp.NetworkState
11710// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11711// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11712// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11713
11714namespace WinApp
11715{
11716  internal enum NetworkState
11717  {
11718    None,
11719    NetworkNotFound,
11720    ServerNotFound,
11721    ServerOnline,
11722  }
11723}
11724?// Decompiled with JetBrains decompiler
11725// Type: XamlGeneratedNamespace.GeneratedInternalTypeHelper
11726// Assembly: KairosPlanet, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11727// MVID: 11FB976C-FCD4-4E7B-A3A4-41527B84CA9B
11728// Assembly location: C:\Program Files (x86)\KairosPlanet\KairosPlanet.exe
11729
11730using System;
11731using System.CodeDom.Compiler;
11732using System.ComponentModel;
11733using System.Diagnostics;
11734using System.Globalization;
11735using System.Reflection;
11736using System.Windows.Markup;
11737
11738namespace XamlGeneratedNamespace
11739{
11740  [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
11741  [EditorBrowsable(EditorBrowsableState.Never)]
11742  [DebuggerNonUserCode]
11743  public sealed class GeneratedInternalTypeHelper : InternalTypeHelper
11744  {
11745    protected override object CreateInstance(Type type, CultureInfo culture)
11746    {
11747      return Activator.CreateInstance(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, (Binder) null, (object[]) null, culture);
11748    }
11749
11750    protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture)
11751    {
11752      return propertyInfo.GetValue(target, BindingFlags.Default, (Binder) null, (object[]) null, culture);
11753    }
11754
11755    protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture)
11756    {
11757      propertyInfo.SetValue(target, value, BindingFlags.Default, (Binder) null, (object[]) null, culture);
11758    }
11759
11760    protected override Delegate CreateDelegate(Type delegateType, object target, string handler)
11761    {
11762      return (Delegate) target.GetType().InvokeMember("_CreateDelegate", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, (Binder) null, target, new object[2]
11763      {
11764        (object) delegateType,
11765        (object) handler
11766      }, (CultureInfo) null);
11767    }
11768
11769    protected override void AddEventHandler(EventInfo eventInfo, object target, Delegate handler)
11770    {
11771      eventInfo.AddEventHandler(target, handler);
11772    }
11773  }
11774}
11775?using System;
11776using System.Reflection;
11777using System.Runtime.CompilerServices;
11778using System.Runtime.InteropServices;
11779using System.Windows;
11780
11781[assembly: Extension]
11782[assembly: AssemblyTitle("KairosPlanet")]
11783[assembly: AssemblyDescription("")]
11784[assembly: AssemblyProduct("KairosPlanet")]
11785[assembly: InternalsVisibleTo("KairosPlanet.Tests")]
11786[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
11787[assembly: ThemeInfo(ResourceDictionaryLocation.None, ResourceDictionaryLocation.SourceAssembly)]
11788[assembly: AssemblyConfiguration("")]
11789[assembly: AssemblyCompany("Kairos Technologies Ltd")]
11790[assembly: AssemblyCopyright("Copyright © Kairos Technologies 2014")]
11791[assembly: AssemblyTrademark("")]
11792[assembly: ComVisible(false)]
11793[assembly: CLSCompliant(false)]
11794[assembly: AssemblyFileVersion("1.0.18.651")]
11795[assembly: AssemblyInformationalVersion("1.0.18.651")]
11796[assembly: AssemblyVersion("1.0.18.651")]
11797?// Decompiled with JetBrains decompiler
11798// Type: WinApp.Data.Helpers.LoginResponce
11799// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11800// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11801// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11802
11803using WinApp.Data.Model;
11804
11805namespace WinApp.Data.Helpers
11806{
11807  public struct LoginResponce
11808  {
11809    public static LoginResponce NoResponce = new LoginResponce(LoginResult.NoResponce, (Man) null);
11810    public static LoginResponce WrongInput = new LoginResponce(LoginResult.WrongInput, (Man) null);
11811    public static LoginResponce UserDeleted = new LoginResponce(LoginResult.UserDeleted, (Man) null);
11812
11813    public Man UserInfo { get; private set; }
11814
11815    public LoginResult Result { get; private set; }
11816
11817    private LoginResponce(LoginResult result, Man userInfo = null)
11818    {
11819      this = new LoginResponce();
11820      this.Result = result;
11821      this.UserInfo = userInfo;
11822    }
11823
11824    public static LoginResponce Pass(Man user)
11825    {
11826      return new LoginResponce(LoginResult.Pass, user);
11827    }
11828  }
11829}
11830?// Decompiled with JetBrains decompiler
11831// Type: WinApp.Data.Helpers.DateTimeExtention
11832// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11833// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11834// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11835
11836using System;
11837
11838namespace WinApp.Data.Helpers
11839{
11840  public static class DateTimeExtention
11841  {
11842    public static DateTime ToDateTime(this long ticks)
11843    {
11844      return new DateTime(ticks);
11845    }
11846  }
11847}
11848?// Decompiled with JetBrains decompiler
11849// Type: WinApp.Data.Helpers.LoginResult
11850// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11851// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11852// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11853
11854namespace WinApp.Data.Helpers
11855{
11856  public enum LoginResult
11857  {
11858    NoResponce,
11859    WrongInput,
11860    UserDeleted,
11861    Pass,
11862  }
11863}
11864?// Decompiled with JetBrains decompiler
11865// Type: WinApp.Data.Helpers.StringUtil
11866// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11867// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11868// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11869
11870namespace WinApp.Data.Helpers
11871{
11872  public static class StringUtil
11873  {
11874    public static bool IsNullOrWhiteSpace(this string str)
11875    {
11876      return str == null || str.Trim().Length == 0;
11877    }
11878  }
11879}
11880?// Decompiled with JetBrains decompiler
11881// Type: WinApp.Data.Helpers.TimeSpanExtention
11882// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11883// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11884// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11885
11886using System;
11887
11888namespace WinApp.Data.Helpers
11889{
11890  public static class TimeSpanExtention
11891  {
11892    public static TimeSpan TrimToSeconds(this TimeSpan span)
11893    {
11894      return TimeSpan.FromSeconds((double) (span.Ticks / 10000000L));
11895    }
11896
11897    public static TimeSpan ToTimeSpan(this long ticks)
11898    {
11899      return new TimeSpan(ticks);
11900    }
11901
11902    public static string TotalTimeString(this TimeSpan timeSpan, string format)
11903    {
11904      long num1 = (long) timeSpan.TotalHours;
11905      long num2 = (long) timeSpan.TotalMinutes - num1 * 60L;
11906      long num3 = (long) timeSpan.TotalSeconds - num1 * 3600L - num2 * 60L;
11907      return string.Format(format, (object) num1, (object) num2, (object) num3);
11908    }
11909  }
11910}
11911?// Decompiled with JetBrains decompiler
11912// Type: WinApp.Data.Helpers.AppData
11913// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11914// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11915// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11916
11917using System;
11918using System.IO;
11919
11920namespace WinApp.Data.Helpers
11921{
11922  public static class AppData
11923  {
11924    public static string Path
11925    {
11926      get
11927      {
11928        DirectoryInfo directoryInfo = new DirectoryInfo(System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "WinApp"));
11929        if (!directoryInfo.Exists)
11930        {
11931          directoryInfo.Create();
11932          directoryInfo.Refresh();
11933        }
11934        return directoryInfo.FullName;
11935      }
11936    }
11937  }
11938}
11939?// Decompiled with JetBrains decompiler
11940// Type: WinApp.Data.Security.Cryptography
11941// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11942// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
11943// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
11944
11945using Inc.Logging;
11946using System;
11947using System.Collections.Generic;
11948using System.Linq;
11949using System.Security.Cryptography;
11950using System.Text;
11951
11952namespace WinApp.Data.Security
11953{
11954  public static class Cryptography
11955  {
11956    private static readonly byte[] _entropy = Encoding.Unicode.GetBytes("WinApp Cryptography Data Salt");
11957
11958    public static byte[] GetSha1Hash(this string message)
11959    {
11960      return new SHA1CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(message));
11961    }
11962
11963    public static bool CheckHash(this byte[] h1, byte[] h2)
11964    {
11965      return Enumerable.SequenceEqual<byte>((IEnumerable<byte>) h1, (IEnumerable<byte>) h2);
11966    }
11967
11968    public static string GetSha1HashText(this string message, int length)
11969    {
11970      return Convert.ToBase64String(Cryptography.GetSha1Hash(message)).Substring(0, length);
11971    }
11972
11973    public static string ProtectedUserData(string data)
11974    {
11975      if (string.IsNullOrEmpty(data))
11976        return string.Empty;
11977      return Convert.ToBase64String(ProtectedData.Protect(Encoding.Unicode.GetBytes(data), Cryptography._entropy, DataProtectionScope.CurrentUser));
11978    }
11979
11980    public static string UnprotectUserData(string protectedData)
11981    {
11982      try
11983      {
11984        if (string.IsNullOrEmpty(protectedData))
11985          return string.Empty;
11986        return Encoding.Unicode.GetString(ProtectedData.Unprotect(Convert.FromBase64String(protectedData), Cryptography._entropy, DataProtectionScope.CurrentUser));
11987      }
11988      catch (Exception ex)
11989      {
11990        Logger.WriteError(typeof (Cryptography), "UnprotectUserData", "?? ??????? ????????????? ?????? ???????? ????????????", ex);
11991        return (string) null;
11992      }
11993    }
11994  }
11995}
11996?// Decompiled with JetBrains decompiler
11997// Type: WinApp.Data.Model.Man
11998// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
11999// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12000// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12001
12002using System.Runtime.Serialization;
12003
12004namespace WinApp.Data.Model
12005{
12006  [DataContract]
12007  public class Man
12008  {
12009    [DataMember(Name = "user_id")]
12010    public long Id { get; set; }
12011
12012    [DataMember(Name = "user_name")]
12013    public string Name { get; set; }
12014
12015    [DataMember(Name = "country")]
12016    public string Country { get; set; }
12017
12018    [DataMember(Name = "email")]
12019    public string Email { get; set; }
12020
12021    [DataMember(Name = "gender_id")]
12022    public int Gender { get; set; }
12023
12024    [DataMember(Name = "birth_date")]
12025    public string BirthDate { get; set; }
12026
12027    [DataMember(Name = "created_date")]
12028    public string CreatedDate { get; set; }
12029
12030    [DataMember(Name = "phone_number_main")]
12031    public string PhoneNumber { get; set; }
12032
12033    [DataMember(Name = "user_status_id")]
12034    public int UserStatus { get; set; }
12035  }
12036}
12037?// Decompiled with JetBrains decompiler
12038// Type: WinApp.Data.Model.ProductAttributes
12039// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12040// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12041// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12042
12043using System.Runtime.Serialization;
12044
12045namespace WinApp.Data.Model
12046{
12047  [DataContract]
12048  public class ProductAttributes
12049  {
12050    [DataMember(Name = "discSpace")]
12051    public int DiscSpace { get; set; }
12052
12053    [DataMember(Name = "timeOnline")]
12054    public string TimeOnline { get; set; }
12055
12056    [DataMember(Name = "basicIncome")]
12057    public string BasicIncome { get; set; }
12058
12059    [DataMember(Name = "basicIncomePeriod")]
12060    public string BasicIncomePeriod { get; set; }
12061
12062    [DataMember(Name = "profit")]
12063    public string Profit { get; set; }
12064
12065    [DataMember(Name = "investmentPeriod")]
12066    public string InvestmentPeriod { get; set; }
12067
12068    [DataMember(Name = "available")]
12069    public string Available { get; set; }
12070
12071    [DataMember(Name = "start")]
12072    public string Start { get; set; }
12073  }
12074}
12075?// Decompiled with JetBrains decompiler
12076// Type: WinApp.Data.Model.SessionRecord
12077// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12078// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12079// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12080
12081using NPoco;
12082using System;
12083
12084namespace WinApp.Data.Model
12085{
12086  [TableName("SessionRecord")]
12087  public class SessionRecord : Entity
12088  {
12089    [Ignore]
12090    public DateTime StartTime { get; set; }
12091
12092    public long StartInt
12093    {
12094      get
12095      {
12096        return this.StartTime.Ticks;
12097      }
12098      set
12099      {
12100        this.StartTime = new DateTime(value);
12101      }
12102    }
12103
12104    [Ignore]
12105    public DateTime EndTime { get; set; }
12106
12107    public long EndInt
12108    {
12109      get
12110      {
12111        return this.EndTime.Ticks;
12112      }
12113      set
12114      {
12115        this.EndTime = new DateTime(value);
12116      }
12117    }
12118  }
12119}
12120?// Decompiled with JetBrains decompiler
12121// Type: WinApp.Data.Model.ModuleState
12122// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12123// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12124// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12125
12126namespace WinApp.Data.Model
12127{
12128  public enum ModuleState
12129  {
12130    Buy,
12131    Install,
12132    Installed,
12133    InstalledAndActivated,
12134    ValidityCompleted,
12135    Blocked,
12136    Order,
12137  }
12138}
12139?// Decompiled with JetBrains decompiler
12140// Type: WinApp.Data.Model.Purchase
12141// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12142// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12143// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12144
12145using System;
12146using System.Runtime.Serialization;
12147
12148namespace WinApp.Data.Model
12149{
12150  [DataContract]
12151  public class Purchase
12152  {
12153    private string _dateString;
12154
12155    [DataMember(Name = "id")]
12156    public long Id { get; set; }
12157
12158    [DataMember(Name = "buyer_user_id")]
12159    public long BuyerUserId { get; set; }
12160
12161    [DataMember(Name = "product_id")]
12162    public long ProductId { get; set; }
12163
12164    [DataMember(Name = "price")]
12165    public double Price { get; set; }
12166
12167    [DataMember(Name = "status")]
12168    public int Status { get; set; }
12169
12170    [DataMember(Name = "terms")]
12171    public string Terms { get; set; }
12172
12173    [DataMember(Name = "package_status")]
12174    public int PackageStatus { get; set; }
12175
12176    public DateTime? Date { get; set; }
12177
12178    [DataMember(Name = "date")]
12179    public string DateString
12180    {
12181      get
12182      {
12183        return this._dateString;
12184      }
12185      set
12186      {
12187        this._dateString = value;
12188        this.Date = this._dateString == null ? new DateTime?() : new DateTime?(DateTime.Parse(this._dateString));
12189      }
12190    }
12191
12192    public override bool Equals(object purchase)
12193    {
12194      return this.Id == ((Purchase) purchase).Id;
12195    }
12196  }
12197}
12198?// Decompiled with JetBrains decompiler
12199// Type: WinApp.Data.Model.Entity
12200// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12201// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12202// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12203
12204using NPoco;
12205
12206namespace WinApp.Data.Model
12207{
12208  [PrimaryKey("Id", AutoIncrement = true)]
12209  public class Entity
12210  {
12211    private long _id;
12212
12213    [Ignore]
12214    public bool IsNew { get; protected set; }
12215
12216    public long Id
12217    {
12218      get
12219      {
12220        return this._id;
12221      }
12222      set
12223      {
12224        this._id = value;
12225        this.IsNew = false;
12226      }
12227    }
12228
12229    protected Entity()
12230    {
12231      this.IsNew = true;
12232    }
12233
12234    public virtual Entity Clone()
12235    {
12236      return (Entity) this.MemberwiseClone();
12237    }
12238  }
12239}
12240?// Decompiled with JetBrains decompiler
12241// Type: WinApp.Data.Model.ModuleInfo
12242// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12243// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12244// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12245
12246using System.Runtime.Serialization;
12247
12248namespace WinApp.Data.Model
12249{
12250  [DataContract]
12251  public class ModuleInfo
12252  {
12253    [DataMember]
12254    public long Id { get; set; }
12255
12256    [DataMember]
12257    public long ProductId { get; set; }
12258
12259    [DataMember]
12260    public string Title { get; set; }
12261
12262    [DataMember]
12263    public string Version { get; set; }
12264
12265    [DataMember]
12266    public string Description { get; set; }
12267
12268    [DataMember]
12269    public string Filename { get; set; }
12270
12271    [DataMember]
12272    public string Url { get; set; }
12273  }
12274}
12275?// Decompiled with JetBrains decompiler
12276// Type: WinApp.Data.Model.Module
12277// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12278// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12279// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12280
12281using NPoco;
12282
12283namespace WinApp.Data.Model
12284{
12285  [TableName("Module")]
12286  public class Module : Entity
12287  {
12288    public int State { get; set; }
12289
12290    public long ProductId { get; set; }
12291
12292    [Ignore]
12293    public ModuleState StateEnum
12294    {
12295      get
12296      {
12297        return (ModuleState) this.State;
12298      }
12299      set
12300      {
12301        this.State = (int) value;
12302      }
12303    }
12304  }
12305}
12306?// Decompiled with JetBrains decompiler
12307// Type: WinApp.Data.Model.Product
12308// Assembly: KairosPlanet.Data, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12309// MVID: 146F38A9-3288-4859-BC9A-322D8E703D1E
12310// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Data.dll
12311
12312using System.Runtime.Serialization;
12313
12314namespace WinApp.Data.Model
12315{
12316  [DataContract]
12317  public class Product
12318  {
12319    [DataMember(Name = "category_id")]
12320    public long CategoryId { get; set; }
12321
12322    [DataMember(Name = "created_date")]
12323    public string CreatedDate { get; set; }
12324
12325    [DataMember(Name = "creator_id")]
12326    public long CreatorId { get; set; }
12327
12328    [DataMember(Name = "description")]
12329    public string Description { get; set; }
12330
12331    [DataMember(Name = "id")]
12332    public long Id { get; set; }
12333
12334    [DataMember(Name = "image_url")]
12335    public string ImageUrl { get; set; }
12336
12337    [DataMember(Name = "price")]
12338    public double Price { get; set; }
12339
12340    [DataMember(Name = "product_url")]
12341    public string ProductUrl { get; set; }
12342
12343    [DataMember(Name = "status")]
12344    public int Status { get; set; }
12345
12346    [DataMember(Name = "title")]
12347    public string Title { get; set; }
12348
12349    [DataMember(Name = "type")]
12350    public int Type { get; set; }
12351
12352    [DataMember(Name = "attributes")]
12353    public ProductAttributes Attributes { get; set; }
12354  }
12355}
12356?using System;
12357using System.Reflection;
12358using System.Runtime.CompilerServices;
12359using System.Runtime.InteropServices;
12360
12361[assembly: AssemblyInformationalVersion("1.0.18.651")]
12362[assembly: AssemblyFileVersion("1.0.18.651")]
12363[assembly: AssemblyProduct("KairosPlanet.Data")]
12364[assembly: InternalsVisibleTo("KairosPlanet")]
12365[assembly: CLSCompliant(false)]
12366[assembly: Extension]
12367[assembly: AssemblyTitle("KairosPlanet.Data")]
12368[assembly: AssemblyDescription("")]
12369[assembly: AssemblyConfiguration("")]
12370[assembly: ComVisible(false)]
12371[assembly: InternalsVisibleTo("KairosPlanet.Tests")]
12372[assembly: Guid("6e9f63c9-13ed-4f02-acb0-f8bf5302b813")]
12373[assembly: InternalsVisibleTo("KairosPlanet.Service")]
12374[assembly: AssemblyCompany("Kairos Technologies Ltd")]
12375[assembly: AssemblyCopyright("Copyright © Kairos Technologies 2014")]
12376[assembly: AssemblyTrademark("")]
12377[assembly: AssemblyVersion("1.0.18.651")]
12378?// Decompiled with JetBrains decompiler
12379// Type: WinApp.Service.ServiceBootstrapper
12380// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12381// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12382// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12383
12384using Inc.Logging;
12385using IncMap;
12386using WinApp.Data.Helpers;
12387using WinApp.Data.Model;
12388using WinApp.Service.Core;
12389using WinApp.Service.Repository;
12390using WinApp.Service.Repository.Interface;
12391
12392namespace WinApp.Service
12393{
12394  public class ServiceBootstrapper
12395  {
12396    public static void Bootstrap()
12397    {
12398      Logger.WriteInfo(typeof (ServiceBootstrapper), "Bootstrap()", "????????????? ?????????? Bootstrapper...");
12399      Map.Inject<IDatabaseManager>((IDatabaseManager) new SQLiteDatabaseManager(AppData.Path + "\\KairosPlanet.db"));
12400      ServiceBootstrapper.MapEntityServices<SessionRecord, ISessionRecordRepository>((ISessionRecordRepository) new SessionRecordRepository());
12401      ServiceBootstrapper.MapEntityServices<Module, IModuleRepository>((IModuleRepository) new ModuleRepository());
12402      Logger.WriteInfo(typeof (ServiceBootstrapper), "Bootstrap()", "????????? Bootstrapper ??????? ???????????????");
12403    }
12404
12405    private static void MapEntityServices<T, TRepo>(TRepo repository) where T : Entity where TRepo : class, IRepository<T>
12406    {
12407      Map.Inject<TRepo>(repository);
12408      Map.Route<IRepository<T>, TRepo>();
12409    }
12410  }
12411}
12412?// Decompiled with JetBrains decompiler
12413// Type: WinApp.Service.Core.DatabaseInitializer
12414// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12415// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12416// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12417
12418using Inc.Logging;
12419using IncMap;
12420using NPoco;
12421using System;
12422using System.Data;
12423using System.Data.SQLite;
12424using System.IO;
12425
12426namespace WinApp.Service.Core
12427{
12428  public class DatabaseInitializer : SqlDatabaseInitializer
12429  {
12430    private static readonly object _dbLockObj = new object();
12431    private static readonly DatabaseInitializer _instance = new DatabaseInitializer();
12432    private readonly SqlDatabaseInitializer.DbUpdate _u0 = new SqlDatabaseInitializer.DbUpdate(1L)
12433    {
12434      Comment = "Initial update",
12435      Sql = "\r\n                CREATE TABLE [SessionRecord](\r\n                    [Id]            [integer] PRIMARY KEY AUTOINCREMENT,\r\n                    [StartInt]      [integer] NOT NULL,\r\n                    [EndInt]        [integer] NOT NULL\r\n                );"
12436    };
12437    private readonly SqlDatabaseInitializer.DbUpdate _u1 = new SqlDatabaseInitializer.DbUpdate(2L)
12438    {
12439      Comment = "Initial update 2",
12440      Sql = "\r\n                CREATE TABLE [Module](\r\n                    [Id]            [integer] PRIMARY KEY,\r\n                    [ProductId]     [integer] NOT NULL,\r\n                    [State]         [integer] NOT NULL DEFAULT 0\r\n                );"
12441    };
12442
12443    public static int UpdateCount
12444    {
12445      get
12446      {
12447        return DatabaseInitializer._instance.UpdateSequence.Length;
12448      }
12449    }
12450
12451    protected override Database Database
12452    {
12453      get
12454      {
12455        return new Database((IDbConnection) new SQLiteConnection(Map.Get<IDatabaseManager>().ConnectionString), DatabaseType.SQLite);
12456      }
12457    }
12458
12459    protected override SqlDatabaseInitializer.DbUpdate[] UpdateSequence
12460    {
12461      get
12462      {
12463        return new SqlDatabaseInitializer.DbUpdate[2]
12464        {
12465          this._u0,
12466          this._u1
12467        };
12468      }
12469    }
12470
12471    private DatabaseInitializer()
12472    {
12473    }
12474
12475    public static void Initialize()
12476    {
12477      lock (DatabaseInitializer._dbLockObj)
12478      {
12479        Logger.WriteInfo(typeof (DatabaseInitializer), "Initialize()", "????????????? ???? ??????...");
12480        try
12481        {
12482          DatabaseInitializer.CreateDatabase();
12483          DatabaseInitializer.CreateDatabaseSystemTable();
12484          DatabaseInitializer.MakeDatabaseChanges();
12485          Logger.WriteInfo(typeof (DatabaseInitializer), "Initialize()", "???? ?????? ??????? ????????????????");
12486        }
12487        catch (Exception exception_0)
12488        {
12489          Logger.WriteError(typeof (DatabaseInitializer), "Initialize()", "?????? ??? ????????????? ???? ??????", exception_0);
12490        }
12491      }
12492    }
12493
12494    public static void CreateDatabase()
12495    {
12496      lock (DatabaseInitializer._dbLockObj)
12497      {
12498        try
12499        {
12500          Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???????? ??????? ????? ???? ??????...");
12501          if (File.Exists(Map.Get<IDatabaseManager>().DbPath))
12502          {
12503            Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???? ???? ?????? ??????");
12504          }
12505          else
12506          {
12507            Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???? ???? ?????? ?? ??????. ??????? ???? ??????...");
12508            Map.Get<IDatabaseManager>().CreateDatabase();
12509            Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???? ?????? ??????? ???????!");
12510          }
12511        }
12512        catch (Exception exception_0)
12513        {
12514          Logger.WriteError(typeof (DatabaseInitializer), "CreateDatabase()", "?????? ??? ???????? ???? ??????", exception_0);
12515        }
12516      }
12517    }
12518
12519    private static void CreateDatabaseSystemTable()
12520    {
12521      lock (DatabaseInitializer._dbLockObj)
12522      {
12523        try
12524        {
12525          DatabaseInitializer._instance.CreateSystemTable();
12526        }
12527        catch (Exception exception_0)
12528        {
12529          Logger.WriteError(typeof (DatabaseInitializer), "CreateDatabaseSystemTable()", "?????? ??? ???????? ????????? ??????? ???? ??????", exception_0);
12530        }
12531      }
12532    }
12533
12534    private static void MakeDatabaseChanges()
12535    {
12536      lock (DatabaseInitializer._dbLockObj)
12537      {
12538        Logger.WriteInfo(typeof (DatabaseInitializer), "MakeDatabaseChanges()", "?????????? ???? ??????...");
12539        try
12540        {
12541          DatabaseInitializer._instance.MakeChanges();
12542          Logger.WriteInfo(typeof (DatabaseInitializer), "MakeDatabaseChanges()", "?????????? ???? ?????? ?????? ???????");
12543        }
12544        catch (Exception exception_0)
12545        {
12546          Logger.WriteError(typeof (DatabaseInitializer), "MakeDatabaseChanges()", "?????? ??? ?????????? ?????????? ? ???? ??????", exception_0);
12547        }
12548      }
12549    }
12550  }
12551}
12552?// Decompiled with JetBrains decompiler
12553// Type: WinApp.Service.Core.SqlDatabaseInitializer
12554// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12555// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12556// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12557
12558using Inc.Logging;
12559using NPoco;
12560using System;
12561using System.Collections.Generic;
12562using System.Data.Common;
12563using System.Linq;
12564
12565namespace WinApp.Service.Core
12566{
12567  public abstract class SqlDatabaseInitializer
12568  {
12569    private const string SYSTEM_TABLE_NAME = "_systemInfo";
12570
12571    protected abstract Database Database { get; }
12572
12573    protected abstract SqlDatabaseInitializer.DbUpdate[] UpdateSequence { get; }
12574
12575    internal static string GetCreateSystemTableSqlCommand()
12576    {
12577      return string.Format("\r\n                    CREATE TABLE [{0}](\r\n                        [id] [integer] NOT NULL,\r\n                        [Date] [integer] NOT NULL,\r\n                        [Description] [text] NULL\r\n                    );\r\n                ", (object) "_systemInfo");
12578    }
12579
12580    protected virtual void MakeChanges()
12581    {
12582      using (Database database = this.Database)
12583      {
12584        Logger.WriteInfo(typeof (SqlDatabaseInitializer), "MakeChanges()", "????????? ??????? ?????? ???? ??????...");
12585        IEnumerable<long> source;
12586        try
12587        {
12588          source = (IEnumerable<long>) Enumerable.ToArray<long>(Enumerable.Select<SqlDatabaseInitializer.IdContainer, long>((IEnumerable<SqlDatabaseInitializer.IdContainer>) database.Fetch<SqlDatabaseInitializer.IdContainer>(string.Format("SELECT [Id] FROM [{0}];", (object) "_systemInfo"), new object[0]), (Func<SqlDatabaseInitializer.IdContainer, long>) (x => x.Id)));
12589          Logger.WriteInfo(typeof (SqlDatabaseInitializer), "MakeChanges()", "?????? ???? ?????? ???????? ???????");
12590        }
12591        catch (DbException ex)
12592        {
12593          Logger.WriteWarning(typeof (SqlDatabaseInitializer), "MakeChanges()", "?????? ??? ????????? ?????? ???? ??????. ???????? ????????? ??????? ???????????");
12594          source = (IEnumerable<long>) new long[0];
12595        }
12596        Logger.WriteInfo(typeof (SqlDatabaseInitializer), "MakeChanges()", "??????? ?????? ???? ?????? ????? ?????????? ??????????: " + (object) Enumerable.Count<long>(source));
12597        Logger.WriteInfo(typeof (SqlDatabaseInitializer), "MakeChanges()", "???????? ? ?????????? ?????????? ???? ??????...");
12598        foreach (SqlDatabaseInitializer.DbUpdate dbUpdate in this.UpdateSequence)
12599        {
12600          SqlDatabaseInitializer.DbUpdate update = dbUpdate;
12601          if (Enumerable.All<long>(source, (Func<long, bool>) (x => x != update.Id)))
12602          {
12603            if (update.DropAll)
12604            {
12605              Logger.WriteWarning(typeof (SqlDatabaseInitializer), "MakeChanges()", string.Format("??? ?????????? '{0}' ?????????? ???????? ???? ??????"));
12606              this.DropTables(database);
12607              this.CreateSystemTable();
12608            }
12609            database.BeginTransaction();
12610            Logger.WriteInfo(typeof (SqlDatabaseInitializer), "MakeChanges()", string.Format("?????????? ?????????? ?? ??????: {0} ({1})", (object) update.Id, (object) update.Comment));
12611            this.Execute(database, update.Sql);
12612            this.CommitVersion(database, update);
12613            database.CompleteTransaction();
12614            this.OnUpdate(update);
12615            Logger.WriteInfo(typeof (SqlDatabaseInitializer), "MakeChanges()", string.Format("??????? ????????? ?????????? ???? ?????? ?? ??????: {0} ({1})", (object) update.Id, (object) update.Comment));
12616          }
12617        }
12618      }
12619    }
12620
12621    protected virtual void Execute(Database db, string command)
12622    {
12623      try
12624      {
12625        db.Execute(command, new object[0]);
12626      }
12627      catch (DbException ex)
12628      {
12629        Logger.WriteError(typeof (SqlDatabaseInitializer), "Execute()", "?????? ??? ?????????? SQL ???????", (Exception) ex);
12630      }
12631    }
12632
12633    protected virtual void OnUpdate(SqlDatabaseInitializer.DbUpdate update)
12634    {
12635    }
12636
12637    protected void CreateSystemTable()
12638    {
12639      Logger.WriteInfo(typeof (DatabaseInitializer), "CreateSystemTable()", "???????? ????????? ??????? ? ???? ??????...");
12640      this.Execute(this.Database, SqlDatabaseInitializer.GetCreateSystemTableSqlCommand());
12641      Logger.WriteInfo(typeof (DatabaseInitializer), "CreateSystemTable()", "????????? ??????? ??????? ???????!");
12642    }
12643
12644    private void CommitVersion(Database db, SqlDatabaseInitializer.DbUpdate update)
12645    {
12646      Logger.WriteInfo(typeof (DatabaseInitializer), "CommitVersion()", "?????????? ?????? ???? ??????...");
12647      db.Execute(new Sql(string.Format("INSERT INTO [{0}] ([Id], [Date], [Description]) VALUES (@0, @1, @2);", (object) "_systemInfo"), new object[3]
12648      {
12649        (object) update.Id,
12650        (object) DateTime.Now.ToBinary(),
12651        (object) update.Comment
12652      }));
12653      Logger.WriteInfo(typeof (DatabaseInitializer), "CommitVersion()", "?????? ???? ?????? ??????? ?????????");
12654    }
12655
12656    private void DropTables(Database db)
12657    {
12658      Logger.WriteInfo(typeof (SqlDatabaseInitializer), "DropTables()", "???????? ???? ??????...");
12659      db.Execute("DROP TABLE [SessionRecords]", new object[0]);
12660      Logger.WriteInfo(typeof (SqlDatabaseInitializer), "DropTables()", "??? ??????? ???????");
12661    }
12662
12663    protected class DbUpdate
12664    {
12665      public long Id { get; private set; }
12666
12667      public bool DropAll { get; set; }
12668
12669      public string Sql { get; set; }
12670
12671      public string Comment { get; set; }
12672
12673      public string Hash { get; set; }
12674
12675      public DbUpdate(long id)
12676      {
12677        this.Id = id;
12678      }
12679    }
12680
12681    private class IdContainer
12682    {
12683      public long Id { get; set; }
12684    }
12685  }
12686}
12687?// Decompiled with JetBrains decompiler
12688// Type: WinApp.Service.Core.IDatabaseManager
12689// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12690// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12691// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12692
12693using System.Data;
12694
12695namespace WinApp.Service.Core
12696{
12697  public interface IDatabaseManager
12698  {
12699    string DbPath { get; }
12700
12701    string ConnectionString { get; }
12702
12703    IDbConnection GetNewDbConnection();
12704
12705    void CreateDatabase();
12706
12707    void DeleteDatabase();
12708  }
12709}
12710?// Decompiled with JetBrains decompiler
12711// Type: WinApp.Service.Core.SQLiteDatabaseManager
12712// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12713// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12714// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12715
12716using Inc.Logging;
12717using System;
12718using System.Data;
12719using System.Data.SQLite;
12720using System.IO;
12721
12722namespace WinApp.Service.Core
12723{
12724  public class SQLiteDatabaseManager : IDatabaseManager
12725  {
12726    private string _connectionStringTemplate = "Data Source={0};Version=3;";
12727    private string _dbPath;
12728    private string _connectionString;
12729
12730    public string DbPath
12731    {
12732      get
12733      {
12734        return this._dbPath;
12735      }
12736    }
12737
12738    public string ConnectionString
12739    {
12740      get
12741      {
12742        return this._connectionString ?? (this._connectionString = string.Format(this._connectionStringTemplate, (object) this._dbPath));
12743      }
12744    }
12745
12746    public SQLiteDatabaseManager(string path)
12747    {
12748      this._dbPath = path;
12749    }
12750
12751    public IDbConnection GetNewDbConnection()
12752    {
12753      return (IDbConnection) new SQLiteConnection(this.ConnectionString);
12754    }
12755
12756    public void CreateDatabase()
12757    {
12758      if (File.Exists(this.DbPath))
12759        return;
12760      Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???????? ???? ??????...");
12761      try
12762      {
12763        string directoryName = Path.GetDirectoryName(this.DbPath);
12764        if (directoryName != null)
12765        {
12766          if (!Directory.Exists(directoryName))
12767            Directory.CreateDirectory(directoryName);
12768        }
12769        try
12770        {
12771          SQLiteConnection.CreateFile(this.DbPath);
12772          Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???? ?????? ??????? ???????");
12773        }
12774        catch (Exception ex)
12775        {
12776          Logger.WriteWarning(typeof (DatabaseInitializer), "CreateDatabase()", "?????? ??? ???????? ???? ??????");
12777          Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???????? SqlLite Pool...");
12778          SQLiteConnection.ClearAllPools();
12779          Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "SqlLite Pool ??????");
12780          SQLiteConnection.CreateFile(this.DbPath);
12781          Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???? ?????? ??????? ???????");
12782        }
12783      }
12784      catch (Exception ex)
12785      {
12786        Logger.WriteError(typeof (DatabaseInitializer), "CreateDatabase()", "?????? ??? ???????? ???? ??????", ex);
12787      }
12788    }
12789
12790    public void DeleteDatabase()
12791    {
12792      if (!File.Exists(this.DbPath))
12793        return;
12794      Logger.WriteInfo(typeof (DatabaseInitializer), "DeleteDatabase()", "???????? ???? ??????...");
12795      try
12796      {
12797        Logger.WriteInfo(typeof (DatabaseInitializer), "CreateDatabase()", "???????? SqlLite Pool...");
12798        SQLiteConnection.ClearAllPools();
12799        Logger.WriteInfo(typeof (DatabaseInitializer), "DeleteDatabase()", "SqlLite Pool ??????");
12800        this.DeleteDatabaseFiles();
12801      }
12802      catch (Exception ex)
12803      {
12804        Logger.WriteError(typeof (DatabaseInitializer), "DeleteDatabase()", "?? ??????? ??????? ???? ??????", ex);
12805      }
12806    }
12807
12808    private void DeleteDatabaseFiles()
12809    {
12810      File.Delete(this.DbPath);
12811      string path = Path.Combine(Path.GetDirectoryName(this.DbPath), Path.GetFileNameWithoutExtension(this.DbPath) + "_log.ldf");
12812      if (File.Exists(path))
12813        File.Delete(path);
12814      Logger.WriteInfo(typeof (DatabaseInitializer), "DeleteDatabaseFiles()", "???? ?????? ??????? ???????");
12815    }
12816  }
12817}
12818?// Decompiled with JetBrains decompiler
12819// Type: WinApp.Service.Repository.Repository`1
12820// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12821// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12822// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12823
12824using IncMap;
12825using NPoco;
12826using System.Collections.Generic;
12827using System.Data;
12828using System.Data.SQLite;
12829using System.Linq;
12830using WinApp.Data.Model;
12831using WinApp.Service.Core;
12832using WinApp.Service.Repository.Interface;
12833
12834namespace WinApp.Service.Repository
12835{
12836  public class Repository<T> : IRepository<T> where T : Entity
12837  {
12838    protected Database Database
12839    {
12840      get
12841      {
12842        return new Database((IDbConnection) new SQLiteConnection(Map.Get<IDatabaseManager>().ConnectionString));
12843      }
12844    }
12845
12846    protected string TableName { get; private set; }
12847
12848    protected Repository(string tableName)
12849    {
12850      this.TableName = tableName;
12851    }
12852
12853    public void Insert(T entity)
12854    {
12855      this.Database.Insert<T>(this.TableName, "Id", true, entity);
12856    }
12857
12858    public void Update(T entity)
12859    {
12860      this.Database.Update(this.TableName, "Id", (object) entity);
12861    }
12862
12863    public void Update(T entity, string[] fields)
12864    {
12865      this.Database.Update(this.TableName, "Id", (object) entity, (IEnumerable<string>) fields);
12866    }
12867
12868    public virtual T[] FindAll()
12869    {
12870      return this.Database.Fetch<T>(string.Format("SELECT * FROM [{0}];", (object) this.TableName), new object[0]).ToArray();
12871    }
12872
12873    public virtual T FindById(long id)
12874    {
12875      return Enumerable.SingleOrDefault<T>((IEnumerable<T>) this.Database.Fetch<T>(string.Format("SELECT * FROM [{0}] WHERE Id = @0", (object) this.TableName), new object[1]
12876      {
12877        (object) id
12878      }));
12879    }
12880
12881    public virtual T Save(T entity)
12882    {
12883      if (entity.IsNew)
12884        this.Insert(entity);
12885      else
12886        this.Update(entity);
12887      return entity;
12888    }
12889
12890    public virtual void Delete(T entity)
12891    {
12892      this.Database.Delete((object) entity);
12893    }
12894
12895    protected void BulkInsertRecords(IEnumerable<T> collection)
12896    {
12897      Database database = this.Database;
12898      foreach (T poco in collection)
12899        database.Insert<T>(poco);
12900    }
12901
12902    protected IEnumerable<T> FindBy(string whereClause, params object[] parameters)
12903    {
12904      return (IEnumerable<T>) this.Database.Fetch<T>(string.Format("SELECT * FROM [{0}] WHERE {1}", (object) this.TableName, (object) whereClause), parameters);
12905    }
12906  }
12907}
12908?// Decompiled with JetBrains decompiler
12909// Type: WinApp.Service.Repository.Interface.ISessionRecordRepository
12910// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12911// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12912// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12913
12914using System;
12915using WinApp.Data.Model;
12916
12917namespace WinApp.Service.Repository.Interface
12918{
12919  public interface ISessionRecordRepository : IRepository<SessionRecord>
12920  {
12921    long GetTotalTime();
12922
12923    long GetTotalTimeByPeriod(DateTime periodStart, DateTime periodEnd);
12924
12925    SessionRecord[] GetByPeriod(DateTime periodStart, DateTime periodEnd);
12926  }
12927}
12928?// Decompiled with JetBrains decompiler
12929// Type: WinApp.Service.Repository.Interface.IRepository`1
12930// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12931// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12932// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12933
12934using WinApp.Data.Model;
12935
12936namespace WinApp.Service.Repository.Interface
12937{
12938  public interface IRepository<T> where T : Entity
12939  {
12940    T[] FindAll();
12941
12942    T FindById(long id);
12943
12944    void Insert(T entity);
12945
12946    void Update(T entity);
12947
12948    void Update(T entity, string[] fields);
12949
12950    T Save(T entity);
12951
12952    void Delete(T entity);
12953  }
12954}
12955?// Decompiled with JetBrains decompiler
12956// Type: WinApp.Service.Repository.Interface.IModuleRepository
12957// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12958// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12959// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12960
12961using WinApp.Data.Model;
12962
12963namespace WinApp.Service.Repository.Interface
12964{
12965  public interface IModuleRepository : IRepository<Module>
12966  {
12967    bool IsInstalled(long productId);
12968
12969    bool IsInstalledAndActivated(long productId);
12970
12971    Module GetModuleByProductId(long productId);
12972  }
12973}
12974?// Decompiled with JetBrains decompiler
12975// Type: WinApp.Service.Repository.ModuleRepository
12976// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
12977// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
12978// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
12979
12980using System.Linq;
12981using WinApp.Data.Model;
12982using WinApp.Service.Repository.Interface;
12983
12984namespace WinApp.Service.Repository
12985{
12986  public class ModuleRepository : Repository<Module>, IModuleRepository, IRepository<Module>
12987  {
12988    public ModuleRepository()
12989      : base("Module")
12990    {
12991    }
12992
12993    public bool IsInstalled(long productId)
12994    {
12995      Module module = Enumerable.SingleOrDefault<Module>(this.FindBy("ProductId = @0", (object) productId));
12996      if (module == null)
12997        return false;
12998      return module.State == 2;
12999    }
13000
13001    public bool IsInstalledAndActivated(long productId)
13002    {
13003      Module module = Enumerable.SingleOrDefault<Module>(this.FindBy("ProductId = @0", (object) productId));
13004      if (module == null)
13005        return false;
13006      return module.State == 3;
13007    }
13008
13009    public Module GetModuleByProductId(long productId)
13010    {
13011      return Enumerable.SingleOrDefault<Module>(this.FindBy("ProductId = @0", (object) productId)) ?? (Module) null;
13012    }
13013  }
13014}
13015?// Decompiled with JetBrains decompiler
13016// Type: WinApp.Service.Repository.SessionRecordRepository
13017// Assembly: KairosPlanet.Service, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13018// MVID: C598B940-0130-4846-9EFD-92647F3BFA24
13019// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.Service.dll
13020
13021using System;
13022using System.Linq;
13023using WinApp.Data.Model;
13024using WinApp.Service.Repository.Interface;
13025
13026namespace WinApp.Service.Repository
13027{
13028  public class SessionRecordRepository : Repository<SessionRecord>, ISessionRecordRepository, IRepository<SessionRecord>
13029  {
13030    public SessionRecordRepository()
13031      : base("SessionRecord")
13032    {
13033    }
13034
13035    public long GetTotalTime()
13036    {
13037      return this.Database.ExecuteScalar<long>("SELECT SUM([EndInt] - [StartInt]) FROM [SessionRecord]", new object[0]);
13038    }
13039
13040    public long GetTotalTimeByPeriod(DateTime periodStart, DateTime periodEnd)
13041    {
13042      if (periodEnd.Subtract(periodStart) < TimeSpan.Zero)
13043        return 0;
13044      return this.Database.ExecuteScalar<long>("SELECT SUM([EndInt] - [StartInt])\r\n                             FROM [SessionRecord]\r\n                             WHERE [StartInt] >= @0 AND [EndInt] <= @1", (object) periodStart.Ticks, (object) periodEnd.Ticks);
13045    }
13046
13047    public SessionRecord[] GetByPeriod(DateTime periodStart, DateTime periodEnd)
13048    {
13049      return Enumerable.ToArray<SessionRecord>(this.FindBy("[StartInt] >= @0 AND [EndInt] <= @1", (object) periodStart.Ticks, (object) periodEnd.Ticks));
13050    }
13051  }
13052}
13053?using System;
13054using System.Reflection;
13055using System.Runtime.CompilerServices;
13056using System.Runtime.InteropServices;
13057
13058[assembly: InternalsVisibleTo("KairosPlanet.Tests")]
13059[assembly: AssemblyTitle("KairosPlanet.Service")]
13060[assembly: AssemblyDescription("")]
13061[assembly: AssemblyProduct("KairosPlanet.Service")]
13062[assembly: InternalsVisibleTo("KairosPlanet")]
13063[assembly: AssemblyConfiguration("")]
13064[assembly: AssemblyCompany("Kairos Technologies Ltd")]
13065[assembly: AssemblyCopyright("Copyright © Kairos Technologies 2014")]
13066[assembly: AssemblyTrademark("")]
13067[assembly: ComVisible(false)]
13068[assembly: CLSCompliant(false)]
13069[assembly: AssemblyFileVersion("1.0.18.651")]
13070[assembly: AssemblyInformationalVersion("1.0.18.651")]
13071[assembly: AssemblyVersion("1.0.18.651")]
13072?// Decompiled with JetBrains decompiler
13073// Type: WinApp.Api.ApiClientFactory
13074// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13075// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13076// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13077
13078using Inc.Logging;
13079using KairosPlanet.WebServiceManager;
13080using System;
13081using System.Net;
13082using System.Net.Security;
13083using System.Security.Cryptography.X509Certificates;
13084using System.ServiceModel;
13085using System.ServiceModel.Channels;
13086using System.ServiceModel.Description;
13087using WinApp.Api.Interfaces;
13088
13089namespace WinApp.Api
13090{
13091  public class ApiClientFactory : IClientFactory
13092  {
13093    private string _userAgent;
13094
13095    public IAuthApi CreateChannel(string login, string password, string endpoingUri, string userAgent)
13096    {
13097      this._userAgent = userAgent;
13098      if (endpoingUri.ToUpper().StartsWith("HTTPS://"))
13099        return this.CreateChannelHttps(login.ToLower(), password, endpoingUri);
13100      return this.CreateChannelHttp(login.ToLower(), password, endpoingUri);
13101    }
13102
13103    public void SetUserAgent(string userAgent)
13104    {
13105      if (string.IsNullOrEmpty(userAgent))
13106        return;
13107      this._userAgent = userAgent;
13108    }
13109
13110    private IAuthApi CreateChannelHttps(string login, string password, string endpoingUri)
13111    {
13112      CheckPoint checkPoint = Logger.CheckPointStart("ClientFactory.CreateChannel HTTPS");
13113      ApiAccess apiAccess;
13114      try
13115      {
13116        WebHttpBinding webHttpBinding = new WebHttpBinding();
13117        EndpointAddress remoteAddress = new EndpointAddress(endpoingUri);
13118        webHttpBinding.UseDefaultWebProxy = true;
13119        webHttpBinding.Security.Mode = WebHttpSecurityMode.Transport;
13120        webHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
13121        webHttpBinding.OpenTimeout = new TimeSpan(0, 0, 3, 0, 0);
13122        webHttpBinding.SendTimeout = new TimeSpan(0, 0, 3, 0, 0);
13123        webHttpBinding.MaxReceivedMessageSize = (long) int.MaxValue;
13124        webHttpBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
13125        webHttpBinding.AllowCookies = true;
13126        apiAccess = new ApiAccess((Binding) webHttpBinding, remoteAddress);
13127        apiAccess.SetUserData(login, password);
13128        apiAccess.Endpoint.Behaviors.Add((IEndpointBehavior) new WebHttpBehavior());
13129        apiAccess.Endpoint.Behaviors.Add((IEndpointBehavior) new HttpKairosEndpointBehavior(this._userAgent, login, password));
13130        ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(this.ValidateRemoteCertificate);
13131      }
13132      finally
13133      {
13134        checkPoint.Close();
13135      }
13136      return (IAuthApi) apiAccess;
13137    }
13138
13139    private IAuthApi CreateChannelHttp(string login, string password, string endpoingUri)
13140    {
13141      CheckPoint checkPoint = Logger.CheckPointStart("ClientFactory.CreateChannel HTTP");
13142      ApiAccess apiAccess;
13143      try
13144      {
13145        WebHttpBinding webHttpBinding = new WebHttpBinding();
13146        EndpointAddress remoteAddress = new EndpointAddress(endpoingUri);
13147        webHttpBinding.Security.Mode = WebHttpSecurityMode.TransportCredentialOnly;
13148        webHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
13149        webHttpBinding.OpenTimeout = new TimeSpan(0, 0, 3, 0, 0);
13150        webHttpBinding.SendTimeout = new TimeSpan(0, 0, 3, 0, 0);
13151        webHttpBinding.MaxReceivedMessageSize = (long) int.MaxValue;
13152        webHttpBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
13153        webHttpBinding.AllowCookies = true;
13154        apiAccess = new ApiAccess((Binding) webHttpBinding, remoteAddress);
13155        apiAccess.SetUserData(login, password);
13156        apiAccess.Endpoint.Behaviors.Add((IEndpointBehavior) new WebHttpBehavior());
13157        apiAccess.Endpoint.Behaviors.Add((IEndpointBehavior) new HttpKairosEndpointBehavior(this._userAgent, login, password));
13158      }
13159      finally
13160      {
13161        checkPoint.Close();
13162      }
13163      return (IAuthApi) apiAccess;
13164    }
13165
13166    private bool ValidateRemoteCertificate(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors policyErrors)
13167    {
13168      return cert.Subject.ToUpper().Contains("staging.xmlm.t4web.com.ua".ToUpper()) || cert.Subject.ToUpper().Contains("cabinet.kairosplanet.com".ToUpper());
13169    }
13170  }
13171}
13172?// Decompiled with JetBrains decompiler
13173// Type: WinApp.Api.Data.ModuleContentResponse
13174// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13175// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13176// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13177
13178using System.Runtime.Serialization;
13179
13180namespace WinApp.Api.Data
13181{
13182  [DataContract]
13183  public class ModuleContentResponse
13184  {
13185    [DataMember(Name = "source")]
13186    public string Source { get; set; }
13187  }
13188}
13189?// Decompiled with JetBrains decompiler
13190// Type: WinApp.Api.Data.StatisticsResponse
13191// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13192// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13193// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13194
13195using System.Runtime.Serialization;
13196
13197namespace WinApp.Api.Data
13198{
13199  [DataContract]
13200  public class StatisticsResponse
13201  {
13202    [DataMember(Name = "sessions")]
13203    public Statistic[] Statistics { get; set; }
13204  }
13205}
13206?// Decompiled with JetBrains decompiler
13207// Type: WinApp.Api.Data.PurchaseResponse
13208// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13209// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13210// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13211
13212using System.Runtime.Serialization;
13213using WinApp.Data.Model;
13214
13215namespace WinApp.Api.Data
13216{
13217  [DataContract]
13218  public class PurchaseResponse
13219  {
13220    [DataMember(Name = "purchases")]
13221    public Purchase[] Purchases { get; set; }
13222  }
13223}
13224?// Decompiled with JetBrains decompiler
13225// Type: WinApp.Api.Data.PingResponse
13226// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13227// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13228// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13229
13230using System.Runtime.Serialization;
13231
13232namespace WinApp.Api.Data
13233{
13234  [DataContract]
13235  public class PingResponse
13236  {
13237    [DataMember(Name = "lifetime")]
13238    public long Lifetime { get; set; }
13239
13240    public long ErrorText { get; set; }
13241  }
13242}
13243?// Decompiled with JetBrains decompiler
13244// Type: WinApp.Api.Data.ActivationRequest
13245// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13246// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13247// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13248
13249using System.Runtime.Serialization;
13250
13251namespace WinApp.Api.Data
13252{
13253  [DataContract]
13254  public class ActivationRequest
13255  {
13256    [DataMember(Name = "purchase_id")]
13257    public long PurchaseId { get; set; }
13258  }
13259}
13260?// Decompiled with JetBrains decompiler
13261// Type: WinApp.Api.Data.AppVersionResponse
13262// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13263// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13264// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13265
13266using System.Runtime.Serialization;
13267
13268namespace WinApp.Api.Data
13269{
13270  [DataContract]
13271  public class AppVersionResponse
13272  {
13273    [DataMember(Name = "id")]
13274    public long Id { get; set; }
13275
13276    [DataMember(Name = "version")]
13277    public string Version { get; set; }
13278
13279    [DataMember(Name = "file_name")]
13280    public string FileName { get; set; }
13281
13282    [DataMember(Name = "path")]
13283    public string Path { get; set; }
13284
13285    [DataMember(Name = "status")]
13286    public bool Status { get; set; }
13287  }
13288}
13289?// Decompiled with JetBrains decompiler
13290// Type: WinApp.Api.Data.Statistic
13291// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13292// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13293// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13294
13295using System;
13296using System.Runtime.Serialization;
13297
13298namespace WinApp.Api.Data
13299{
13300  [DataContract]
13301  public class Statistic
13302  {
13303    private string _created;
13304    private string _closed;
13305
13306    [DataMember(Name = "id")]
13307    public long Id { get; set; }
13308
13309    [DataMember(Name = "actual")]
13310    public bool Actual { get; set; }
13311
13312    [DataMember(Name = "created")]
13313    public string Created
13314    {
13315      get
13316      {
13317        return this._created;
13318      }
13319      set
13320      {
13321        this._created = value;
13322        this.CreatedDate = DateTime.Parse(this._created);
13323      }
13324    }
13325
13326    public DateTime CreatedDate { get; private set; }
13327
13328    [DataMember(Name = "lifetime")]
13329    public long Lifetime { get; set; }
13330  }
13331}
13332?// Decompiled with JetBrains decompiler
13333// Type: WinApp.Api.Data.ModuleInfoResponse
13334// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13335// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13336// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13337
13338using System.Runtime.Serialization;
13339
13340namespace WinApp.Api.Data
13341{
13342  [DataContract]
13343  public class ModuleInfoResponse
13344  {
13345    [DataMember(Name = "id")]
13346    public long Id { get; set; }
13347
13348    [DataMember(Name = "product_id")]
13349    public long ProductId { get; set; }
13350
13351    [DataMember(Name = "title")]
13352    public string Title { get; set; }
13353
13354    [DataMember(Name = "version")]
13355    public string Version { get; set; }
13356
13357    [DataMember(Name = "description")]
13358    public string Description { get; set; }
13359
13360    [DataMember(Name = "filename")]
13361    public string Filename { get; set; }
13362
13363    [DataMember(Name = "url")]
13364    public string Url { get; set; }
13365  }
13366}
13367?// Decompiled with JetBrains decompiler
13368// Type: WinApp.Api.Data.ActivationResponse
13369// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13370// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13371// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13372
13373using System.Runtime.Serialization;
13374
13375namespace WinApp.Api.Data
13376{
13377  [DataContract]
13378  public class ActivationResponse
13379  {
13380    [DataMember(Name = "packagesecurekey")]
13381    public string PackageSecureKey { get; set; }
13382  }
13383}
13384?// Decompiled with JetBrains decompiler
13385// Type: WinApp.Api.Data.UserResponse
13386// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13387// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13388// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13389
13390using System.Runtime.Serialization;
13391using WinApp.Data.Model;
13392
13393namespace WinApp.Api.Data
13394{
13395  [DataContract]
13396  public class UserResponse
13397  {
13398    [DataMember(Name = "user")]
13399    public Man User { get; set; }
13400  }
13401}
13402?// Decompiled with JetBrains decompiler
13403// Type: KairosPlanet.WebServiceManager.HttpKairosEndpointBehavior
13404// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13405// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13406// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13407
13408using System.ServiceModel.Channels;
13409using System.ServiceModel.Description;
13410using System.ServiceModel.Dispatcher;
13411
13412namespace KairosPlanet.WebServiceManager
13413{
13414  public class HttpKairosEndpointBehavior : IEndpointBehavior
13415  {
13416    private readonly string _userAgent;
13417    private readonly string _login;
13418    private readonly string _password;
13419
13420    public HttpKairosEndpointBehavior(string userAgent, string login = "", string password = "")
13421    {
13422      this._userAgent = userAgent;
13423      this._login = login.ToLower();
13424      this._password = password;
13425    }
13426
13427    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
13428    {
13429    }
13430
13431    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
13432    {
13433      HttpKairosMessageInspector messageInspector = new HttpKairosMessageInspector(this._userAgent, this._login, this._password);
13434      clientRuntime.MessageInspectors.Add((IClientMessageInspector) messageInspector);
13435    }
13436
13437    public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
13438    {
13439    }
13440
13441    public void Validate(ServiceEndpoint endpoint)
13442    {
13443    }
13444  }
13445}
13446?// Decompiled with JetBrains decompiler
13447// Type: KairosPlanet.WebServiceManager.HttpKairosMessageInspector
13448// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13449// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13450// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13451
13452using System;
13453using System.Collections.Generic;
13454using System.Linq;
13455using System.Net;
13456using System.ServiceModel;
13457using System.ServiceModel.Channels;
13458using System.ServiceModel.Dispatcher;
13459using System.Text;
13460
13461namespace KairosPlanet.WebServiceManager
13462{
13463  public class HttpKairosMessageInspector : IClientMessageInspector
13464  {
13465    private static readonly HashSet<string> _requiredAuth = new HashSet<string>()
13466    {
13467      "/users/api/desktop/get-user/",
13468      "/users/api/desktop/get-purchases/",
13469      "/users/api/desktop/get-statistic/",
13470      "/application/api/desktop/get-module-info/",
13471      "/application/api/desktop/get-module-content/",
13472      "/application/api/desktop/get-application-info/"
13473    };
13474    private readonly string _userAgent;
13475    private readonly string _login;
13476    private readonly string _password;
13477
13478    public HttpKairosMessageInspector(string userAgent, string login = "", string password = "")
13479    {
13480      this._userAgent = userAgent;
13481      this._login = login;
13482      this._password = password;
13483    }
13484
13485    public void AfterReceiveReply(ref Message reply, object correlationState)
13486    {
13487    }
13488
13489    public object BeforeSendRequest(ref Message request, IClientChannel channel)
13490    {
13491      object obj;
13492      if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out obj))
13493      {
13494        HttpRequestMessageProperty requestMessageProperty = obj as HttpRequestMessageProperty;
13495        if (requestMessageProperty != null)
13496        {
13497          if (!string.IsNullOrEmpty(this._login) && !string.IsNullOrEmpty(this._password))
13498          {
13499            string path = request.Headers.To.AbsolutePath;
13500            if (Enumerable.Any<string>((IEnumerable<string>) HttpKairosMessageInspector._requiredAuth, (Func<string, bool>) (x => path == x)))
13501              requestMessageProperty.Headers[HttpRequestHeader.Authorization] = "Basic " + Convert.ToBase64String(Encoding.ASCII.GetBytes(this._login + ":" + this._password));
13502          }
13503          if (string.IsNullOrEmpty(requestMessageProperty.Headers[HttpRequestHeader.UserAgent]))
13504            requestMessageProperty.Headers[HttpRequestHeader.UserAgent] = this._userAgent;
13505          else
13506            request.Properties.Add(HttpRequestMessageProperty.Name, (object) new HttpRequestMessageProperty()
13507            {
13508              Headers = {
13509                {
13510                  HttpRequestHeader.UserAgent,
13511                  this._userAgent
13512                }
13513              }
13514            });
13515        }
13516      }
13517      return (object) null;
13518    }
13519  }
13520}
13521?// Decompiled with JetBrains decompiler
13522// Type: WinApp.Api.ApiException
13523// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13524// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13525// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13526
13527using System;
13528using System.Net;
13529
13530namespace WinApp.Api
13531{
13532  public class ApiException : Exception
13533  {
13534    public HttpStatusCode ErrorCode { get; set; }
13535
13536    public string StatusDescription { get; set; }
13537
13538    public ApiException(string message, HttpStatusCode errorCode, string statusDescription = "")
13539      : base(message)
13540    {
13541      this.ErrorCode = errorCode;
13542      this.StatusDescription = statusDescription;
13543    }
13544  }
13545}
13546?// Decompiled with JetBrains decompiler
13547// Type: WinApp.Api.Interfaces.IClientFactory
13548// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13549// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13550// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13551
13552namespace WinApp.Api.Interfaces
13553{
13554  public interface IClientFactory
13555  {
13556    IAuthApi CreateChannel(string login, string password, string endpoingUri, string userAgent);
13557  }
13558}
13559?// Decompiled with JetBrains decompiler
13560// Type: WinApp.Api.Interfaces.IApi
13561// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13562// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13563// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13564
13565using System.ServiceModel;
13566
13567namespace WinApp.Api.Interfaces
13568{
13569  [ServiceContract]
13570  public interface IApi : IProductsApi
13571  {
13572  }
13573}
13574?// Decompiled with JetBrains decompiler
13575// Type: WinApp.Api.Interfaces.IUsersApi
13576// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13577// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13578// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13579
13580using System;
13581using System.ServiceModel;
13582using System.ServiceModel.Web;
13583using WinApp.Api.Data;
13584
13585namespace WinApp.Api.Interfaces
13586{
13587  [ServiceContract]
13588  public interface IUsersApi
13589  {
13590    [OperationContract]
13591    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/users/api/desktop/get-user/")]
13592    UserResponse GetUser();
13593
13594    [OperationContract]
13595    [WebInvoke(BodyStyle = WebMessageBodyStyle.Bare, Method = "POST", ResponseFormat = WebMessageFormat.Json, UriTemplate = "/users/api/desktop/ping/?packagesecurekey={packagesecurekey}")]
13596    PingResponse Ping(string packagesecurekey);
13597
13598    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/users/api/desktop/get-statistic/")]
13599    [OperationContract]
13600    StatisticsResponse GetStatistics();
13601
13602    [OperationContract(Name = "GetStatisticsExt")]
13603    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/users/api/desktop/get-statistic/?dateFrom={dateFrom}&dateTo={dateTo}")]
13604    StatisticsResponse GetStatistics(DateTime dateFrom, DateTime dateTo);
13605
13606    [OperationContract]
13607    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/users/api/desktop/get-purchases/")]
13608    PurchaseResponse GetPurchases();
13609
13610    [OperationContract]
13611    [WebInvoke(Method = "PUT", RequestFormat = WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/users/api/desktop/activation/")]
13612    ActivationResponse Activation(ActivationRequest activationRequest);
13613
13614    void SetUserData(string username, string password);
13615
13616    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/application/api/desktop/get-application-info/")]
13617    [OperationContract]
13618    AppVersionResponse GetAppVersion();
13619  }
13620}
13621?// Decompiled with JetBrains decompiler
13622// Type: WinApp.Api.Interfaces.IProductsApi
13623// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13624// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13625// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13626
13627using System.ServiceModel;
13628using System.ServiceModel.Web;
13629using WinApp.Data.Model;
13630
13631namespace WinApp.Api.Interfaces
13632{
13633  [ServiceContract]
13634  public interface IProductsApi
13635  {
13636    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/products/api/products/")]
13637    [OperationContract]
13638    Product[] GetProducts();
13639
13640    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/products/api/products/?limit={limit}&offset={offset}")]
13641    [OperationContract(Name = "GetProductsByOffset")]
13642    Product[] GetProducts(int limit, int offset);
13643  }
13644}
13645?// Decompiled with JetBrains decompiler
13646// Type: WinApp.Api.Interfaces.IAppApi
13647// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13648// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13649// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13650
13651using System.ServiceModel;
13652using System.ServiceModel.Web;
13653using WinApp.Api.Data;
13654
13655namespace WinApp.Api.Interfaces
13656{
13657  [ServiceContract]
13658  public interface IAppApi
13659  {
13660    [OperationContract]
13661    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/application/api/desktop/get-module-info/?product_id={productId}")]
13662    ModuleInfoResponse GetModuleInfo(long productId);
13663
13664    [WebGet(BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, UriTemplate = "/application/api/desktop/get-module-content/?product_id={productId}")]
13665    [OperationContract]
13666    ModuleContentResponse GetModuleContent(long productId);
13667  }
13668}
13669?// Decompiled with JetBrains decompiler
13670// Type: WinApp.Api.Interfaces.IAuthApi
13671// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13672// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13673// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13674
13675using System.ServiceModel;
13676
13677namespace WinApp.Api.Interfaces
13678{
13679  [ServiceContract]
13680  public interface IAuthApi : IUsersApi, IApi, IProductsApi, IAppApi
13681  {
13682    void Close();
13683  }
13684}
13685?// Decompiled with JetBrains decompiler
13686// Type: WinApp.Api.ApiAccess
13687// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13688// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13689// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13690
13691using Inc.Logging;
13692using System;
13693using System.Net;
13694using System.ServiceModel;
13695using System.ServiceModel.Channels;
13696using WinApp.Api.Data;
13697using WinApp.Api.Interfaces;
13698using WinApp.Data.Model;
13699
13700namespace WinApp.Api
13701{
13702  public class ApiAccess : ClientBase<IAuthApi>, IAuthApi, IUsersApi, IApi, IProductsApi, IAppApi
13703  {
13704    public ApiAccess(Binding binding, EndpointAddress remoteAddress)
13705      : base(binding, remoteAddress)
13706    {
13707    }
13708
13709    public ModuleInfoResponse GetModuleInfo(long productId)
13710    {
13711      return this.HandleResponse<ModuleInfoResponse>((Func<IAuthApi, ModuleInfoResponse>) (x => x.GetModuleInfo(productId)));
13712    }
13713
13714    public ModuleContentResponse GetModuleContent(long productId)
13715    {
13716      return this.HandleResponse<ModuleContentResponse>((Func<IAuthApi, ModuleContentResponse>) (x => x.GetModuleContent(productId)));
13717    }
13718
13719    public void SetUserData(string username, string password)
13720    {
13721      this.ClientCredentials.UserName.UserName = username.ToLower();
13722      this.ClientCredentials.UserName.Password = password;
13723    }
13724
13725    public StatisticsResponse GetStatistics()
13726    {
13727      return this.HandleResponse<StatisticsResponse>((Func<IAuthApi, StatisticsResponse>) (x => x.GetStatistics()));
13728    }
13729
13730    public StatisticsResponse GetStatistics(DateTime dateFrom, DateTime dateTo)
13731    {
13732      return this.HandleResponse<StatisticsResponse>((Func<IAuthApi, StatisticsResponse>) (x => x.GetStatistics(dateFrom, dateTo)));
13733    }
13734
13735    public UserResponse GetUser()
13736    {
13737      return this.HandleResponse<UserResponse>((Func<IAuthApi, UserResponse>) (x => x.GetUser()));
13738    }
13739
13740    public PingResponse Ping(string packageSecureKey)
13741    {
13742      return this.HandleResponse<PingResponse>((Func<IAuthApi, PingResponse>) (x => x.Ping(packageSecureKey)));
13743    }
13744
13745    public Product[] GetProducts()
13746    {
13747      return this.HandleResponse<Product[]>((Func<IAuthApi, Product[]>) (x => x.GetProducts()));
13748    }
13749
13750    public Product[] GetProducts(int limit, int offset)
13751    {
13752      return this.HandleResponse<Product[]>((Func<IAuthApi, Product[]>) (x => x.GetProducts(limit, offset)));
13753    }
13754
13755    public PurchaseResponse GetPurchases()
13756    {
13757      return this.HandleResponse<PurchaseResponse>((Func<IAuthApi, PurchaseResponse>) (x => x.GetPurchases()));
13758    }
13759
13760    public ActivationResponse Activation(ActivationRequest activationRequest)
13761    {
13762      return this.HandleResponse<ActivationResponse>((Func<IAuthApi, ActivationResponse>) (x => x.Activation(activationRequest)));
13763    }
13764
13765    public AppVersionResponse GetAppVersion()
13766    {
13767      return this.HandleResponse<AppVersionResponse>((Func<IAuthApi, AppVersionResponse>) (x => x.GetAppVersion()));
13768    }
13769
13770    private T HandleResponse<T>(Func<IAuthApi, T> func)
13771    {
13772      try
13773      {
13774        return func(this.Channel);
13775      }
13776      catch (Exception ex)
13777      {
13778        Logger.WriteError((object) this, "HandleResponse<T>", "Method: '" + func.Method.Name + "'. Error: " + ex.Message);
13779        WebException webException = ex.InnerException as WebException;
13780        if (webException != null && webException.Response != null)
13781        {
13782          HttpWebResponse httpWebResponse = (HttpWebResponse) webException.Response;
13783          throw new ApiException(webException.Message, httpWebResponse.StatusCode, httpWebResponse.StatusDescription);
13784        }
13785        throw;
13786      }
13787    }
13788  }
13789}
13790?using System;
13791using System.Reflection;
13792using System.Runtime.InteropServices;
13793
13794[assembly: AssemblyTitle("KairosPlanet.WebServiceManager")]
13795[assembly: AssemblyDescription("")]
13796[assembly: AssemblyInformationalVersion("1.0.18.651")]
13797[assembly: Guid("7aa12bcc-c133-487c-b901-bb1afd1f652b")]
13798[assembly: AssemblyFileVersion("1.0.18.651")]
13799[assembly: AssemblyProduct("KairosPlanet.WebServiceManager")]
13800[assembly: AssemblyConfiguration("")]
13801[assembly: AssemblyCompany("Kairos Technologies Ltd")]
13802[assembly: AssemblyCopyright("Copyright © Kairos Technologies 2014")]
13803[assembly: AssemblyTrademark("")]
13804[assembly: ComVisible(false)]
13805[assembly: CLSCompliant(false)]
13806[assembly: AssemblyVersion("1.0.18.651")]
13807?// Decompiled with JetBrains decompiler
13808// Type: WinApp.Api.ApiBootstrapper
13809// Assembly: KairosPlanet.WebServiceManager, Version=1.0.18.651, Culture=neutral, PublicKeyToken=null
13810// MVID: F6F5C251-9F2C-4C96-A6DF-4DB3276EDED0
13811// Assembly location: C:\Program Files (x86)\KairosPlanet\Bin\KairosPlanet.WebServiceManager.dll
13812
13813using IncMap;
13814using WinApp.Api.Interfaces;
13815
13816namespace WinApp.Api
13817{
13818  public class ApiBootstrapper
13819  {
13820    public static void Bootstrap()
13821    {
13822      Map.Inject<IClientFactory>((IClientFactory) new ApiClientFactory());
13823    }
13824  }
13825}