iWOWS/WolfOfWallStreet/ViewModels/EasyTraderControllerViewModel.cs

using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using WolfOfWallStreet.Models;
using WolfOfWallStreet.Models.EasyTrader;
using WolfOfWallStreet.Properties;
using WolfOfWallStreet.Services;
using WolfOfWallStreet.Services.Contracts;

namespace WolfOfWallStreet.ViewModels
{
    public class EasyTraderControllerViewModel : ViewModelBase
    {
        private readonly SettingsServices _settingsServices;
        private readonly IEasyTraderService _easyTraderService;
        private EasyTraderDraft easyTraderDraft;
        public EasyTraderDraft EasyTraderDraft
        {
            get { return easyTraderDraft; }
            set { SetProperty(ref easyTraderDraft, value); }
        }

        private string auth;
        public string Auth
        {
            get { return auth; }
            set { SetProperty(ref auth, value , nameof(Auth)); }
        }
        private string email;
        public string Email
        {
            get { return email; }
            set { SetProperty(ref email, value, nameof(Email)); }
        }
        private string phoneNumber;
        public string PhoneNumber
        {
            get { return phoneNumber; }
            set { SetProperty(ref phoneNumber, value, nameof(PhoneNumber)); }
        }

        public bool Ordered { get; set; } = true;
        private int server;
        public int Server
        {
            get { return server; }
            set { SetProperty(ref server, value); }
        }
        
        public ObservableCollection<Symbol> Symbols { get; set; } = new ObservableCollection<Symbol>();
        public ICommand SelectSymbolCommand { get; set; }
        public ICommand SendOrderCommand { get; set; }
        public ICommand StopOrderCommand { get; set; }
        public ICommand ClearOrdersCommand { get; set; }
        public ObservableCollection<EasyTraderOrderResult> Results { get; set; }=new ObservableCollection<EasyTraderOrderResult>();    

        public EasyTraderControllerViewModel(SettingsServices settingsServices , IEasyTraderService easyTraderService)
        {
            _settingsServices = settingsServices;
            _easyTraderService = easyTraderService;
            _settingsServices.GetSymbols().ForEach(s => Symbols.Add(s));

        }

        public override void InitialCommand()
        {
            base.InitialCommand();
            SelectSymbolCommand= new DelegateCommand<Symbol>(async symbol =>
            { 
                EasyTraderDraft = await _easyTraderService.GetSymbolOrderBase(Auth, symbol, 11000000);
            });
            SendOrderCommand = new DelegateCommand(async () =>
            {
                Ordered = true;
                for (int i = 0; i < 5; i++)
                {
                    Thread thread = new Thread(SendOrder);
                    thread.Start();
                }
            });
            StopOrderCommand = new DelegateCommand(() => { Ordered = false; });
            ClearOrdersCommand = new DelegateCommand(() => { Results.Clear(); });
        }

        async void SendOrder()
        {
            
            while (Ordered)
            {
                var res = await _easyTraderService.SendOrder(Auth, EasyTraderDraft);
                Application.Current.Dispatcher.Invoke(() => Results.Add(res));
            }
        }

        protected override bool SetProperty<T>(ref T storage, T value, string propertyName = null)
        {
            bool flag = base.SetProperty(ref storage, value, propertyName);
            if (propertyName == nameof(Auth))
            {
                DecodeJwt();
            }

            return flag;
        }

        private void DecodeJwt()
        {
            try
            {
                if (!string.IsNullOrEmpty(auth))
                {
                    var stream = auth.Replace("Bearer","").Trim();
                    /*var handler = new JwtSecurityTokenHandler();var 
                        jsonToken = handler.ReadToken(stream);
                    var tokenS = handler.ReadToken(stream) as JwtSecurityToken;*/
                    var token = new System.IdentityModel.Tokens.Jwt.JwtSecurityToken(stream);
                    Email = token.Claims.FirstOrDefault(c => c.Type == "email")?.Value;
                    PhoneNumber = token.Claims.FirstOrDefault(c => c.Type == "phone_number")?.Value;

                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }
}