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

using System;
using System.Linq;
using System.Linq.Expressions;
using InABox.Core;
using PRSClasses;

namespace Comal.Classes
{
    [UserTracking(typeof(Requisition))]
    [Obsolete("Replaced with PickingListItem")]
    public class RequisitionItem : StockEntity, IPersistent, IRemotable, INumericAutoIncrement<RequisitionItem>, IOneToMany<Requisition>
        , ILicense<LogisticsLicense>, IJobMaterial, IJobScopedItem
    {
        [IntegerEditor(Editable = Editable.Hidden)]
        [NullEditor]
        public int Sequence { get; set; }

        [EntityRelationship(DeleteAction.Cascade)]
        [NullEditor]
        public RequisitionLink Requisition { get; set; }

        [Obsolete("Replaced by Requisition")]
        public RequisitionLink RequisitionLink
        {
            get => Requisition;
            set { }
        }

        private class StockLocationLookup : LookupDefinitionGenerator<StockLocation, RequisitionItem>
        {
            public override Filter<StockLocation> DefineFilter(RequisitionItem[] items)
            {
                var productid = items.Select(x => x.Product.ID).FirstOrDefault();
                var styleid = items.Select(x => x.Style.ID).FirstOrDefault();
                var dimensions = items.Select(x => x.Dimensions).FirstOrDefault();
                var result = Filter<StockLocation>.Where(x => x.ID).InQuery(
                    Filter<StockHolding>.Where(x => x.Product.ID).IsEqualTo(productid)
                        .And(x => x.Style.ID).IsEqualTo(styleid)
                        .And(x => x.Dimensions).DimensionEquals(dimensions)
                        .And(x => x.Qty).IsNotEqualTo(0.0),
                    x => x.Location.ID);
                return result;
            }

            public override Columns<RequisitionItem> DefineFilterColumns()
                => Columns.None<RequisitionItem>().Add(x => x.Product.ID).Add(x => x.Style.ID);
        }
        [LookupDefinition(typeof(StockLocationLookup))]
        [EditorSequence(1)]
        [RequiredColumn]
        public StockLocationLink Location { get; set; }
        
        [EditorSequence(2)]
        [RequiredColumn]
        public override ProductLink Product { get; set; }
        
        [EditorSequence(2)]
        [CodeEditor(Visible = Visible.Optional)]
        public string Code { get; set; }

        [MemoEditor]
        [EditorSequence(3)]
        public string Description { get; set; }

        [EditorSequence(4)]
        [RequiredColumn]
        public ProductStyleLink Style { get; set; }

        [EditorSequence(5)]
        [RequiredColumn]
        [DimensionsEditor(typeof(StockDimensions))]
        public override StockDimensions Dimensions { get; set; }
        
        [EntityRelationship(DeleteAction.Cascade)]
        [EditorSequence(6)]
        [RequiredColumn]
        public JobLink Job { get; set; }
        
        [Obsolete("Replaced with Job")]
        [NullEditor]
        public JobLink JobLink { get; set; }
        
        [EditorSequence(7)]
        [Caption("Required Quantity")]
        [RequiredColumn]
        public double Quantity { get; set; }

        [EditorSequence(8)]
        [RequiredColumn]
        public double ActualQuantity { get; set; }
        
        [EditorSequence(9)]
        [CurrencyEditor(Visible = Visible.Optional, Editable = Editable.Enabled)]
        [RequiredColumn]
        public double Cost { get; set; }
        
        /// <summary>
        /// This is the JRI that the stock for the Requisition is sourced from, filled if generated <i>from</i> a JRI.
        /// This can't be changed.
        /// </summary>
        [RequiredColumn]
        public JobRequisitionItemLink SourceJRI { get; set; }
        
        /// <summary>
        /// This is the JobRequisitionItem that the stock movements will be issued from; the holding JRI allocation. That is, it is the "target" JRI.<br/>
        /// This will be set when selecting holdings for this line
        /// </summary>
        [EditorSequence(9)]
        [RequiredColumn]
        public JobRequisitionItemLink JobRequisitionItem { get; set; }

        [NullEditor]
        [Obsolete("Replaced with Done")]
        public DateTime Picked { get; set; }

        [EditorSequence(10)]
        [CheckBoxEditor]
        public bool Done { get; set; }
        
        [EditorSequence("Image",1)]
        [DataModelTableName("Image")]
        public ImageDocumentLink Image { get; set; }
        
        [NullEditor]
        public string BarCode { get; set; }

        [NullEditor]
        public PickingListItemEditType EditType { get; set; }
       
        private class JobScopeLookup : LookupDefinitionGenerator<JobScope, RequisitionItem>
        {
            public override Filter<JobScope> DefineFilter(RequisitionItem[] items)
            {
                var item = items?.Length == 1 ? items[0] : null;
                if (item != null)
                    return Filter<JobScope>.Where(x => x.Job.ID).IsEqualTo(item.Requisition.Job.ID).And(x => x.Status.Approved).IsEqualTo(true);
                return Filter.None<JobScope>();
            }
            
            public override Columns<RequisitionItem> DefineFilterColumns()
                => Columns.None<RequisitionItem>().Add(x=>x.Requisition.Job.ID);
        }
        [LookupDefinition(typeof(JobScopeLookup))]
        [EditorSequence("Processing",1)]
        public JobScopeLink JobScope { get; set; }
        
        [EditorSequence("Processing",2)]
        public ActualCharge Charge { get; set; }
        
        public Expression<Func<RequisitionItem, int>> AutoIncrementField() => x => x.Sequence;
        public Filter<RequisitionItem> AutoIncrementFilter() => Filter<RequisitionItem>.Where(x => x.Requisition.ID).IsEqualTo(Requisition.ID);
        public int AutoIncrementDefault() => 1;

        static RequisitionItem()
        {
            LinkedProperties.Register<RequisitionItem, ProductLink, String>(x => x.Product, x => x.Code, x => x.Code);
            LinkedProperties.Register<RequisitionItem, ProductLink, String>(x => x.Product, x => x.Name, x => x.Description);
            LinkedProperties.Register<RequisitionItem, ProductLink, bool>(x => x.Product, x => x.Chargeable, x => x.Charge.Chargeable);
            LinkedProperties.Register<RequisitionItem, ProductStyleLink, Guid>(x=>x.Product.DefaultInstance.Style, x => x.ID, x => x.Style.ID);
            LinkedProperties.Register<RequisitionItem, StockLocationLink, Guid>(x=>x.Product.DefaultLocation, x => x.ID, x => x.Location.ID);
            StockEntity.LinkStockDimensions<RequisitionItem>();
            
            LinkedProperties.Register<RequisitionItem, JobLink, Guid>(x=>x.Requisition.Job, x => x.ID, x => x.Job.ID);
            LinkedProperties.Register<RequisitionItem, JobScopeLink, Guid>(x=>x.Requisition.JobScope, x => x.ID, x => x.JobScope.ID);
            Classes.JobScope.LinkScopeProperties<RequisitionItem>();
        }
    }
}