Пример #1
0
        private void Save()
        {
            try
            {
                if (string.IsNullOrEmpty(Password) || string.IsNullOrEmpty(Username) || string.IsNullOrEmpty(Name))
                {
                    throw new Exception("All fields are required.");
                }

                PasswordItem pwd = new PasswordItem();

                pwd.Username = Username;
                pwd.Password = Password;
                pwd.Name     = Name;


                if (isEdit)
                {
                    pwd.ID = existing.ID;
                    ds.UpdatePassword(pwd);
                }
                else
                {
                    ds.AddPassword(pwd);
                }

                Cancelled = false;
                window.Close();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #2
0
        private void LoadDatabase()
        {
            try
            {
                if (string.IsNullOrEmpty(DatabasePath))
                {
                    throw new Exception("Path cannot be empty.");
                }

                var exists = File.Exists(databasePath);

                dataStore = new DataStore(databasePath, !exists);
                QuoteService.Instance.SetDataStore(dataStore);

                //Store
                Properties.Settings.Default.LastPath = databasePath;
                Properties.Settings.Default.Save();

                RaisePropertyChanged("Loaded");
                RaisePropertyChanged("NotLoaded");

                RefreshQuote();

                QuoteService.Instance.StartTimer();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
        private void SaveTag()
        {
            try
            {
                if (SelectedCategory == null)
                {
                    return;
                }

                if (SelectedTag == null)
                {
                    StateManager.Instance.DataStore.AddTag(SelectedCategory.ID, TagName);
                    TagName = null;
                }
                else
                {
                    SelectedTag.Name = TagName;
                    StateManager.Instance.DataStore.UpdateTag(SelectedTag);
                }

                LoadWindow(SelectedCategory.ID);

                Changed = true;
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
        private void Export()
        {
            try
            {
                if (string.IsNullOrEmpty(SavePath))
                {
                    throw new Exception("Save path not defined.");
                }
                else if (string.IsNullOrEmpty(SelectedExporter))
                {
                    throw new Exception("No exporter selected.");
                }
                else if (SelectedBook == null)
                {
                    throw new Exception("No book selected.");
                }

                if (File.Exists(SavePath) &&
                    !MessageBoxFactory.ShowConfirmAsBool("Overwrite existing file?", "File Exists"))
                {
                    return;
                }

                BaseExporter exporter = GetExporter();
                exporter.Export(SelectedBook, SavePath);

                MessageBoxFactory.ShowInfo("Book has been exported to: " + SavePath, "Book Exported");
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #5
0
        private void SaveSettings()
        {
            try
            {
                if (string.IsNullOrEmpty(DbPath) || !Path.IsPathRooted(DbPath))
                {
                    throw new Exception("DB Path is empty or not valid.");
                }

                settings.DbPath     = DbPath;
                settings.Username   = Username;
                settings.Password   = settingsWindow.PasswordBox.Password;
                settings.HideChrome = HideBrowser;

                settings.Save();

                Changed = true;

                settingsWindow.Close();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #6
0
        /// <summary>
        /// Comment on a specific rant using the RantSelector
        /// </summary>
        private async void ViewSpecificRant()
        {
            var rantSelector = new IDInputWindow(IDInputWindowViewModel.Type.Rant);

            rantSelector.Owner = window;

            rantSelector.ShowDialog();

            if (!string.IsNullOrEmpty(rantSelector.InputValue))
            {
                try
                {
                    Dtos.Rant rant = await api.GetRant(Convert.ToInt64(rantSelector.InputValue));

                    var dlg = new RantViewerWindow(new ViewModels.Rant(rant), api);
                    dlg.Owner = window;

                    dlg.ShowDialog();
                }
                catch (Exception e)
                {
                    MessageBoxFactory.ShowError(e);
                }
            }
        }
Пример #7
0
        private void Save()
        {
            try
            {
                TaskList newList = new TaskList(Name, Description, ConvertType(SelectedListType));

                var type = ConvertType(SelectedListType);
                if (existing != null)
                {
                    Workspace.API.UpdateList(existing, Name, Description, type);
                }
                else
                {
                    Workspace.API.InsertList(Name, Description, type);
                }

                Cancelled = false;
                window.Close();
            }
            catch (Exception e)
            {
                Workspace.Instance.RejectChanges();
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #8
0
        private async void RefreshWatchlistItemsAsync()
        {
            IsRefreshing = false;

            await Task.Run(() =>
            {
                try
                {
                    //TODO: Disable Button
                    RefreshWatchlistItems(false);

                    App.Current.Dispatcher.Invoke(() =>
                    {
                        LoadFromContext();
                        IsRefreshing = true;
                    });
                }
                catch (Exception e)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        MessageBoxFactory.ShowError(e);
                        IsRefreshing = true;
                    });
                }
            });
        }
Пример #9
0
        private async void ViewSpecificProfile()
        {
            try
            {
                var dlg = new IDInputWindow(IDInputWindowViewModel.Type.Profile);
                dlg.Owner = window;
                dlg.ShowDialog();

                string username = dlg.InputValue;

                if (!string.IsNullOrEmpty(username))
                {
                    bool valid = await api.IsValidUser(username);

                    if (valid)
                    {
                        ViewProfile(username);
                    }
                    else
                    {
                        throw new Exception(username + " does not exist.");
                    }
                }
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #10
0
        private void DoSearch()
        {
            try
            {
                if (IsSearching)
                {
                    ClearSearch();
                }
                else
                {
                    if (SearchFilter == null || string.IsNullOrEmpty(SearchFilter.Trim()))
                    {
                        throw new Exception("No search string entered");
                    }

                    items.Clear();
                    List <IDataItem> results = DataManager.Instance().DataStore.Search(SearchFilter);

                    foreach (var i in results)
                    {
                        Items.Add(new ItemViewModel(i, SVMLookup[i.GetSource()]));
                    }
                }

                SortedView.Refresh();
                IsSearching = !IsSearching;

                RefreshViewModel();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #11
0
        private async void RefreshRecentMoviesAsync()
        {
            IsRefreshing = false;

            await Task.Run(() =>
            {
                try
                {
                    var result = RefreshRecentlyAdded();

                    App.Current.Dispatcher.Invoke(() =>
                    {
                        ShowRefreshStatus(result);
                        LoadFromContext();
                        IsRefreshing = true;
                    });
                }
                catch (Exception e)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        MessageBoxFactory.ShowError(e);
                        IsRefreshing = true;
                    });
                }
            });
        }
Пример #12
0
        private void DeleteItem()
        {
            try
            {
                if (SelectedTask == null)
                {
                    return;
                }
                else if (!MessageBoxFactory.ShowConfirmAsBool("Are you sure you want to delete this Task and ALL it's SubTasks?",
                                                              "Confirm Delete",
                                                              System.Windows.MessageBoxImage.Exclamation))
                {
                    return;
                }

                var parent = SelectedTask.Parent;
                int?pid    = parent == null ? null : (int?)parent.TaskItemID;

                Workspace.API.DeleteTask(SelectedTask);

                TasksChanged();

                if (pid != null)
                {
                    ExpandAndSelect(tasks, pid.Value);
                }

                //Need to update list as well
                //TODO Duplicate: RefreshListsView();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #13
0
        private void Save()
        {
            try
            {
                if (string.IsNullOrEmpty(Comment))
                {
                    throw new Exception("The comment cannot be empty.");
                }

                Data = new Core.Comment()
                {
                    Text = Comment,
                };

                //Returns a List and then API checks if it has ID, if yes update, else add

                if (IsEdit)
                {
                    Data.CommentID = existing.CommentID;
                }
                else
                {
                    Data.Created = DateTime.Now;
                }

                Cancelled = false;
                window.Close();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
        private void EditLogin()
        {
            try
            {
                if (SelectedLogin == null)
                {
                    return;
                }

                try
                {
                    var dlg = new EditLoginWindow(ds, passwordsMap, SelectedLogin);
                    dlg.Owner = mainWindow;
                    dlg.ShowDialog();

                    if (!dlg.Cancelled)
                    {
                        LoadLists();
                    }
                }
                catch (Exception e)
                {
                    MessageBoxFactory.ShowError(e);
                }
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #15
0
        public void Load()
        {
            try
            {
                if (string.IsNullOrEmpty(WorkspacePath))
                {
                    throw new Exception("The path cannot be empty.");
                }

                string dbFile = GetDbFilePath(WorkspacePath);

                if (!Directory.Exists(WorkspacePath))
                {
                    Directory.CreateDirectory(WorkspacePath);
                }
                else
                {
                    ValidateWorkspace(workspacePath);
                }

                LoadWorkspaceAsync(dbFile);
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #16
0
        private void AddNewToCurrent()
        {
            try
            {
                if (string.IsNullOrEmpty(NewTagName))
                {
                    return;
                }

                var exists = ds.GetTags(NewTagName);
                if (exists.Count > 0)
                {
                    throw new Exception("The tag already exists.");
                }
                else
                {
                    CurrentList.Add(new Tag()
                    {
                        TagName = NewTagName
                    });
                    NewTagName = "";
                }
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #17
0
        //TODO: Clean, figure out whether should do in GameBoard or here
        private void OnClick(int r, int c)
        {
            if (board.IsMine(r, c))
            {
                MessageBoxFactory.ShowError("Lose", "You Lose");

                InGame = false;
            }
            else
            {
                CellsLeft--;

                var button = buttonGrid[r, c];

                if (button.IsEmpty)
                {
                    for (int row = r - 1; row <= r + 1; row++)
                    {
                        for (int col = c - 1; col <= c + 1; col++)
                        {
                            GridButton gb = GetButton(row, col);
                            if (gb != null && gb != button && !gb.Clicked && !gb.IsMine)
                            {
                                gb.Click(); //This is recursive
                            }
                        }
                    }
                }

                CheckWin();
            }
        }
Пример #18
0
 private void ClearDatabase()
 {
     if (MessageBoxFactory.ShowConfirmAsBool("Are you sure you want to clear the database?", "Confirm Clear Database", MessageBoxImage.Exclamation))
     {
         QuoteService.Instance.DataStore.ClearTables(); //TODO: Change all to use QuoteService
     }
 }
Пример #19
0
        public static void Main()
        {
            Application.SetHighDpiMode(HighDpiMode.SystemAware);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            // Configure main logic:
            var factory    = new MessageBoxFactory();
            var mainForm   = new DataGridViewMain();
            var controller = new StandardController(mainForm, null);

#if !DEBUG
            try
            {
                controller.LoadApp();
            }
            catch (Exception a)
            {
                factory.ShowMessageBox(EMessageBox.Standard,
                                       string.Format(Resources.UnknownExceptionMessage, a.Message),
                                       Settings.Default.AppName,
                                       MessageBoxButtons.OK,
                                       MessageBoxIcon.Error);

                return;
            }
#else
            controller.LoadApp();
#endif

            Application.Run(mainForm);
        }
Пример #20
0
        private void Execute(object sender)
        {
            var selectedItem = SelectionManager.SelectedItem;

            if (selectedItem == null)
            {
                MessageBoxFactory.Show("No Item selected", "Export");
                return;
            }

            var textLines = _applicableTypes[selectedItem.GetType()](selectedItem);

            if (textLines == null || !textLines.Any())
            {
                MessageBoxFactory.Show("Unable to export inline table because it does not contain any rows", "Export");
                return;
            }
            var saveFileDialog1 = new SaveFileDialog();

            saveFileDialog1.Title  = "Specify file to export data to";
            saveFileDialog1.Filter = "Text Files (*.txt)|*.txt|All Files (*.*)|*.*";
            saveFileDialog1.ShowDialog();

            if (saveFileDialog1.FileName != "")
            {
                System.IO.File.WriteAllLines(saveFileDialog1.FileName, textLines);

                MessageBoxFactory.Show("Successfuly exported " + textLines.Count() + " rows to file: " + saveFileDialog1.FileName, "Export");
            }
        }
Пример #21
0
        private void Save()
        {
            try
            {
                if (String.IsNullOrEmpty(Name))
                {
                    throw new Exception("Name is empty");
                }

                if (IsEdit)
                {
                    existing.Name = Name;
                }
                else
                {
                    Topic t = new Topic()
                    {
                        Name = Name
                    };

                    Util.DB.Topics.Add(t);
                }

                Util.DB.SaveChanges();
                window.Close();
            }
            catch (Exception e)
            {
                Util.DB.RejectChanges();
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #22
0
        private void ClearLogs()
        {
            try
            {
                if (selectedTask == null)
                {
                    return;
                }
                else if (!MessageBoxFactory.ShowConfirmAsBool("Delete all log entries?", "Confirm Delete"))
                {
                    return;
                }

                foreach (var t in Workspace.Instance.TasksLog.Where(x => x.TaskID == SelectedTask.Data.TaskItemID))
                {
                    Workspace.Instance.TasksLog.Remove(t);
                }

                Workspace.Instance.SaveChanges();
                UpdateCalendar();
            }
            catch (Exception e)
            {
            }
        }
Пример #23
0
        private void OpenDataStore()
        {
            try
            {
                if (string.IsNullOrEmpty(Path) || string.IsNullOrEmpty(pwdBox.Password))
                {
                    throw new Exception("A path and password are required.");
                }
                else if (!Path.EndsWith(Extension))
                {
                    Path += Extension;
                }

                IDataStore ds = new SQLiteDataStore(Path, pwdBox.Password);
                ds.Open();

                DataStore = ds;

                pathHistory.AddItem(Path);
                settings.History = pathHistory.SerializeToString();
                settings.Save();

                Cancelled = false;
                openDatabaseWindow.Close();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #24
0
        private void Save()
        {
            try
            {
                if (!Enabled)
                {
                    Hotkey.ClearHotkey();
                }
                else
                {
                    ModifierKeys mod = ToModifier(SelectedModifier);
                    Key          key = ToKey(Character);

                    Hotkey hk = new Hotkey(mod, key);
                    Hotkey.RegisterHotkey(hk, showDashboardCb);
                }

                Changed = true;
                closeWindowCb.Invoke();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);

                Changed = false;
            }
        }
Пример #25
0
 private void DeleteQuote()
 {
     if (SelectedQuote != null &&
         MessageBoxFactory.ShowConfirmAsBool("Are you sure you want to delete the selected quote?", "Confirm Delete"))
     {
         dataStore.DeleteQuote(SelectedQuote);
         LoadItem();
     }
 }
Пример #26
0
        private void SaveChange()
        {
            try
            {
                if (string.IsNullOrEmpty(Location))
                {
                    throw new RequiredFieldException("Location");
                }
                else if (string.IsNullOrEmpty(OriginalText))
                {
                    throw new RequiredFieldException("OriginalText");
                }
                else if (SelectedTopic == null)
                {
                    throw new RequiredFieldException("Topic");
                }

                if (IsEdit)
                {
                    note.Location     = Location;
                    note.OriginalText = OriginalText;
                    note.Published    = IsPublished;
                    //note.SubTopic = SelectedSubTopic;
                    note.Topic   = SelectedTopic;
                    note.Updated = DateTime.Now;
                    note.WriteUp = WriteUp;
                    note.Notes   = Notes;
                }
                else
                {
                    Note note = new Note()
                    {
                        Book         = book,
                        Topic        = SelectedTopic,
                        Location     = Location,
                        OriginalText = OriginalText,
                        //SubTopic = SelectedSubTopic,
                        Created = DateTime.Now,
                        Updated = DateTime.Now,
                        WriteUp = WriteUp,
                        Notes   = Notes
                    };

                    Workspace.Current.DB.Notes.Add(note);
                }

                Workspace.Current.DB.SaveChanges();
                cancelled = false;

                window.Close();
            }
            catch (Exception e)
            {
                Workspace.Current.DB.RejectChanges();
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #27
0
        private void Save()
        {
            try
            {
                ds.SetDefaultRange(DefaultStoryRange);
                ds.SetDefaultFeed(DefaultFeed);

                AddedUsers = ds.SetFollowing(users);
                ds.SetUpdatesInterval(UpdateCheckInterval);

                if (!string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(Password))
                {
                    api.User.Login(Username, Password);
                }

                ds.SetHideUsername(!ShowUsername);
                ds.SetShowCreateTime(ShowCreateTime);
                ds.SetFilterOutRead(FilterOutRead);

                ds.SetLimits(ResultsLimit, MinScore, MaxPages);

                //Check DBPath
                if (ds.DBFolder != DBFolder)
                {
                    ds.SetDBFolder(DBFolder);
                    DatabaseChanged = true;
                }

                //Check/Save Login
                if (Username != null && Password != null)
                {
                    var info = ds.GetLoginInfo();
                    if (info != null)
                    {
                        if (Username != info.Username || Password != info.Password)
                        {
                            ds.SetLogin(new LoginInfo(Username, Password));
                            LoginChanged = true;
                        }
                    }
                    else
                    {
                        ds.SetLogin(new LoginInfo(Username, Password));
                        LoginChanged = true;
                    }
                }

                Cancelled = false;
                window.Close();
            }
            catch (Exception e)
            {
                MessageBoxFactory.ShowError(e);
            }
        }
Пример #28
0
 private void SendSong()
 {
     try
     {
         waClient.SendMessage(azClient.GetRandom());
     }
     catch (Exception e)
     {
         MessageBoxFactory.ShowError(e, owner: window);
     }
 }
Пример #29
0
 private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
 {
     if (vm.HasUnsaved)
     {
         var ctnu = MessageBoxFactory.ShowConfirmAsBool("There are unsaved documents. Continue closing?", "Unsaved Documents", MessageBoxImage.Exclamation);
         if (!ctnu)
         {
             e.Cancel = true;
         }
     }
 }
Пример #30
0
 private void SendRandomMessage()
 {
     try
     {
         waClient.SendRandomMessage();
     }
     catch (Exception e)
     {
         MessageBoxFactory.ShowError(e);
     }
 }