Software/Visual_Studio/PPC/Tango.PPC.Publisher.UI/MainWindowVM.cs


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<<?xml version="1.0"?>

<!-- For more information on using Web.config transformation visit https://go.microsoft.com/fwlink/?LinkId=301874 -->

<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  <!--
    In the example below, the "SetAttributes" transform will change the value of
    "connectionString" to use "ReleaseSQLServer" only when the "Match" locator
    finds an attribute "name" that has a value of "MyDB".

    <connectionStrings>
      <add name="MyDB"
        connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True"
        xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
    </connectionStrings>
  -->
  <system.web>
    <!--
      In the example below, the "Replace" transform will replace the entire
      <customErrors> section of your Web.config file.
      Note that because there is only one customErrors section under the
      <system.web> node, there is no need to use the "xdt:Locator" attribute.

      <customErrors defaultRedirect="GenericError.htm"
        mode="RemoteOnly" xdt:Transform="Replace">
        <error statusCode="500" redirect="InternalError.htm"/>
      </customErrors>
    -->
  </system.web>
</configuration>
using FluentFTP;
using Ionic.Zip;
using Microsoft.Win32;
using Microsoft.WindowsAzure.Storage.Blob;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Data;
using Tango.BL;
using Tango.BL.DTO;
using Tango.BL.Entities;
using Tango.Core;
using Tango.Core.Commands;
using Tango.Core.Cryptography;
using Tango.Core.Helpers;
using Tango.Core.IO;
using Tango.PPC.Common;
using Tango.PPC.Common.Publish;
using Tango.PPC.Common.Web;
using Tango.Settings;
using Tango.SharedUI;
using Tango.SQLExaminer;
using Tango.Transport.Web;
using Tango.Web;

namespace Tango.PPC.Publisher.UI
{
    public class MainWindowVM : ViewModel
    {
        private PPCWebClient _client;
        private PPCPublisher _publisher;

        private PublishOptions _options;
        public PublishOptions Options
        {
            get { return _options; }
            set { _options = value; RaisePropertyChangedAuto(); }
        }

        private List<MachineVersionDTO> _machineVersions;
        public List<MachineVersionDTO> MachineVersions
        {
            get { return _machineVersions; }
            set { _machineVersions = value; RaisePropertyChangedAuto(); }
        }

        private MachineVersionDTO _selectedMachineVersion;
        public MachineVersionDTO SelectedMachineVersion
        {
            get { return _selectedMachineVersion; }
            set { _selectedMachineVersion = value; RaisePropertyChangedAuto(); OnSelectedMachineVersionChanged(); }
        }

        private String _localVersion;
        public String LocalVersion
        {
            get { return _localVersion; }
            set { _localVersion = value; RaisePropertyChangedAuto(); }
        }

        private String _remoteVersion;
        public String RemoteVersion
        {
            get { return _remoteVersion; }
            set { _remoteVersion = value; RaisePropertyChangedAuto(); }
        }

        private ICollectionView _provisionSequenceItemsView;
        public ICollectionView ProvisionSequenceItemsView
        {
            get { return _provisionSequenceItemsView; }
            set { _provisionSequenceItemsView = value; RaisePropertyChangedAuto(); }
        }

        private ICollectionView _updateSequenceItemsView;
        public ICollectionView UpdateSequenceItemsView
        {
            get { return _updateSequenceItemsView; }
            set { _updateSequenceItemsView = value; RaisePropertyChangedAuto(); }
        }

