1 files changed, 270 insertions, 4 deletions
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Synchronization/ViewModels/DirectSynchronizationViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Synchronization/ViewModels/DirectSynchronizationViewVM.cs
index ba3521009..f265fafe7 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Synchronization/ViewModels/DirectSynchronizationViewVM.cs
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Synchronization/ViewModels/DirectSynchronizationViewVM.cs
@@ -1,20 +1,286 @@
-using System;
+using Google.Protobuf;
+using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
+using Tango.Core.Commands;
+using Tango.Core.Helpers;
+using Tango.DAL.Observables;
 using Tango.Integration.Services;
+using Tango.MachineStudio.Common.Notifications;
+using Tango.MachineStudio.Common.StudioApplication;
+using Tango.MachineStudio.Synchronization.Navigation;
+using Tango.PMR.Integration;
 using Tango.SharedUI;
+using Tango.Synchronization;
+using Tango.Synchronization.Local;
+using Tango.Synchronization.Remote;
 
 namespace Tango.MachineStudio.Synchronization.ViewModels
 {
     public class DirectSynchronizationViewVM : ViewModel
     {
-        public ExternalBridgeScanner Scanner { get; set; }
+        private SyncNavigationManager _navigation;
+        private String _slaveDBFile;
+        private String _masterDBFile;
+        private LocalDBComparer _comparer;
+        private INotificationProvider _notification;
+        private bool _isWorking;
 
-        public DirectSynchronizationViewVM(ExternalBridgeScanner scanner)
+        public IStudioApplicationManager ApplicationManager { get; set; }
+
+        public DirectSynchronizationViewVM(IStudioApplicationManager applicationManager, SyncNavigationManager navigation, INotificationProvider notification)
+        {
+            ApplicationManager = applicationManager;
+
+            _navigation = navigation;
+            _notification = notification;
+
+            BackCommand = new RelayCommand(() => _navigation.NavigateTo(NavigationView.MenuView));
+
+            Differences = new ObservableCollection<Diff>();
+
+            CompareCommand = new RelayCommand(Compare, (x) => !_isWorking && SelectedMachine != null);
+            CommitAllCommand = new RelayCommand(Synchronize, (x) => Differences.Count > 0 && !_isWorking && SelectedMachine != null);
+        }
+
+        #region Commands
+
+        /// <summary>
+        /// Gets or sets the back command.
+        /// </summary>
+        public RelayCommand BackCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the browse master database command.
+        /// </summary>
+        public RelayCommand BrowseMasterDBCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the browse slave database command.
+        /// </summary>
+        public RelayCommand BrowseSlaveDBCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the compare command.
+        /// </summary>
+        public RelayCommand CompareCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the commit command.
+        /// </summary>
+        public RelayCommand CommitCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the commit all command.
+        /// </summary>
+        public RelayCommand CommitAllCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the clean command.
+        /// </summary>
+        public RelayCommand CleanCommand { get; set; }
+
+        #endregion
+
+        #region Properties
+
+        private bool _isClearMachine;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is clear machine.
+        /// </summary>
+        public bool IsClearMachine
+        {
+            get { return _isClearMachine; }
+            set
+            {
+                _isClearMachine = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+        private ObservableCollection<Diff> _differences;
+        /// <summary>
+        /// Gets or sets the differences.
+        /// </summary>
+        public ObservableCollection<Diff> Differences
+        {
+            get { return _differences; }
+            set { _differences = value; RaisePropertyChanged(nameof(Differences)); }
+        }
+
+        private Diff _selectedDifference;
+        /// <summary>
+        /// Gets or sets the selected difference.
+        /// </summary>
+        public Diff SelectedDifference
+        {
+            get { return _selectedDifference; }
+            set { _selectedDifference = value; RaisePropertyChanged(nameof(SelectedDifference)); InvalidateRelayCommands(); }
+        }
+
+        private Machine _selectedMachine;
+        /// <summary>
+        /// Gets or sets the selected machine.
+        /// </summary>
+        public Machine SelectedMachine
+        {
+            get { return _selectedMachine; }
+            set { _selectedMachine = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+        }
+
+        #endregion
+
+        private void Compare()
+        {
+            if (SelectedMachine.SerialNumber != ApplicationManager.ConnectedMachine.SerialNumber)
+            {
+                if (!_notification.ShowQuestion("The selected machine serial number does not match the connected machine. Are you sure you want to continue?"))
+                {
+                    return;
+                }
+            }
+
+            Task.Factory.StartNew(async () =>
+            {
+                using (_notification.PushTaskItem("Downloading machine database..."))
+                {
+                    try
+                    {
+                        _isWorking = true;
+                        InvalidateRelayCommands();
+                        Thread.Sleep(1500);
+
+                        ApplicationManager.ConnectedMachine.RequestTimeout = TimeSpan.FromSeconds(10);
+                        var response = await ApplicationManager.ConnectedMachine.SendRequest<DirectSynchronizationRequest, DirectSynchronizationResponse>(new DirectSynchronizationRequest());
+
+                        using (_notification.PushTaskItem("Generating temporary files..."))
+                        {
+                            String tempFolder = PathHelper.GetTempFolderPath();
+
+                            //File path for the reflected remote data base SQLite.
+                            _masterDBFile = Path.Combine(tempFolder, "Remote.db");
+                            //File path for the received machine SQLite db.
+                            _slaveDBFile = Path.Combine(tempFolder, "Local.db");
+
+                            //Save the machine db to file.
+                            File.WriteAllBytes(_slaveDBFile, response.Message.LocalDB.ToByteArray());
+
+                            //Copy the SQLite db template.
+                            File.Copy(Path.Combine(PathHelper.GetStartupPath(), "Tango.db"), _masterDBFile);
+
+                            //Synchronize the SQL Server db with the new SQLite template. (Overwrite basically)
+                            RemoteDBSynchronizer.Synchronize(_masterDBFile, SelectedMachine.SerialNumber, true);
+
+                            using (_notification.PushTaskItem("Comparing database..."))
+                            {
+                                _comparer = new LocalDBComparer(new SQLiteDataBase(_masterDBFile), new SQLiteDataBase(_slaveDBFile));
+
+                                var diffs = _comparer.Compare();
+                                Differences = new ObservableCollection<Diff>(diffs);
+
+                                if (diffs.Where(x => x.Action != DiffAction.ReplaceTableDataInSlave).Count() > 0)
+                                {
+                                    ShowInfo("Found " + Differences.Where(x => x.Action != DiffAction.ReplaceTableDataInSlave).Count() + " differences.");
+                                }
+                                else
+                                {
+                                    ShowInfo("The machine database is synchronized.");
+                                }
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        ShowError(ex.Message);
+                    }
+                    finally
+                    {
+                        _isWorking = false;
+                        SelectedDifference = null;
+                        InvalidateRelayCommands();
+                    }
+                }
+            });
+        }
+
+        private void Synchronize()
+        {
+            if (IsClearMachine)
+            {
+                if (!_notification.ShowQuestion("This will erase and override the existing machine database. Do you want to proceed?"))
+                {
+                    return;
+                }
+            }
+
+            Task.Factory.StartNew(async () =>
+            {
+                using (_notification.PushTaskItem("Synchronizing..."))
+                {
+                    try
+                    {
+                        _isWorking = true;
+                        InvalidateRelayCommands();
+                        Thread.Sleep(1500);
+
+                        for (int i = 0; i < Differences.Count; i++)
+                        {
+                            var diff = Differences[i];
+
+                            diff.Commit();
+                            InvokeUINow(() => Differences.Remove(diff));
+                            i--;
+                        }
+
+                        _comparer.Dispose();
+
+                        byte[] remoteDbBytes = IsClearMachine ? File.ReadAllBytes(_masterDBFile) : File.ReadAllBytes(_slaveDBFile);
+
+                        var response = await ApplicationManager.ConnectedMachine.SendRequest<OverrideDataBaseRequest, OverrideDataBaseResponse>(new OverrideDataBaseRequest()
+                        {
+                            RemoteDB = ByteString.CopyFrom(remoteDbBytes)
+                        });
+
+                        if (!response.Message.Successful)
+                        {
+                            ShowError("The remote machine has reported some error while trying to override the database.");
+                        }
+                        else
+                        {
+                            PathHelper.TryDeleteFile(_slaveDBFile);
+                            PathHelper.TryDeleteFile(_masterDBFile);
+                            _slaveDBFile = null;
+                            _masterDBFile = null;
+                            InvalidateRelayCommands();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        ShowError(ex.Message);
+                    }
+                    finally
+                    {
+                        _isWorking = false;
+                        SelectedDifference = null;
+                        InvalidateRelayCommands();
+                    }
+                }
+            });
+        }
+
+        private void ShowError(String message)
+        {
+            InvokeUINow(() => _notification.ShowError(message));
+        }
+
+        private void ShowInfo(String message)
         {
-            Scanner = scanner;
+            InvokeUINow(() => _notification.ShowInfo(message));
         }
     }
 }