Software/Code_Composer/.gitignore


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using FluentFTP;
using Ionic.Zip;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using Tango.Core.Commands;
using Tango.Core.Cryptography;
using Tango.Core.Helpers;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.Common.Update;
using Tango.Settings;
using Tango.SharedUI;

namespace Tango.MachineStudio.Publisher
{
    public class MainWindowVM : ViewModel
    {
        private BasicHashGenerator _hashGenerator;
        private String _appPath = AppDomain.CurrentDomain.BaseDirectory + "..\\Release";
        private ChannelFactory<IMachineStudioUpdateService> _service;
        private IMachineStudioUpdateService _client;

        private String _email;

        public String Email
        {
            get { return _email; }
            set { _email = value; RaisePropertyChangedAuto(); }
        }

        private String _password;

        public String Password
        {
            get { return _password; }
            set { _password = value; RaisePropertyChangedAuto(); }
        }

        private String _comments;

        public String Comments
        {
            get { return _comments; }
            set { _comments = value; RaisePropertyChangedAuto(); }
        }

        private bool _forcesUpdate;

        public bool ForcedUpdate
        {
            get { return _forcesUpdate; }
            set { _forcesUpdate = value; RaisePropertyChangedAuto(); }
        }

        private String _currentVersion;

        public String CurrentVersion
        {
            get { return _currentVersion; }
            set { _currentVersion = value; RaisePropertyChangedAuto(); }
        }

        private String _latestVersion;

        public String LatestVersion
        {
            get { return _latestVersion; }
            set { _latestVersion = value; RaisePropertyChangedAuto(); }
        }

        private double _maxProgress;

        public double MaxProgress
        {
            get { return _maxProgress; }
            set { _maxProgress = value; RaisePropertyChangedAuto(); }
        }

        private double _progress;

        public double Progress
        {
            get { return _progress; }
            set { _progress = value; RaisePropertyChangedAuto(); }
        }

        private bool _isUpdating;

        public bool IsUpdating
        {
            get { return _isUpdating; }
            set { _isUpdating = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand PublishCommand { get; set; }

        public MainWindowVM()
        {
            MaxProgress = 100;

            _hashGenerator = new BasicHashGenerator();

            PublishCommand = new RelayCommand(Publish, () => Email != null && Password != null && Comments != null && CurrentVersion != null && LatestVersion != null && !IsUpdating && Version.Parse(CurrentVersion) > Version.Parse(LatestVersion));

            _service = UpdateServiceHelper.GetUpdateServiceChannel();
            _client = _service.CreateChannel();

            UpdateVersions();

            var settings = SettingsManager.Default.GetOrCreate<MachineStudioSettings>();

            Email = settings.LastLoginEmail;

            var cryptographer = new Rfc2898Cryptographer();
            Password = cryptographer.Decrypt(settings.LastLoginPassword);
        }

        private void UpdateVersions()
        {
            CurrentVersion = typeof(MainWindowVM).Assembly.GetName().Version.ToString();
            LatestVersion = _client.GetLatestVersion();
        }

        private void Publish()
        {
            if (!ShowQuestion("Did you remember to synchronize production database ?"))
            {
                return;
            }

            MaxProgress = 100;
            Progress = 0;

            Task.Factory.StartNew(() =>
            {
                IsUpdating = true;
                String tempFile = String.Empty;

                try
                {
                    var response = _client.UploadVersion(new UploadVersionRequest()
                    {
                        Email = Email,
                        Password = _hashGenerator.Encrypt(Password),
                        Version = CurrentVersion.ToString(),
                        Comments = Comments,
                        ForcedUpdate = ForcedUpdate,
                    });

                    tempFile = Path.Combine(Path.GetTempPath(), response.FileName);

                    using (ZipFile zip = new ZipFile())
                    {
                        zip.AddDirectory(Path.Combine(_appPath, "x86"), "/x86");
                        zip.AddDirectory(Path.Combine(_appPath, "x64"), "/x64");

                        foreach (var file in Directory.GetFiles(_appPath, "*.*", SearchOption.TopDirectoryOnly))
                        {
                            zip.AddFile(file, "/");
                        }

                        zip.SaveProgress += (x, e) =>
                        {
                            MaxProgress = e.TotalBytesToTransfer;
                            Progress = e.BytesTransferred;
                        };

                        zip.Save(tempFile);
                    }

                    Progress = 0;
                    MaxProgress = 100;

                    FileStreamWrapper fs = null;

                    using (fs = new FileStreamWrapper(tempFile, FileMode.Open, (current) =>
                    {
                        InvokeUINow(() =>
                        {
                            Thread.Sleep(10);
                            Progress = ((double)current / (double)fs.Length) * 100d;
                        });
                    }))
                    {
                        using (FtpClient ftp = new FtpClient(response.FtpHost, response.UserName, response.Password))
                        {
                            ftp.ConnectAsync().Wait();
                            ftp.UploadAsync(fs, response.FilePath, FtpExists.Overwrite, true).Wait();
                        }
                    }

                    _client.NotifyUploadCompleted(new UploadCompletedRequest()
                    {
                        Token = response.Token,
                    });

                    Progress = 0;
                    UpdateVersions();
                    ShowInfo("Version published successfully!");
                }
                catch (Exception ex)
                {
                    ShowError(ex.Message.ToString());
                }
                finally
                {
                    IsUpdating = false;
                    PathHelper.TryDeleteFile(tempFile);
                }
            });
        }

        private void ShowError(String error)
        {
            MessageBox.Show(error, "Machine Studio Publisher", MessageBoxButton.OK, MessageBoxImage.Error);
        }

        private void ShowInfo(String message)
        {
            MessageBox.Show(message, "Machine Studio Publisher", MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private bool ShowQuestion(String message)
        {
            return MessageBox.Show(message, "Machine Studio Publisher", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes;
        }

        protected override void RaisePropertyChangedAuto([CallerMemberName] string caller = null)
        {
            base.RaisePropertyChangedAuto(caller);
            InvalidateRelayCommands();
        }
    }
}