        private PublishProgressEventArgs _publishArgs;
        public PublishProgressEventArgs PublishArgs
        {
            get { return _publishArgs; }
            set { _publishArgs = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand PublishCommand { get; set; }

        public RelayCommand CreateTupCommand { get; set; }

        public RelayCommand FirmwareUpgradePackageBrowseCommand { get; set; }

        public MainWindowVM()
        {
            _client = new PPCWebClient();

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

            _publisher = new PPCPublisher(Options);
            _publisher.PublishProgress += _publisher_PublishProgress;

            ProvisionSequenceItemsView = CollectionViewSource.GetDefaultView(Options.Synchronization.ProvisionSequenceItems);
            ProvisionSequenceItemsView.SortDescriptions.Add(new SortDescription(nameof(SequenceItem.Index), ListSortDirection.Ascending));

            UpdateSequenceItemsView = CollectionViewSource.GetDefaultView(Options.Synchronization.UpdateSequenceItems);
            UpdateSequenceItemsView.SortDescriptions.Add(new SortDescription(nameof(SequenceItem.Index), ListSortDirection.Ascending));

            SettingsManager.Default.GetOrCreate<CoreSettings>();
            SettingsManager.Default.Save();

            PublishCommand = new RelayCommand(Publish, () => Options.Email != null && Options.Password != null && Options.Comments != null && LocalVersion != null && RemoteVersion != null && IsFree);
            CreateTupCommand = new RelayCommand(PublishTupFile);
            FirmwareUpgradePackageBrowseCommand = new RelayCommand(BrowseFirmwareUpgradePackage);

            Options.BasicInfoChanged += (_, __) => InvalidateRelayCommands();
            Options.EnvironmentChanged += async (_, __) => await OnEnvironmentChanged();
            Options.BuidConfigChanged += async (_, __) => await UpdateVersions();

            Init();
        }

        private void _publisher_PublishProgress(object sender, PublishProgressEventArgs e)
        {
            PublishArgs = e;
        }

        private async void Init()
        {
            await UpdateAvailableMachineVersions();
        }

        private async Task OnEnvironmentChanged()
        {
            IsFree = false;
            _client.Environment = Options.Environment;
            await UpdateAvailableMachineVersions();
            await UpdateVersions();
            IsFree = true;
        }

        private async Task UpdateAvailableMachineVersions()
        {
            IsFree = false;
            _machineVersions = (await _client.GetMachineVersions(new MachineVersionsRequest())).MachineVersions;
            _selectedMachineVersion = MachineVersions.OrderBy(x => x.Version).LastOrDefault();
            RaisePropertyChanged(nameof(MachineVersions));
            RaisePropertyChanged(nameof(SelectedMachineVersion));
            await OnSelectedMachineVersionChanged();
            IsFree = true;
        }

        private async Task UpdateVersions()
        {
            IsFree = false;
            LocalVersion = _publisher.GetLocalVersion();
            if (SelectedMachineVersion != null)
            {
                RemoteVersion = await _publisher.GetRemoteVersion(SelectedMachineVersion.Guid);
            }
            InvalidateRelayCommands();
            IsFree = true;
        }

        private async Task OnSelectedMachineVersionChanged()
        {
            if (SelectedMachineVersion != null) Options.MachineVersionGuid = SelectedMachineVersion.Guid;
            await UpdateVersions();
        }

        private async void Publish()
        {
            try
            {
                IsFree = false;
                SettingsManager.Default.Save();
                await _publisher.Publish();
                ShowInfo("Version published successfully.");
                await UpdateVersions();
            }
            catch (Exception ex)
            {
                ShowError(ex.FlattenMessage());
            }
            finally
            {
                IsFree = true;
            }
        }

        private async void PublishTupFile()
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Filter = "Tango Update Package|*.tup";
            dlg.DefaultExt = ".tup";
            if (dlg.ShowDialog().Value)
            {
                try
                {
                    IsFree = false;
                    await _publisher.CreateTupPackage(dlg.FileName);
                    ShowInfo("Package file created successfully!");
                }
                catch (Exception ex)
                {
                    ShowError(ex.Message);
                }
                finally
                {
                    IsFree = true;
                }
            }
        }

        private void BrowseFirmwareUpgradePackage()
        {
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Title = "Select Tango Firmware Package";
            dlg.Filter = "Tango Firmware Package Files|*.tfp";
            if (dlg.ShowDialog().Value)
            {
                Options.TfpPath = dlg.FileName;
            }
        }

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

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

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

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