LegalModel.cs

using LegalLab.Extensions;
using LegalLab.Models.Standards;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Networking.XMPP.HttpFileUpload;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
 
namespace LegalLab.Models.Legal
{
    [Singleton]
    public class LegalModel : PersistedModel, IDisposable
    {
        private readonly PersistedProperty<string> firstName;
        private readonly PersistedProperty<string> middleName;
        private readonly PersistedProperty<string> lastName;
        private readonly PersistedProperty<string> personalNumber;
        private readonly PersistedProperty<string> address;
        private readonly PersistedProperty<string> address2;
        private readonly PersistedProperty<string> zip;
        private readonly PersistedProperty<string> area;
        private readonly PersistedProperty<string> city;
        private readonly PersistedProperty<string> region;
        private readonly PersistedProperty<string> country;
        private readonly PersistedProperty<string> nationality;
        private readonly PersistedProperty<string> gender;
        private readonly PersistedProperty<string> eMail;
        private readonly PersistedProperty<DateTime?> birthDate;
 
        private readonly PersistedProperty<string> orgName;
        private readonly PersistedProperty<string> orgDepartment;
        private readonly PersistedProperty<string> orgRole;
        private readonly PersistedProperty<string> orgNumber;
        private readonly PersistedProperty<string> orgAddress;
        private readonly PersistedProperty<string> orgAddress2;
        private readonly PersistedProperty<string> orgZip;
        private readonly PersistedProperty<string> orgArea;
        private readonly PersistedProperty<string> orgCity;
        private readonly PersistedProperty<string> orgRegion;
        private readonly PersistedProperty<string> orgCountry;
 
        private readonly Property<Contract> template;
        private readonly Property<TemplateReferenceModel[]> templates;
        private readonly Property<string> contractTemplateName;
 
        private readonly Dictionary<string, IdentityWrapper> identities = new();
 
        private readonly Command apply;
 
        private readonly ContractsClient contracts;
        private readonly HttpFileUploadClient httpFileUploadClient;
        private ContractModel currentContract;
 
