prs/prs.classes/Entities/Requisition/Requisition.cs

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using InABox.Core;

namespace Comal.Classes
{
    [UserTracking(typeof(StockMovement))]
    [Caption("Picking List")]
    [Obsolete("Replaced with PickingList")]
    public class Requisition : Entity, IRequisition, IPersistent, IRemotable, INumericAutoIncrement<Requisition>, ILicense<ProjectManagementLicense>, IJobScopedItem
    {
        
        [EntityRelationship(DeleteAction.SetNull)]
        [NullEditor]
        [RequiredColumn]
        [LoggableProperty]
        public DeliveryLink Delivery { get; set; }

        private class DocumentsAggregate : ComplexFormulaGenerator<Requisition, int>
        {
            public override IComplexFormulaNode<Requisition, int> GetFormula() =>
                Count<RequisitionDocument, Guid>(x => x.Property(x => x.ID))
                .WithLink(x => x.Entity.ID, x => x.ID);
        }
        [ComplexFormula(typeof(DocumentsAggregate))]
        [NullEditor]
        public int Documents { get; set; }
        
        public Expression<Func<Requisition, int>> AutoIncrementField() => x => x.Number;
        public Filter<Requisition>? AutoIncrementFilter() => null;
        public int AutoIncrementDefault() => 1;

        [EditorSequence(1)]
        [IntegerEditor(Editable = Editable.Disabled)]
        public int Number { get; set; }
        
        [EditorSequence(2)]
        [DateEditor(Editable = Editable.Hidden)]
        public override DateTime Created
        {
            get => base.Created;
            set => base.Created = value;
        }
        
        [EditorSequence(3)]
        [TextBoxEditor]
        public string Title { get; set; }

        [EditorSequence(4)]
        [RequiredColumn]
        [EntityRelationship(DeleteAction.Cascade)]
        public JobLink Job { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Job")]
        public JobLink JobLink { get; set; }
        
        private class JobScopeLookup : LookupDefinitionGenerator<JobScope, Requisition>
        {
            public override Filter<JobScope> DefineFilter(Requisition[] items)
            {
                var item = items?.Length == 1 ? items[0] : null;
                if (item != null)
                    return Filter<JobScope>.Where(x => x.Job.ID).IsEqualTo(item.Job.ID).And(x => x.Status.Approved).IsEqualTo(true);
                return Filter.None<JobScope>();
            }
            
            public override Columns<Requisition> DefineFilterColumns()
                => Columns.None<Requisition>().Add(x=>x.Job.ID);
        }
        [LookupDefinition(typeof(JobScopeLookup))]
        [EditorSequence(5)]
        [EntityRelationship(DeleteAction.SetNull)]
        public JobScopeLink JobScope { get; set; }

        [EditorSequence(6)]
        public EmployeeLink RequestedBy { get; set; }
        
        [EditorSequence(7)]
        [MemoEditor]
        public string Request { get; set; }
        
        [EditorSequence(8)]
        [DateTimeEditor]
        public DateTime Due { get; set; }
        
        [EditorSequence(9)]
        public RequisitionDestinationLink Destination { get; set; }
        
        [EditorSequence("Notes",1)]
        [NotesEditor]
        public string[] Notes { get; set; } = Array.Empty<string>();
        
        [EditorSequence("Fulfilment", 1)]
        [Caption("Assigned To")]
        public EmployeeLink Employee { get; set; }
        
        [EditorSequence("Fulfilment", 2)]
        [TimestampEditor]
        public DateTime Filled { get; set; }
        
        [EditorSequence("Fulfilment", 3)]
        [IntegerEditor]
        public int Boxes { get; set; }
        
        [EditorSequence("Fulfilment", 4)]
        [LoggableProperty]
        [RequiredColumn]
        public EmployeeLink TakenBy { get; set; }
        
        [EditorSequence("Fulfilment", 5)]
        [TimestampEditor(Editable = Editable.Disabled)]
        public DateTime StockUpdated { get; set; }
        
        [EditorSequence("Fulfilment", 6)]
        [TimestampEditor(Editable = Editable.Disabled)]
        [LoggableProperty]
        public DateTime Archived { get; set; } = DateTime.MinValue;
        
        public override string ToString()
        {
            return string.Format("{0}: {1} ({2} - {3})", Number, Title, Job.JobNumber, Job.Name);
        }

        static Requisition()
        {
            LinkedProperties.Register<Requisition,JobScopeLink,Guid>(x=>x.Job.DefaultScope, x=>x.ID, x=>x.JobScope.ID);
        }
    }
}