bodyshop-uploader/BodyshopUploader/ViewModels/MainViewModel.cs

using BodyshopUploader.Models;
using BodyshopUploader.Utils.Growls;
using GraphQL.Client;
using GraphQL.Common.Request;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace BodyshopUploader.ViewModels
{
    public partial class MainViewModel : BaseViewModel
    {
        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        public MainViewModel()
        {
            logger.Trace("Main VM constructed.");

            BackgroundWorker bw = new BackgroundWorker();
            bw.DoWork += bw_InitVm;
            bw.WorkerReportsProgress = true;
            bw.ProgressChanged += Bw_ProgressChanged;
            bw.RunWorkerCompleted += Bw_RunWorkerCompleted;
            bw.RunWorkerAsync();

            Growler = new GrowlNotification(this);
            Utils.JobProcessingQueue.SetGrowler(Growler);
        }

        private void Bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            ((BackgroundWorker)sender).Dispose();
            Progress = 0;
        }

        private void Bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            Progress = e.ProgressPercentage;

            logger.Trace("Starting monitors if able to.");
            if (StartFolderMonitorsCommand.CanExecute(null))
                StartFolderMonitorsCommand.Execute(null);
        }

        private void bw_InitVm(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker _callingThread = sender as BackgroundWorker;
            _callingThread.ReportProgress(1);

            //Restore list of paths, convert to monitor object.
            List<string> listOfPaths = Properties.Settings.Default.MonitoringPaths;
            if (listOfPaths == null) listOfPaths = new List<string>();
            foreach (var p in listOfPaths)
            {
                MonitoringPaths.Add(new Models.Monitor() { FilePath = p });
            }
            MonitoringPaths.CollectionChanged += MonitoringPathsChanged;
            _callingThread.ReportProgress(30);

            //Cannot use await.
            LoadBodyshopData().Wait(); ;

            _callingThread.ReportProgress(80);

            logger.Debug("VM Init Complete");
            _callingThread.ReportProgress(100);
        }


        private void MonitoringPathsChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            IndeterminateLoading = true;
            StopAllFolderMonitors();
            StartAllFolderMonitors();
            IndeterminateLoading = false;
        }

        public void AddFolderMonitoringPath()
        {
            var dialog = new Ookii.Dialogs.Wpf.VistaFolderBrowserDialog();
            if (dialog.ShowDialog().GetValueOrDefault())
            {
                logger.Debug("Adding folder {0} to monitoring paths.", dialog.SelectedPath);
                MonitoringPaths.Add(new Models.Monitor() { FilePath = dialog.SelectedPath });
                Properties.Settings.Default.MonitoringPaths = MonitoringPaths.Select(x => x.FilePath).ToList(); ;
                Properties.Settings.Default.Save();
            }
        }

        public void RemoveFolderMonitoringPath(Monitor m)
        {
            logger.Debug("Removing folder {0} to monitoring paths.", m.FilePath);
            m.StopMonitor();
            MonitoringPaths.Remove(m);
            Properties.Settings.Default.MonitoringPaths = MonitoringPaths.Select(x => x.FilePath).ToList();
            Properties.Settings.Default.Save();
        }

        public void StartAllFolderMonitors()
        {
            IndeterminateLoading = true;
            if (MonitoringPaths.Count > 0)
                foreach (var m in MonitoringPaths)
                {
                    m.StopMonitor();
                }

            foreach (var p in MonitoringPaths)
            {
                p.StartMonitor();
            }
            IndeterminateLoading = false;
        }

        public void StopAllFolderMonitors()
        {
            IndeterminateLoading = true;
            if (MonitoringPaths.Count > 0)
                foreach (var m in MonitoringPaths)
                {
                    m.StopMonitor();
                }
            IndeterminateLoading = false;
        }

        public async Task LoadBodyshopData()
        {
            var r = new GraphQLRequest
            {
                Query = @"query QUERY_BODYSHOPS {
                                                  bodyshops {
                                                    shopname
                                                    id
                                                    associations {
                                                      id
                                                      active
                                                    }
                                                  }
                                                }"
            };

            var Data = await Utils.GraphQL.ExecuteQuery(r);
            if (Data != null)
            {
                ShopData = Data.bodyshops.ToObject<ObservableCollection<Bodyshop>>();
            }
            string SettingsSelectedShopUuid = Properties.Settings.Default.LastSelectedShop;
            if (string.IsNullOrEmpty(SettingsSelectedShopUuid))
            {
                ActiveShop = ShopData[0] ?? null;
                Properties.Settings.Default.LastSelectedShop = ShopData[0].Id ?? null;
                Properties.Settings.Default.Save();
            }
            else
            {
                ActiveShop = ShopData.Where(_ => _.Id == SettingsSelectedShopUuid).FirstOrDefault();
            }
        }

        public async Task SetActiveBodyshop()
        {
            IndeterminateLoading = true;
            foreach (var s in ShopData)
            {
                if (s.Id == ActiveShop.Id) s.AssociationActive = true;
                else s.AssociationActive = false;
                var r = new GraphQLRequest
                {
                    Query = @"
                        mutation UPDATE_ASSOCIATION($assocId: uuid, $assocActive: Boolean) {
                            update_associations(where: {id: {_eq: $assocId}}, _set: {active: $assocActive}) {
                                returning {
                                    id
                                    active
                                }
                            }
                        }
            ",
                    Variables = new
                    {
                        assocId = s.AssociationId,
                        assocActive = s.AssociationActive
                    }
                };
                await Utils.GraphQL.ExecuteQuery(r);
            }
            Properties.Settings.Default.LastSelectedShop = ActiveShop.Id;
            Properties.Settings.Default.Save();
            IndeterminateLoading = false;
        }

        public async Task TestGql()
        {
            Notification _n = new Notification()
            {
                Id = 123,
                Title = "This is a title",
                Subtitle = "Subtitle",
                Message = "Somethin"
            };
            Growler.AddNotification(_n);

            var r = new GraphQLRequest
            {
                Query = @"
                            query QUERY_BODYSHOPS {
                              bodyshops {
                                shopname
                                id
                              }
                            }"
            };
            await Utils.GraphQL.ExecuteQuery(r);
        }
    }
}