        public LegalModel(XmppClient Client, string ComponentJid, string FileUploadJid, long? MaxFileSize)
            : base()
        {
            this.Add(this.firstName = new PersistedProperty<string>("Legal", nameof(this.FirstName), true, string.Empty, this));
            this.Add(this.middleName = new PersistedProperty<string>("Legal", nameof(this.MiddleName), true, string.Empty, this));
            this.Add(this.lastName = new PersistedProperty<string>("Legal", nameof(this.LastName), true, string.Empty, this));
            this.Add(this.personalNumber = new PersistedProperty<string>("Legal", nameof(this.PersonalNumber), true, string.Empty, this));
            this.Add(this.address = new PersistedProperty<string>("Legal", nameof(this.Address), true, string.Empty, this));
            this.Add(this.address2 = new PersistedProperty<string>("Legal", nameof(this.Address2), true, string.Empty, this));
            this.Add(this.zip = new PersistedProperty<string>("Legal", nameof(this.Zip), true, string.Empty, this));
            this.Add(this.area = new PersistedProperty<string>("Legal", nameof(this.Area), true, string.Empty, this));
            this.Add(this.city = new PersistedProperty<string>("Legal", nameof(this.City), true, string.Empty, this));
            this.Add(this.region = new PersistedProperty<string>("Legal", nameof(this.Region), true, string.Empty, this));
            this.Add(this.country = new PersistedProperty<string>("Legal", nameof(this.Country), true, string.Empty, this));
            this.Add(this.nationality = new PersistedProperty<string>("Legal", nameof(this.Nationality), true, string.Empty, this));
            this.Add(this.gender = new PersistedProperty<string>("Legal", nameof(this.Gender), true, string.Empty, this));
            this.Add(this.eMail = new PersistedProperty<string>("Legal", nameof(this.EMail), true, string.Empty, this));
            this.Add(this.birthDate = new PersistedProperty<DateTime?>("Legal", nameof(this.BirthDate), true, null, this));
 
            this.Add(this.orgName = new PersistedProperty<string>("Legal", nameof(this.OrgName), true, string.Empty, this));
            this.Add(this.orgDepartment = new PersistedProperty<string>("Legal", nameof(this.OrgDepartment), true, string.Empty, this));
            this.Add(this.orgRole = new PersistedProperty<string>("Legal", nameof(this.OrgRole), true, string.Empty, this));
            this.Add(this.orgNumber = new PersistedProperty<string>("Legal", nameof(this.OrgNumber), true, string.Empty, this));
            this.Add(this.orgAddress = new PersistedProperty<string>("Legal", nameof(this.OrgAddress), true, string.Empty, this));
            this.Add(this.orgAddress2 = new PersistedProperty<string>("Legal", nameof(this.OrgAddress2), true, string.Empty, this));
            this.Add(this.orgZip = new PersistedProperty<string>("Legal", nameof(this.OrgZip), true, string.Empty, this));
            this.Add(this.orgArea = new PersistedProperty<string>("Legal", nameof(this.OrgArea), true, string.Empty, this));
            this.Add(this.orgCity = new PersistedProperty<string>("Legal", nameof(this.OrgCity), true, string.Empty, this));
            this.Add(this.orgRegion = new PersistedProperty<string>("Legal", nameof(this.OrgRegion), true, string.Empty, this));
            this.Add(this.orgCountry = new PersistedProperty<string>("Legal", nameof(this.OrgCountry), true, string.Empty, this));
 
            this.template = new Property<Contract>(nameof(this.Template), null, this);
            this.templates = new Property<TemplateReferenceModel[]>(nameof(this.Templates), Array.Empty<TemplateReferenceModel>(), this);
            this.contractTemplateName = new Property<string>(nameof(this.ContractTemplateName), string.Empty, this);
 
            this.apply = new Command(this.CanExecuteApply, this.ExecuteApply);
 
            this.contracts = new ContractsClient(Client, ComponentJid);
            this.contracts.EnableE2eEncryption(true);
            this.contracts.IdentityUpdated += this.Contracts_IdentityUpdated;
            this.contracts.PetitionForIdentityReceived += this.Contracts_PetitionForIdentityReceived;
 
            this.httpFileUploadClient = new HttpFileUploadClient(Client, FileUploadJid, MaxFileSize);
        }
 
        public void Dispose()
        {
            this.contracts.Dispose();
        }
 
        public ContractsClient Contracts => this.contracts;
 
        public HttpFileUploadClient FileUpload => this.httpFileUploadClient;
 
        public ContractModel CurrentContract => this.currentContract;
 
        public override async Task Start()
        {
            MainWindow.UpdateGui(() =>
            {
                MainWindow.currentInstance.LegalIdTab.DataContext = this;
                MainWindow.currentInstance.ContractsTab.DataContext = this;
                MainWindow.currentInstance.ContractsTab.ContractCommands.DataContext = this;
 
                return Task.CompletedTask;
            });
 
            await this.contracts.LoadKeys(true);
 
            LegalIdentity[] Identities = await this.contracts.GetLegalIdentitiesAsync();
 
            lock (this.identities)
            {
                foreach (LegalIdentity Identity in Identities)
                    this.identities[Identity.Id] = new IdentityWrapper(this.contracts.Client.Domain, Identity);
            }
 
            this.RaisePropertyChanged(nameof(this.Identities));
 
            Dictionary<string, object> Settings = await RuntimeSettings.GetWhereKeyLikeAsync("Contract.Template.*", "*");
            List<TemplateReferenceModel> Templates = new();
 
            foreach (KeyValuePair<string, object> Setting in Settings)
            {
                if (Setting.Value is string ContractId)
                    Templates.Add(new TemplateReferenceModel(Setting.Key[18..], ContractId));
            }
 
            this.Templates = Templates.ToArray();
 
            await base.Start();
        }
 
        #region Legal Identity properties
 
        public string FirstName
        {
            get => this.firstName.Value;
            set => this.firstName.Value = value;
        }
 
