prs/prs.server/Forms/DatabaseLicense/LicenseRenewalForm.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Wpf;
using InABox.WPF;
using Stripe;
using System.Diagnostics.CodeAnalysis;
using System.Windows.Controls;
using System.Drawing;
using Image = System.Windows.Controls.Image;
using System.Diagnostics;
using InABox.Configuration;

namespace PRSServer.Forms.DatabaseLicense
{
    public class CreditCardGrid : DynamicGrid<CreditCardDetails>
    {
        private static readonly EncryptedLocalConfiguration<CreditCardSettings> DetailsConfiguration = new("g6+BoQpyti5bHsTZOY5Nbqq3Q3c90n0m3qZaQ3eAwkk=");
        
        protected override void Reload(Filters<CreditCardDetails> criteria, Columns<CreditCardDetails> columns, ref SortOrder<CreditCardDetails>? sort, Action<CoreTable, Exception> action)
        {
        }
        
        private static CreditCardDetails LoadSaved()
        {
            var settings = DetailsConfiguration.Load();
            var details = new CreditCardDetails
            {
                CardNumber = settings.CardNumber,
                Month = settings.Month,
                Year = settings.Year,
                Cvv = settings.Cvv,
                // If the card number is not blank, it means we loaded from a saved file, and therefore the default should be to still save details
                SaveDetails = !string.IsNullOrWhiteSpace(settings.CardNumber)
            };
            return details;
        }
        private static void SaveDetails(CreditCardDetails details)
        {
            var settings = new CreditCardSettings
            {
                CardNumber = details.CardNumber,
                Month = details.Month,
                Year = details.Year,
                Cvv = details.Cvv
            };
            DetailsConfiguration.Save(settings);
        }
        private static void ClearDetails()
        {
            DetailsConfiguration.Delete();
        }

        public static bool DoPayment(double amount, [NotNullWhen(true)] out string? transactionID)
        {
            var details = LoadSaved();
            details.Amount = amount;

            var grid = new CreditCardGrid();
            if (grid.EditItems(new[] { details }))
            {
                if (details.SaveDetails)
                {
                    SaveDetails(details);
                }
                else
                {
                    ClearDetails();
                }
                transactionID = grid.TransactionID;
                return true;
            }
            transactionID = null;
            return false;
        }

        protected override CreditCardDetails LoadItem(CoreRow row)
        {
            return new CreditCardDetails();
        }

        private string TransactionID = "";

        protected override void DoValidate(CreditCardDetails[] items, List<string> errors)
        {
            base.DoValidate(items, errors);

            if (items.Any(x => string.IsNullOrWhiteSpace(x.CardNumber)))
                errors.Add("Please supply a card number.");
            if (items.Any(x => string.IsNullOrWhiteSpace(x.Month)))
                errors.Add("Please supply an expiration month.");
            if (items.Any(x => string.IsNullOrWhiteSpace(x.Year)))
                errors.Add("Please supply an expiration year.");
            if (items.Any(x => string.IsNullOrWhiteSpace(x.Cvv)))
                errors.Add("Please supply a CVV.");
        }

        public override void SaveItem(CreditCardDetails item)
        {
            TransactionID = "";
            var error = "";
            Progress.ShowModal("Processing Payment", (progress) =>
            {
                try
                {
                    StripeConfiguration.ApiKey = "sk_test_51MRSuPIyPMVqmkXN8TeGxDAGBeFx0pLzn3fsHBR8X1oMBKQVwGPEbuv6DNIu0qSmuflpmFfQ4N8c3vzdknKa7G0o00wTOXwCeW";
                    var cardoptions = new TokenCreateOptions()
                    {
                        Card = new TokenCardOptions()
                        {
                            Number = item.CardNumber.Replace(" ", ""),
                            ExpMonth = item.Month,
                            ExpYear = item.Year,
                            Cvc = item.Cvv
                        }
                    };
                    var service = new TokenService();
                    var token = service.Create(cardoptions);

                    var chargeoptions = new ChargeCreateOptions()
                    {
                        Amount = Convert.ToInt64(item.Amount * 100),
                        Currency = "AUD",
                        Description = "PRS Renewal",
                        Source = token.Id
                    };

                    var chargeservice = new ChargeService();
                    var charge = chargeservice.Create(chargeoptions);
                    if (charge.Paid)
                        TransactionID = charge.Id;
                    else
                        error = string.Format("{0}: {1}", charge.FailureCode, charge.FailureMessage);
                }
                catch (Exception ex)
                {
                    error = $"{ex.Message}";
                }
            });
            if (!String.IsNullOrWhiteSpace(error))
                throw new Exception(error);
        }

