ObservableContract.cs

using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using CommunityToolkit.Mvvm.ComponentModel;
using NeuroAccessMaui.UI.Pages.Contracts.MyContracts.ObjectModels;
using Waher.Networking.XMPP.Contracts;
 
namespace NeuroAccessMaui.UI.Pages.Contracts.ObjectModel
{
    public class ObservableContract : ObservableObject, IDisposable
    {
 
        #region Constructors and Destructor
 
        public ObservableContract(Contract contract)
        {
            this.Contract = contract;
            this.Parameters.CollectionChanged += this.Parameters_CollectionChanged;
            this.Roles.CollectionChanged += this.Roles_CollectionChanged;
        }
 
        #endregion
 
        #region Initialization
 
        public static async Task<ObservableContract> CreateAsync(Contract contract)
        {
            ObservableContract ContractWrapper = new(contract);
            await ContractWrapper.InitializeAsync();
            return ContractWrapper;
        }
 
        public async Task InitializeAsync()
        {
            this.Category = await ContractModel.GetCategory(this.Contract) ?? string.Empty;
 
            foreach (Parameter Param in this.Contract.Parameters ?? Enumerable.Empty<Parameter>())
            {
                ObservableParameter ObservableParam = await ObservableParameter.CreateAsync(Param, this.Contract);
                this.Parameters.Add(ObservableParam);
            }
 
            foreach (Role Role in this.Contract.Roles ?? Enumerable.Empty<Role>())
            {
                ObservableRole ObservableRole = new(Role);
                await ObservableRole.InitializeAsync(this.Contract);
                this.Roles.Add(ObservableRole);
            }
            if (this.IsTemplate)
            {
                foreach (Part part in this.Contract.Parts ?? Enumerable.Empty<Part>())
                {
                    ObservableRole? Role = this.Roles.FirstOrDefault(r => r.Name == part.Role);
                    if (Role is not null)
                        await Role.AddPart(part);
                }
            }
            else
            {
                foreach (ClientSignature signature in this.Contract.ClientSignatures ?? Enumerable.Empty<ClientSignature>())
                {
                    ObservableRole? Role = this.Roles.FirstOrDefault(r => r.Name == signature.Role);
                    if (Role is not null)
                        await Role.AddPart(signature);
                }
            }
 
        }
 
        #endregion
 
        #region Collection Changed Handlers
 
        private void Parameters_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Add && e.NewItems is not null)
            {
                foreach (ObservableParameter param in e.NewItems)
                {
                    param.PropertyChanged += this.Parameter_OnPropertyChanged;
                }
            }
            else if (e.Action == NotifyCollectionChangedAction.Remove && e.OldItems is not null)
            {
                foreach (ObservableParameter param in e.OldItems)
                {
                    param.PropertyChanged -= this.Parameter_OnPropertyChanged;
                }
            }
        }
 
        private void Roles_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Add && e.NewItems is not null)
            {
                foreach (ObservableRole role in e.NewItems)
                {
                    role.PropertyChanged += this.Role_OnPropertyChanged;
                    role.Parts.CollectionChanged += this.Parts_CollectionChanged;
                }
            }
            else if (e.Action == NotifyCollectionChangedAction.Remove && e.OldItems is not null)
            {
                foreach (ObservableRole role in e.OldItems)
                {
                    role.PropertyChanged -= this.Role_OnPropertyChanged;
                    role.Parts.CollectionChanged -= this.Parts_CollectionChanged;
                }
            }
        }
 
        #endregion
 
        #region Property Changed Handlers
 
        public event NotifyCollectionChangedEventHandler? PartChanged;
        private void Parts_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
        {
            this.PartChanged?.Invoke(sender, e);
        }
 
        public event PropertyChangedEventHandler? ParameterChanged;
 
        private void Parameter_OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
        {
            this.ParameterChanged?.Invoke(sender, e);
        }
 
        public event PropertyChangedEventHandler? RoleChanged;
 
        private void Role_OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
        {
            this.RoleChanged?.Invoke(sender, e);
        }
 
        #endregion
 
        #region Properties
 
        public Contract Contract { get; }
 
        public ObservableCollection<ObservableParameter> Parameters => this.parameters;
        private readonly ObservableCollection<ObservableParameter> parameters = [];
 
        public ObservableCollection<ObservableRole> Roles => this.roles;
        private readonly ObservableCollection<ObservableRole> roles = [];
 
        public string Category
        {
            get => this.category;
            private set => this.SetProperty(ref this.category, value);
        }
        private string category = string.Empty;
 
        public ContractState ContractState => this.Contract.State;
 
        public bool CanActAsTemplate => this.Contract.CanActAsTemplate;
 
        public bool IsTemplate => this.Contract.PartsMode == ContractParts.TemplateOnly;
 
        public ContractVisibility Visibility => this.Contract.Visibility;
 
        public string ContractId => this.Contract.ContractId;
 
        public string TemplateId => this.Contract.TemplateId;
 
        #endregion
                private bool disposed = false;
 
        #region IDisposable Support
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            if (this.disposed)
                return;
 
            if (disposing)
            {
                // Unsubscribe from the event to prevent memory leaks
                this.Parameters.CollectionChanged -= this.Parameters_CollectionChanged;
                this.Roles.CollectionChanged -= this.Roles_CollectionChanged;
            }
 
            this.disposed = true;
        }
        #endregion
    }
}