        public string MiddleName
        {
            get => this.middleName.Value;
            set => this.middleName.Value = value;
        }
 
        public string LastName
        {
            get => this.lastName.Value;
            set => this.lastName.Value = value;
        }
 
        public string PersonalNumber
        {
            get => this.personalNumber.Value;
            set => this.personalNumber.Value = value;
        }
 
        public string Address
        {
            get => this.address.Value;
            set => this.address.Value = value;
        }
 
        public string Address2
        {
            get => this.address2.Value;
            set => this.address2.Value = value;
        }
 
        public string Zip
        {
            get => this.zip.Value;
            set => this.zip.Value = value;
        }
 
        public string Area
        {
            get => this.area.Value;
            set => this.area.Value = value;
        }
 
        public string City
        {
            get => this.city.Value;
            set => this.city.Value = value;
        }
 
        public string Region
        {
            get => this.region.Value;
            set => this.region.Value = value;
        }
 
        public string Country
        {
            get => this.country.Value;
            set => this.country.Value = value;
        }
 
        public static Iso_3166_1.Record[] CountryCodes => Iso_3166_1.Data;
 
        public static Iso_5218.Record[] GenderCodes => Iso_5218.Data;
 
        public string Nationality
        {
            get => this.nationality.Value;
            set => this.nationality.Value = value;
        }
 
        public string Gender
        {
            get => this.gender.Value;
            set => this.gender.Value = value;
        }
 
        public DateTime? BirthDate
        {
            get => this.birthDate.Value;
            set => this.birthDate.Value = value;
        }
 
        public string EMail
        {
            get => this.eMail.Value;
            set => this.eMail.Value = value;
        }
 
        public string OrgName
        {
            get => this.orgName.Value;
            set => this.orgName.Value = value;
        }
 
        public string OrgDepartment
        {
            get => this.orgDepartment.Value;
            set => this.orgDepartment.Value = value;
        }
 
        public string OrgRole
        {
            get => this.orgRole.Value;
            set => this.orgRole.Value = value;
        }
 
        public string OrgNumber
        {
            get => this.orgNumber.Value;
            set => this.orgNumber.Value = value;
        }
 
        public string OrgAddress
        {
            get => this.orgAddress.Value;
            set => this.orgAddress.Value = value;
        }
 
        public string OrgAddress2
        {
            get => this.orgAddress2.Value;
            set => this.orgAddress2.Value = value;
        }
 
        public string OrgZip
        {
            get => this.orgZip.Value;
            set => this.orgZip.Value = value;
        }
 
        public string OrgArea
        {
            get => this.orgArea.Value;
            set => this.orgArea.Value = value;
        }
 
        public string OrgCity
        {
            get => this.orgCity.Value;
            set => this.orgCity.Value = value;
        }
 
        public string OrgRegion
        {
            get => this.orgRegion.Value;
            set => this.orgRegion.Value = value;
        }
 
        public string OrgCountry
        {
            get => this.orgCountry.Value;
            set => this.orgCountry.Value = value;
        }
 
        #endregion
 
        #region Legal Identities
 