        protected override void DeleteItems(params CoreRow[] rows)
        {
            
        }
        protected override void Init()
        {
            
        }

        protected override void DoReconfigure(FluentList<DynamicGridOption> options)
        {
            
        }


    }
    
    /// <summary>
    ///     Interaction logic for LicenseRenewal.xaml
    /// </summary>
    public partial class LicenseRenewalForm : ThemableWindow
    {
        private LicenseData? _currentLicense;
        private double _gross;
        private double _discount;
        private DateTime _renewalAvailable;

        public LicenseData? CurrentLicense
        {
            get => _currentLicense;
            set
            {
                if(value == null)
                {
                    return;
                }

                PayWithStripe.IsEnabled = false;
                PayTooltip.Visibility = Visibility.Visible;
                PayTooltip.Content = new Label { Content = "Loading..." };

                _currentLicense = value;
                LastRenewal.Value = value.LastRenewal;
                CurrentExpiry.Value = value.Expiry;
                Modules.Renewed = value.LastRenewal;
                RenewalAvailableFrom = value.RenewalAvailable;

                Modules.Refresh(false, true);
            }
        }
        


        public int RenewalPeriod
        {
            get
            {
                if (int.TryParse(RenewalPeriodEditor.Value?.ToString(), out var period))
                {
                    return period;
                }
                return 0;
            }
            set
            {
                RenewalPeriodEditor.Value = value;
                CalculateDiscounts();
            }
        }

        public DateTime RenewalDate
        {
            get
            {
                if(CurrentLicense == null)
                {
                    return DateTime.MinValue;
                }
                if (CurrentLicense.Expiry > DateTime.Now)
                {
                    return CurrentLicense.Expiry.Date;
                }
                return DateTime.Today;
            }
        }

        public DateTime RenewalAvailableFrom
        {
            get => _renewalAvailable;
            set
            {
                _renewalAvailable = value;
                if (!CanRenew)
                {
                    RenewalAvailableLabel.Content = $"Renewal available from {value:dd MMM yyyy}";
                }
            }
        }

        public bool CanRenew => RenewalAvailableFrom.Date <= DateTime.Today || (CurrentLicense != null && CurrentLicense.Expiry <= DateTime.Now);

        public DateTime NewExpiration
        {
            get => RenewalDate.AddMonths(RenewalPeriod);
        }

        public double Gross { get => _gross; }
        public double Discount { get => _discount; }
        public double Net { get => _gross - _discount; }

        public LicenseRenewalForm()
        {
            InitializeComponent();

            LastRenewal.EditorDefinition = new DateEditor();
            LastRenewal.Configure();
            LastRenewal.IsEnabled = false;

            CurrentExpiry.EditorDefinition = new DateEditor();
            CurrentExpiry.Configure();
            CurrentExpiry.IsEnabled = false;

            RenewalPeriodEditor.EditorDefinition = new ComboLookupEditor(typeof(RenewalPeriodLookups));
            RenewalPeriodEditor.Configure();
            var lookups = new RenewalPeriodLookups(null).AsTable("RenewalPeriod");
            RenewalPeriodEditor.LoadLookups(lookups);

            NewExpiry.EditorDefinition = new DateEditor();
            NewExpiry.Configure();
            NewExpiry.IsEnabled = false;

            GrossLicenseFee.EditorDefinition = new CurrencyEditor();
            GrossLicenseFee.Configure();
            GrossLicenseFee.IsEnabled = false;

            DiscountEditor.EditorDefinition = new DoubleEditor();
            DiscountEditor.Configure();
            DiscountEditor.IsEnabled = false;

            NettLicenseFee.EditorDefinition = new CurrencyEditor();
            NettLicenseFee.Configure();
            NettLicenseFee.IsEnabled = false;

            Help.Content = new Image { Source = Properties.Resources.help.AsBitmapImage(Color.White) };
            Help.Click += Help_Click;

            Modules.AfterRefresh += ModulesRefreshed;

            //double months = Math.Max(0.0F,CalcMonths(CurrentExpiry.Value, NewExpiry.Value));
            //double total = 0.0F;
            //foreach (var row in Modules.Data.Rows)
            //    total += row.Get<LicenseRenewal, double>(x => x.ExGST) * months;
            //GrossLicenseFee.Value = total;
            ////GrossLicenseFee.Width = 150;

            //Discount.Value = LicenseUtils.GetUserDiscount(Modules.Licenses);
            ////Discount.Width = 150;
            //NettLicenseFee.Value = total * ((100.0F - Discount.Value) / 100.0F);
            ////NettLicenseFee.Width = 150;
        }

