prs/prs.stores/BillStore.cs

using com.sun.org.glassfish.external.statistics;
using Comal.Classes;
using InABox.Configuration;
using InABox.Core;
using InABox.Database.Stores;
using InABox.Scripting;
using PRSStores;
using System;

namespace Comal.Stores;

internal class BillStore : BaseStore<Bill>
{
    protected override void BeforeSave(Bill entity)
    {
        base.BeforeSave(entity);

        if(entity.HasOriginalValue(x => x.Number) || entity.SupplierLink.HasOriginalValue(x => x.ID))
        {
            var existing = Provider.Query<Bill>(
                new Filter<Bill>(x => x.Number).IsEqualTo(entity.Number)
                    .And(x => x.SupplierLink.ID).IsEqualTo(entity.SupplierLink.ID)
                    .And(x => x.ID).IsNotEqualTo(entity.ID),
                Columns.None<Bill>().Add(x => x.ID));
            if(existing.Rows.Count > 0)
            {
                throw new DuplicateCodeException(typeof(Bill), new Dictionary<string, object> {{ nameof(Bill.Number), entity.Number }});
            }
        }

        if (entity.ID == Guid.Empty)
        {
            var defaultApprovalSet = Provider.Query<BillApprovalSet>(
                new Filter<BillApprovalSet>(x => x.IsDefault).IsEqualTo(true),
                Columns.None<BillApprovalSet>().Add(x => x.ID))
                .ToObjects<BillApprovalSet>().FirstOrDefault();
            if (defaultApprovalSet is not null)
            {
                entity.ApprovalSet.ID = defaultApprovalSet.ID;
            }
        }

        //UpdateAggregate<Supplier>(entity, entity.SupplierLink, Sum<Supplier>(b => b.Balance, s => s.Balance));
    }

    private void UpdateBillApprovals(Bill bill)
    {
        if (bill.ID == Guid.Empty || bill.ApprovalSet.ID == Guid.Empty) return;

        var setEmployees = Provider.Query(
            new Filter<BillApprovalSetEmployee>(x => x.ApprovalSet.ID).IsEqualTo(bill.ApprovalSet.ID),
            Columns.None<BillApprovalSetEmployee>().Add(x => x.Employee.ID),
            new SortOrder<BillApprovalSetEmployee>(x => x.Sequence))
            .ToArray<BillApprovalSetEmployee>();
        var approvals = Provider.Query(
            new Filter<BillApproval>(x => x.Bill.ID).IsEqualTo(bill.ID),
            Columns.Required<BillApproval>().Add(x => x.Employee.ID).Add(x => x.IsCustom).Add(x => x.Approved))
            .ToList<BillApproval>();

        try
        {
            var customApprovals = new List<BillApproval>();
            foreach(var approval in approvals)
            {
                if (approval.IsCustom)
                {
                    customApprovals.Add(approval);
                }
                else
                {
                    if(approval.Approved != DateTime.MinValue)
                    {
                        // These really are custom approvals for our purposes, since they've been modified.
                        customApprovals.Add(approval);
                    }
                }
            }

            // Build up the automatic list.
            var autoApprovals = new List<BillApproval>();
            foreach(var employee in setEmployees)
            {
                var approval = new BillApproval();
                approval.Employee.CopyFrom(employee.Employee);
                approval.IsCustom = false;
                autoApprovals.Add(approval);
            }
            if(BillApprovalSetStore.GetUpdateApprovalsScript(bill.ApprovalSet.ID) is ScriptDocument script)
            {
                script.Execute(methodname: BillApprovalSet.UpdateBillApprovalsMethodName, parameters: [bill, autoApprovals]);
            }

            // Now, we have to merge the custom and auto lists, only saving auto approvals if there are no custom ones for that employee.
            var toAdd = new List<BillApproval>();
            var toRemove = new List<BillApproval>();

            var newList = customApprovals.ToList();
            foreach(var approval in autoApprovals)
            {
                newList.Add(approval);
                if (!approvals.Any(x => x.Employee.ID == approval.Employee.ID))
                {
                    toAdd.Add(approval);
                }
            }
            foreach(var approval in approvals)
            {
                if (!newList.Any(x => x.Employee.ID == approval.Employee.ID))
                {
                    toRemove.Add(approval);
                }
            }
            foreach(var approval in toAdd)
            {
                approval.Bill.ID = bill.ID;
            }
            Provider.Save(toAdd);
            Provider.Delete(toRemove, UserID);
        }
        catch(Exception e)
        {
            CoreUtils.LogException(UserID, e, "Error running bill approval script");
        }
    }

    protected override void AfterSave(Bill entity)
    {
        base.AfterSave(entity);

        UpdateBillApprovals(entity);
    }

    protected override void BeforeDelete(Bill entity)
    {
        base.BeforeDelete(entity);

        entity.SupplierLink.ID = Guid.Empty;
        //UpdateAggregate<Supplier>(entity, entity.SupplierLink, Sum<Supplier>(b => b.Balance, s => s.Balance));
    }
}