        public IdentityWrapper[] Identities
        {
            get
            {
                lock (this.identities)
                {
                    IdentityWrapper[] Result = new IdentityWrapper[this.identities.Count];
                    this.identities.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        private Task Contracts_IdentityUpdated(object Sender, LegalIdentityEventArgs e)
        {
            lock (this.identities)
            {
                this.identities[e.Identity.Id] = new IdentityWrapper(this.contracts.Client.Domain, e.Identity);
            }
 
            this.RaisePropertyChanged(nameof(this.Identities));
 
            return Task.CompletedTask;
        }
 
        #endregion
 
        #region Apply for new Legal Identity
 
        public ICommand Apply => this.apply;
 
        private bool CanExecuteApply()
        {
            return this.contracts.Client.State == XmppState.Connected;
        }
 
        private async Task ExecuteApply()
        {
            try
            {
                LegalIdentity[] Identities = await this.contracts.GetLegalIdentitiesAsync();
 
                foreach (LegalIdentity OldIdentity in Identities)
                {
                    if (OldIdentity.State == IdentityState.Approved)
                        await this.contracts.ObsoleteLegalIdentityAsync(OldIdentity.Id);
                }
 
                List<Property> Properties = new();
 
                AddProperty(Properties, "FIRST", this.FirstName);
                AddProperty(Properties, "MIDDLE", this.MiddleName);
                AddProperty(Properties, "LAST", this.LastName);
                AddProperty(Properties, "PNR", this.PersonalNumber);
                AddProperty(Properties, "ADDR", this.Address);
                AddProperty(Properties, "ADDR2", this.Address2);
                AddProperty(Properties, "ZIP", this.Zip);
                AddProperty(Properties, "AREA", this.Area);
                AddProperty(Properties, "CITY", this.City);
                AddProperty(Properties, "REGION", this.Region);
                AddProperty(Properties, "COUNTRY", this.Country);
                AddProperty(Properties, "NATIONALITY", this.Nationality);
                AddProperty(Properties, "GENDER", this.Gender);
                AddProperty(Properties, "EMAIL", this.EMail);
 
                if (this.BirthDate.HasValue)
                {
                    AddProperty(Properties, "BDAY", this.BirthDate.Value.Day.ToString());
                    AddProperty(Properties, "BMONTH", this.BirthDate.Value.Month.ToString());
                    AddProperty(Properties, "BYEAR", this.BirthDate.Value.Year.ToString());
                }
 
                AddProperty(Properties, "ORGNAME", this.OrgName);
                AddProperty(Properties, "ORGDEPT", this.OrgDepartment);
                AddProperty(Properties, "ORGROLE", this.OrgRole);
                AddProperty(Properties, "ORGNR", this.OrgNumber);
                AddProperty(Properties, "ORGADDR", this.OrgAddress);
                AddProperty(Properties, "ORGADDR2", this.OrgAddress2);
                AddProperty(Properties, "ORGZIP", this.OrgZip);
                AddProperty(Properties, "ORGAREA", this.OrgArea);
                AddProperty(Properties, "ORGCITY", this.OrgCity);
                AddProperty(Properties, "ORGREGION", this.OrgRegion);
                AddProperty(Properties, "ORGCOUNTRY", this.OrgCountry);
 
                AddProperty(Properties, "JID", this.contracts.Client.BareJID);
 
                LegalIdentity Identity = await this.contracts.ApplyAsync(Properties.ToArray());
 
                lock (this.identities)
                {
                    this.identities[Identity.Id] = new IdentityWrapper(this.contracts.Client.Domain, Identity);
                }
 
                this.RaisePropertyChanged(nameof(this.Identities));
            }
            catch (Exception ex)
            {
                MainWindow.ErrorBox(ex.Message);
            }
        }
 
        private static void AddProperty(List<Property> Properties, string Name, string Value)
        {
            if (!string.IsNullOrEmpty(Value))
                Properties.Add(new Property(Name, Value));
        }
 
        #endregion
 
        #region Legal Identity Petitions
 
        private Task Contracts_PetitionForIdentityReceived(object Sender, LegalIdentityPetitionEventArgs e)
        {
            StringBuilder Question = new();
 
            Question.Append("A petition for your legal identity has been received for the following purpose: ");
            Question.Append(e.Purpose);
            Question.Append(" The petition was sent by");
 
            Append(Question, e.RequestorIdentity["FIRST"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["MIDDLE"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["LAST"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["PNR"], " (", ")");
 
            Question.Append(", at");
 
            Append(Question, e.RequestorIdentity["ADDR"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["ADDR2"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["ZIP"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["AREA"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["CITY"], " ", string.Empty);
            Append(Question, e.RequestorIdentity["REGION"], " ", string.Empty);
 
            string s = e.RequestorIdentity["COUNTRY"];
            if (!string.IsNullOrEmpty(s))
            {
                if (Iso_3166_1.CodeToCountry(s, out string Country))
                    s = Country;
 
                Append(Question, s, " ", string.Empty);
            }
 
            Append(Question, e.RequestorFullJid, ", from ", string.Empty);
 
            Question.Append(". Do you want to return your identity information?");
 
            MainWindow.UpdateGui(() =>
            {
                switch (MessageBox.Show(Question.ToString(), "Petition received", MessageBoxButton.YesNoCancel, MessageBoxImage.Question, MessageBoxResult.No))
                {
                    case MessageBoxResult.Yes:
                        Task.Run(() => this.contracts.PetitionIdentityResponseAsync(e.RequestedIdentityId, e.PetitionId, e.RequestorFullJid, true));
                        break;
 
                    case MessageBoxResult.No:
                        Task.Run(() => this.contracts.PetitionIdentityResponseAsync(e.RequestedIdentityId, e.PetitionId, e.RequestorFullJid, false));
                        break;
                }
 
                return Task.CompletedTask;
            });
 
            return Task.CompletedTask;
        }
 
        private static void Append(StringBuilder Question, string Value, string PrefixIfNotEmpty, string SuffixIfNotEmpty)
        {
            if (!string.IsNullOrEmpty(Value))
            {
                Question.Append(PrefixIfNotEmpty);
                Question.Append(Value);
                Question.Append(SuffixIfNotEmpty);
            }
        }
 
        #endregion
 
        #region Create Contracts
 
        public TemplateReferenceModel[] Templates
        {
            get => this.templates.Value;
            set => this.templates.Value = value;
        }
 
        public string ContractTemplateName
        {
            get => this.contractTemplateName.Value;
            set
            {
                this.contractTemplateName.Value = value;
                MainWindow.UpdateGui(() => this.LoadTemplate(value, null));
            }
        }
 
        public async Task SetContractTemplateName(string Name, Dictionary<CaseInsensitiveString, object> PresetValues)
        {
            this.contractTemplateName.Value = Name;
            this.RaisePropertyChanged(nameof(this.ContractTemplateName));
            await this.LoadTemplate(Name, PresetValues);
        }
 
        public Contract Template
        {
            get => this.template.Value;
            set => this.template.Value = value;
        }
 
        public void ContractTemplateAdded(string TemplateName, Contract Contract)
        {
            SortedDictionary<string, TemplateReferenceModel> Templates = new();
 
            foreach (TemplateReferenceModel Ref in this.Templates)
                Templates[Ref.TemplateName] = Ref;
 
            Templates[TemplateName] = new TemplateReferenceModel(TemplateName, Contract.ContractId);
 
            this.Templates = Templates.ToValueArray();
        }
 
        private async Task LoadTemplate(string TemplateName, Dictionary<CaseInsensitiveString, object> PresetValues)
        {
            try
            {
                string ContractId = await RuntimeSettings.GetAsync("Contract.Template." + TemplateName, string.Empty);
                if (string.IsNullOrEmpty(ContractId))
                    return;
 
                MainWindow.MouseHourglass();
                this.Template = await this.contracts.GetContractAsync(ContractId);
                MainWindow.MouseDefault();
 
                if (this.currentContract is not null)
                    await this.currentContract.Stop();
 
                this.currentContract = await ContractModel.CreateAsync(this.contracts, this.Template, MainWindow.DesignModel, 
                    MainWindow.currentInstance.ContractsTab.MachineReadableXmlEditor);
                
                await this.currentContract.Start();
 
                await this.currentContract.PopulateParameters(
                    MainWindow.currentInstance.ContractsTab.LanguageOptions,
                    MainWindow.currentInstance.ContractsTab.CreateParameters, 
                    MainWindow.currentInstance.ContractsTab.CreateCommands,
                    PresetValues);
 
                await this.currentContract.PopulateContract(
                    MainWindow.currentInstance.ContractsTab.ContractToCreate, 
                    MainWindow.currentInstance.ContractsTab.ContractToCreateHumanReadable);
            }
            catch (Exception ex)
            {
                MainWindow.ErrorBox(ex.Message);
            }
        }
 
        #endregion
    }
}