        private void Help_Click(object sender, RoutedEventArgs e)
        {
            Process.Start(new ProcessStartInfo("https://prsdigital.com.au/wiki/index.php/License_Renewal") { UseShellExecute = true });
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if (!LicenseTrackingItemGrid.LicenseClient.Ping("ping"))
            {
                MessageBox.Show("The PRS server is not available right now. Please try again later.");
                Close();
                return;
            }

            Modules.Refresh(true, false);

            var license = LoadCurrentLicense();
            if(license != null)
            {
                CurrentLicense = license;
            }

            LastRenewal.Loaded = true;
            CurrentExpiry.Loaded = true;
            NewExpiry.Loaded = true;
            RenewalPeriodEditor.Loaded = true;
        }

        private void ModulesRefreshed(object sender, AfterRefreshEventArgs args)
        {
            if (CurrentLicense == null) return;

            var lookups = new RenewalPeriodLookups(null).AsTable("RenewalPeriod");
            RenewalPeriodEditor.LoadLookups(lookups);

            RenewalPeriod = LicenseUtils.TimeDiscountLevels().OrderBy(x => x).First();
            PayWithStripe.IsEnabled = CanRenew;
            if (!PayWithStripe.IsEnabled)
            {
                PayTooltip.Visibility = Visibility.Visible;
                PayTooltip.Content = new Label { Content = $"Renewal available from {RenewalAvailableFrom:dd MMM yyyy}" };
            }
            else
            {
                PayTooltip.Visibility = Visibility.Collapsed;
            }
            OK.IsEnabled = true;
        }

        private static LicenseData? LoadCurrentLicense()
        {
            var license = new Client<License>().Query(new Filter<License>().All(), new Columns<License>(x => x.Data))
                .Rows.FirstOrDefault()?.ToObject<License>();

            if(license == null)
            {
                MessageBox.Show("No current license found. Please see the documentation on how to proceed.");
                return null;
            }
            if(!LicenseUtils.TryDecryptLicense(license.Data, out var data, out var error))
            {
                MessageBox.Show("Current license is corrupt. Please see the documentation on how to proceed.");
                return null;
            }
            return data;
        }

        private void RenewalPeriod_OnEditorValueChanged(IDynamicEditorControl sender, Dictionary<string, object> values)
        {
            CalculateDiscounts();
        }
        
        private void CalculateDiscounts()
        {
            var periodInMonths = RenewalPeriod;
            
            NewExpiry.Value = NewExpiration;
            double total = 0.0F;
            foreach (var row in Modules.Data.Rows)
                total += row.Get<LicenseTrackingItem, double>(x => x.ExGST) * periodInMonths;
            _gross = total;
            _discount = total * (LicenseUtils.GetUserDiscount(Modules.Licenses) / 100.0F) +
                        total * (LicenseUtils.GetTimeDiscount(periodInMonths) / 100.0F);

            GrossLicenseFee.Value = Gross;
            DiscountEditor.Value = Discount;
            NettLicenseFee.Value = Net;
            PayWithStripe.IsEnabled = CanRenew && Net > 0;
        }

