prs/prs.classes/Entities/Product/ProductLookups.cs

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

namespace Comal.Classes
{
    public class ProductLookups : EntityLookup<Product>, 
        ILookupDefinition<Product, StockMovement>, 
        ILookupDefinition<Product, EmployeeProduct>,
        ILookupDefinition<Product, StagingManufacturingPacketTreatment>,
        ILookupDefinition<Product, ManufacturingTreatment>,
        ILookupDefinition<Product, BillLine>

    {
        // EmployeeProduct records also require a Default Location to pull from
        public Filter<Product> DefineFilter(EmployeeProduct[] items)
        {
            return DefineFilter().And(x => x.NonStock).IsEqualTo(false).And(x => x.DefaultLocation).LinkValid();
        }

        Columns<EmployeeProduct> ILookupDefinition<Product, EmployeeProduct>.DefineFilterColumns()
            => new Columns<EmployeeProduct>();

        // You should not be able to create a stock movement for a non-stock item
        public Filter<Product> DefineFilter(StockMovement[] items)
        {
            return DefineFilter().And(x => x.NonStock).IsEqualTo(false);
        }
        
        Columns<StockMovement> ILookupDefinition<Product, StockMovement>.DefineFilterColumns()
            => new Columns<StockMovement>();
        
        // Filters for Manufacturing Treament Codes 
        public Filter<Product> DefineFilter(StagingManufacturingPacketTreatment[] items)
        {
            var jobs = items.Select(x => x.Packet.Job.ID).Distinct().ToArray();

            if(jobs.Length == 0)
            {
                return DefineFilter().And(x => x.IsManufacturingTreatment).IsEqualTo(true);
            }
            else
            {
                var jobStyleFilters = new Filters<JobStyle>();
                foreach(var job in jobs)
                {
                    jobStyleFilters.Add(new Filter<JobStyle>(x => x.Job.ID).IsEqualTo(job));
                }
                return DefineFilter().And(x => x.IsManufacturingTreatment).IsEqualTo(true)
                    .And(x => x.ID).InQuery(
                        new Filter<ProductStyle>(x => x.ID).InQuery(jobStyleFilters.Combine(), x => x.Style.ID),
                        x => x.ManufacturingTreatmentProduct.ID);
            }
        }

        Columns<StagingManufacturingPacketTreatment> ILookupDefinition<Product, StagingManufacturingPacketTreatment>.DefineFilterColumns()
            => new Columns<StagingManufacturingPacketTreatment>(x => x.Packet.Job.ID);
        
        // Filters for Manufacturing Treament Codes 
        public Filter<Product> DefineFilter(ManufacturingTreatment[] items)
        {
            return DefineFilter().And(x => x.IsManufacturingTreatment).IsEqualTo(true);
        }

        Columns<ManufacturingTreatment> ILookupDefinition<Product, ManufacturingTreatment>.DefineFilterColumns()
            => new Columns<ManufacturingTreatment>();

        public override Columns<Product> DefineColumns()
        {
            return new Columns<Product>(
                x => x.ID,
                x => x.Code,
                x => x.Name,
                x => x.TaxCode.ID,
                x => x.PurchaseGL.ID,
                x => x.NettCost, 
                x => x.DefaultInstance.Dimensions.Unit.ID, 
                x => x.DefaultInstance.Dimensions.Unit.Code, 
                x => x.DefaultInstance.Dimensions.Unit.Description, 
                x => x.DefaultInstance.Dimensions.Unit.HasLength,
                x => x.DefaultInstance.Dimensions.Unit.HasHeight, 
                x => x.DefaultInstance.Dimensions.Unit.HasQuantity, 
                x => x.DefaultInstance.Dimensions.Unit.HasWeight, 
                x => x.DefaultInstance.Dimensions.Unit.HasWidth, 
                x => x.DefaultInstance.Dimensions.Unit.Formula, 
                x => x.DefaultInstance.Dimensions.Unit.Format, 
                x => x.DefaultInstance.Dimensions.Height, 
                x => x.DefaultInstance.Dimensions.Length, 
                x => x.DefaultInstance.Dimensions.Quantity, 
                x => x.DefaultInstance.Dimensions.Weight, 
                x => x.DefaultInstance.Dimensions.Width, 
                x => x.DefaultInstance.Dimensions.Value, 
                x => x.DefaultInstance.Dimensions.UnitSize
            );
        }
        
        public override string FormatLookup(Dictionary<string, object?> values, IEnumerable<string> exclude)
        {
            return $"{values["Name"]}";
        }

        public override Filter<Product> DefineFilter()
        {
            return new Filter<Product>(x => x.Expired).IsEqualTo(DateTime.MinValue);
        }

        public override SortOrder<Product> DefineSortOrder()
        {
            return new SortOrder<Product>(x => x.Code);
        }

        public Filter<Product> DefineFilter(BillLine[] items)
        {
            return new Filter<Product>(x => x.NonStock);
        }

        public Columns<BillLine> DefineFilterColumns()
        {
            return new Columns<BillLine>();
        }
    }
}