        private class RenewalPeriodLookups : LookupGenerator<object>
        {
            public RenewalPeriodLookups(object[] items) : base(items)
            {
            }

            protected override void DoGenerateLookups()
            {
                foreach (var period in LicenseUtils.TimeDiscountLevels())
                    AddValue(period, string.Format("{0} month{1}", period, period > 1 ? "s" : ""));
            }
        }

        private License GetNewLicense(LicenseRenewal licenseRenewal)
        {
            var license = LicenseTrackingItemGrid.LicenseClient.PostRequest<License>(licenseRenewal, "RenewLicense");
            if(license == null)
            {
                throw new Exception("The server did not return a valid license.");
            }

            return license;
        }
        private void SaveLicense(License license)
        {
            using var client = new Client<License>();

            var oldLicenses = client
                .Query(new Filter<License>().All(), new Columns<License>(x => x.ID))
                .Rows.Select(x => x.ToObject<License>()).ToList();

            client.Delete(oldLicenses, "");
            client.Save(license, "");
        }

        private void PayNowClick(object sender, RoutedEventArgs e)
        {
            if (!LicenseTrackingItemGrid.LicenseClient.Ping("ping"))
            {
                MessageBox.Show("The PRS server is not available right now. Please try again later.");
                return;
            }

            var companyInformation = new Client<CompanyInformation>().Load().FirstOrDefault();
            var isCompanyEmpty = string.IsNullOrWhiteSpace(companyInformation?.CompanyName);
            var isABNEmpty = string.IsNullOrWhiteSpace(companyInformation?.ABN);
            if (companyInformation == null || (isCompanyEmpty && isABNEmpty))
            {
                MessageBox.Show("The company information for this database has not been set. Please set company information before proceeding. The company name and ABN are required. This can be done through PRS Desktop, via System -> Company Information");
                return;
            }
            else if (isCompanyEmpty)
            {
                MessageBox.Show("Please set your company's name before proceeding. This can be done through PRS Desktop, via System -> Company Information");
                return;
            }
            else if (isABNEmpty)
            {
                MessageBox.Show("Please set your company's ABN before proceeding. This can be done through PRS Desktop, via System -> Company Information");
                return;
            }

            if (!CreditCardGrid.DoPayment(Net, out var transactionID))
                return;

            /*var grid = new CreditCardGrid();
            var ccDetails = grid.LoadSaved();
            ccDetails.Amount = Net;
            if (grid.EditItems(new CreditCardDetails[] { ccDetails }))
            {
                var transactionID = grid.TransactionID;*/
            var licenseRenewal = new LicenseRenewal
            {
                Company = companyInformation,
                DateRenewed = RenewalDate,
                OldLicense = CurrentLicense,
                NewExpiry = NewExpiration,
                LicenseTracking = Modules.Data.Rows.Select(x => x.ToObject<LicenseTrackingItem>()).ToArray(),
                Gross = Gross,
                Discount = Discount,
                Net = Net,
                TransactionID = transactionID
            };
            string? error = null;
            License? license = null;
            Progress.ShowModal("Payment success, renewing license", progress =>
            {
                try
                {
                    license = GetNewLicense(licenseRenewal);
                    SaveLicense(license);
                }
                catch(Exception e)
                {
                    error = $"There was an error retrieving your new license:\n\n{e.Message}\n\nPlease contact the PRS team, and keep your transaction ID for future reference. Your transaction ID is '{transactionID}'";
                }
            });
            if(error != null)
            {
                MessageBox.Show(error);
            }
            else
            {
                MessageBox.Show("License Renewed!");

                if(!LicenseUtils.TryDecryptLicense(license.Data, out var licenseData, out error))
                {
                    MessageBox.Show(error);
                }

                CurrentLicense = licenseData ?? new LicenseData();
            }
            //}
        }

        private void OK_Click(object sender, RoutedEventArgs e)
        {
            DialogResult = true;
            Close();
        }

        private void Cancel_Click(object sender, RoutedEventArgs e)
        {
            DialogResult = false;
            Close();
        }
    }
}