using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Consoles;
using Sarand.BusinessMgr.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Utils;
using System;
using System.Collections.Generic;

namespace Sarand.BusinessMgr.Net.Standard.Base.Bus
{
    //=======================================================================
    public abstract class SbmTransaction : SbmHierarchyItem
	{
		//-------------------------------------------------------------------
		// Columns.
		public enum Column
		{
			Unknown,
			Pos,
			Id,
			//Transaction.
			Type_Desc,
			Ref,
			RefExt,
			DescBrief,
			ContactName,
			Likelihood,
			RaisedOn,
			RequiredOn,
			InProgressOn,
			ClosedOn,
			// Codes.
			ContactAreaCode, ContactArea,
			DeliveryStatusCode, DeliveryStatus,
			DeliveryTypeCode, DeliveryType,
			DeliveryMethodCode, DeliveryMethod,
			DeliveryCourierCode, DeliveryCourier,
			DeliveryBookInCode, DeliveryBookIn,
			StockPickerCode, StockPicker,
			DeliveryAmountNet, DeliveryAmountNet_Fmt,
			DeliveryTaxCodeId, DeliveryTaxCode_Code, DeliveryTaxCode_Rate,
			DeliveryAmountTax, DeliveryAmountTax_Fmt,
			DeliveryAmountTot, DeliveryAmountTot_Fmt,
			DeliveryNominalCode,
			DeliveryDepartment,
			CurrencyId, Currency_Code, Currency_Symbol,
			TaxCodeId,
			AmountEst, AmountEst_Fmt,
			AmountMax, AmountMax_Fmt,
			AmountNet, AmountNet_Fmt,
			AmountTax, AmountTax_Fmt,
			AmountTot, AmountTot_Fmt,
			TimeEst, TimeAct, TimeTot,
			StockLocation_Name,
			Weight, WeightUom_Name,
			BoxCount,
			CostLabourRateHour,
			CostTotal, CostTotal_Fmt,
			AmountMargin, AmountMargin_Fmt,
			PercentMargin, PercentMargin_Fmt,
			/// <summary>Green=Full, Amber=Partial.</summary>
			AllocationInd,
			/// <summary>Y=Full, P=Partial.</summary>
			AllocationInd_YP,
			ReplacementOrder_Tick,
			ReplacementOrder_Y,
			// Association.
			Assoc_Code,
			Assoc_AccountManagerCode, Assoc_AccountManagerDesc,
			Assoc_AccountHandlerCode, Assoc_AccountHandlerDesc,
			AssocOwner_Name, AssocTarget_Name,
			AssocTarget_PhoneMain, AssocTarget_PhoneAlt,
			AssocTarget_Address,
			AssocTarget_Address_Name,
			AssocTarget_Address_Line1, AssocTarget_Address_Line2, AssocTarget_Address_Line3,
			AssocTarget_Address_City, AssocTarget_Address_Province, AssocTarget_Address_Postcode,
			DeliveryAddress,
			DeliveryAddress_Name,
			DeliveryAddress_Line1, DeliveryAddress_Line2, DeliveryAddress_Line3,
			DeliveryAddress_City, DeliveryAddress_Province, DeliveryAddress_Postcode,
			DeliveryAddress_Phone, DeliveryAddress_Email,
			// Source transaction.
			SourceTrans_Ref,
			ReqntCount,
			TimeCount,
			TaskCount,
			/// <summary>Is referenced by corresponding type of invoice, eg. Sales invoice for sales order.</summary>
			HasInvoice,
			/// <summary>Invoice interface item reference, via raised invoice for sales order.</summary>
			AccountsInvoiceRef,
			/// <summary>Must be left at end of list for iteration.</summary>
			LastColumn,
			// Transaction Status specifics.
			/// <summary>Graphic 'tick' if on hold.</summary>
			Status_OnHold_Tick,
			/// <summary>Graphic 'X' if on hold.</summary>
			Status_OnHold_Cross,
			/// <summary>// 'Y' if on hold.</summary>
			Status_OnHold_Y,
			// Common properties.
			Notes,
			Flags,
			Status,
			Status_Ind,
			Status_Desc,
			CreateOn_Date,
			UpdateOn_Date,
		}

		//-------------------------------------------------------------------
		/// <summary>Properties other than common.</summary>
		public class DataProperties
		{
			public SysId AffiliateIdOwner { get; set; } = new SysId();
			public SysId AssociationId { get; set; } = new SysId();
			public Sbm.TransactionType TransactionType { get; set; } = Sbm.TransactionType.Unknown;
			public String Ref { get; set; } = "";
			public int RefInt { get; set; } = 0;
			public String RefExt { get; set; } = "";
			public String RaisedBy { get; set; } = "";
			public SysId AffiliateIdRaise { get; set; } = new SysId();
			public SysId AssociationIdOffice { get; set; } = new SysId();
			public String ContactName { get; set; } = "";
			public String Likelihood { get; set; } = "";
			public SysId TransactionIdSource { get; set; } = new SysId();
			public String ReferCode { get; set; } = "";
			public String ReferSource { get; set; } = "";
			public SysId AffiliateIdRefer { get; set; } = new SysId();
			public SysId AssociationIdContract { get; set; } = new SysId();
			public SysId AssociationIdDelivery { get; set; } = new SysId();
			// Status dates.
			public DateTime Raised { get; set; } = DateTime.MinValue;
			public DateTime Required { get; set; } = DateTime.MinValue;
			public DateTime InProgress { get; set; } = DateTime.MinValue;
			public DateTime DeliveredEst { get; set; } = DateTime.MinValue;
			public DateTime DeliveredAct { get; set; } = DateTime.MinValue;
			public DateTime Closed { get; set; } = DateTime.MinValue;
			public String Department { get; set; } = "";
			public String DescBrief { get; set; } = "";
			public String DescIntro { get; set; } = "";
			public String DescOutline { get; set; } = "";
			public String DescDetail { get; set; } = "";
			public String ResponseCode { get; set; } = "";
			public String ContactAreaCode { get; set; } = "";
			public String Postcode { get; set; } = "";
			public SysId CurrencyId { get; set; } = new SysId();
			// Costing.
			public SysId TaxCodeId { get; set; } = new SysId();
			public decimal AmountEst { get; set; } = 0.0m;
			public decimal AmountMax { get; set; } = 0.0m;
			public decimal AmountNet { get; set; } = 0.0m;
			public decimal AmountTax { get; set; } = 0.0m;
			public decimal AmountTot { get; set; } = 0.0m;
			public decimal TimeEst { get; set; } = 0.0m;
			public decimal TimeAct { get; set; } = 0.0m;
			public decimal TimeTot { get; set; } = 0.0m;
			// Specification.
			public SysId LocationIdStock { get; set; } = new SysId();
			public decimal Weight { get; set; } = 0.0m;
			public SysId UomIdWeight { get; set; } = new SysId();
			public String BoxCount { get; set; } = "";
			// Delivery.
			public String DeliveryStatusCode { get; set; } = "";
			public String DeliveryTypeCode { get; set; } = "";
			public String DeliveryMethodCode { get; set; } = "";
			public String DeliveryCourierCode { get; set; } = "";
			public String DeliveryBookInCode { get; set; } = "";
			public String StockPickerCode { get; set; } = "";
			public String DeliveryRef { get; set; } = "";
			public String DeliveryComment { get; set; } = "";
			public decimal DeliveryAmountNet { get; set; } = 0.0m;
			public SysId TaxCodeIdDelivery { get; set; } = new SysId();
			public decimal DeliveryAmountTax { get; set; } = 0.0m;
			public decimal DeliveryAmountTot { get; set; } = 0.0m;
			public decimal CostLabourRateHour { get; set; } = 0.0m;
			public String DeliveryDepartment { get; set; } = "";
			public String DeliveryNominalCode { get; set; } = "";
		}

		//-------------------------------------------------------------------
		// Data.
		public new class Data : SacsHierarchyItem.Data
		{
			// Data members.
			private readonly DataProperties data = new DataProperties();
			// Construction.
			public Data()
			{
				Status = DefaultStatus;
			}
			public SysId AffiliateIdOwner
			{
				get { return data.AffiliateIdOwner; }
				set { CheckChanged(data.AffiliateIdOwner, value); data.AffiliateIdOwner = value; }
			}
			public SysId AssociationId
			{
				get { return data.AssociationId; }
				set { CheckChanged(data.AssociationId, value); data.AssociationId = value; }
			}
			public Sbm.TransactionType TransactionType
			{
				get { return data.TransactionType; }
				set { CheckChanged((int)data.TransactionType, (int)value); data.TransactionType = value; }
			}
			public String Ref
			{
				get { return data.Ref; }
				set { CheckChanged(data.Ref, value); data.Ref = value; }
			}
			public int RefInt
			{
				get { return data.RefInt; }
				set { CheckChanged(data.RefInt, value); data.RefInt = value; }
			}
			public String RefExt
			{
				get { return data.RefExt; }
				set { CheckChanged(data.RefExt, value); data.RefExt = value; }
			}
			public String RaisedBy
			{
				get { return data.RaisedBy; }
				set { CheckChanged(data.RaisedBy, value); data.RaisedBy = value; }
			}
			public SysId AffiliateIdRaise
			{
				get { return data.AffiliateIdRaise; }
				set { CheckChanged(data.AffiliateIdRaise, value); data.AffiliateIdRaise = value; }
			}
			public SysId AssociationIdOffice
			{
				get { return data.AssociationIdOffice; }
				set { CheckChanged(data.AssociationIdOffice, value); data.AssociationIdOffice = value; }
			}
			public String ContactName
			{
				get { return data.ContactName; }
				set { CheckChanged(data.ContactName, value); data.ContactName = value; }
			}
			public String Likelihood
			{
				get { return data.Likelihood; }
				set { CheckChanged(data.Likelihood, value); data.Likelihood = value; }
			}
			public SysId TransactionIdSource
			{
				get { return data.TransactionIdSource; }
				set { CheckChanged(data.TransactionIdSource, value); data.TransactionIdSource = value; }
			}
			public String ReferCode
			{
				get { return data.ReferCode; }
				set { CheckChanged(data.ReferCode, value); data.ReferCode = value; }
			}
			public String ReferSource
			{
				get { return data.ReferSource; }
				set { CheckChanged(data.ReferSource, value); data.ReferSource = value; }
			}
			public SysId AffiliateIdRefer
			{
				get { return data.AffiliateIdRefer; }
				set { CheckChanged(data.AffiliateIdRefer, value); data.AffiliateIdRefer = value; }
			}
			public SysId AssociationIdContract
			{
				get { return data.AssociationIdContract; }
				set { CheckChanged(data.AssociationIdContract, value); data.AssociationIdContract = value; }
			}
			public SysId AssociationIdDelivery
			{
				get { return data.AssociationIdDelivery; }
				set { CheckChanged(data.AssociationIdDelivery, value); data.AssociationIdDelivery = value; }
			}
			// Status dates.
			public DateTime Raised
			{
				get { return data.Raised; }
				set { CheckChanged(data.Raised, value); data.Raised = value; }
			}
			public DateTime Required
			{
				get { return data.Required; }
				set { CheckChanged(data.Required, value); data.Required = value; }
			}
			public DateTime InProgress
			{
				get { return data.InProgress; }
				set { CheckChanged(data.InProgress, value); data.InProgress = value; }
			}
			public DateTime DeliveredEst
			{
				get { return data.DeliveredEst; }
				set { CheckChanged(data.DeliveredEst, value); data.DeliveredEst = value; }
			}
			public DateTime DeliveredAct
			{
				get { return data.DeliveredAct; }
				set { CheckChanged(data.DeliveredAct, value); data.DeliveredAct = value; }
			}
			public DateTime Closed
			{
				get { return data.Closed; }
				set { CheckChanged(data.Closed, value); data.Closed = value; }
			}
			public String Department
			{
				get { return data.Department; }
				set { CheckChanged(data.Department, value); data.Department = value; }
			}
			public String DescBrief
			{
				get { return data.DescBrief; }
				set { CheckChanged(data.DescBrief, value); data.DescBrief = value; }
			}
			public String DescIntro
			{
				get { return data.DescIntro; }
				set { CheckChanged(data.DescIntro, value); data.DescIntro = value; }
			}
			public String DescOutline
			{
				get { return data.DescOutline; }
				set { CheckChanged(data.DescOutline, value); data.DescOutline = value; }
			}
			public String DescDetail
			{
				get { return data.DescDetail; }
				set { CheckChanged(data.DescDetail, value); data.DescDetail = value; }
			}
			public String ResponseCode
			{
				get { return data.ResponseCode; }
				set { CheckChanged(data.ResponseCode, value); data.ResponseCode = value; }
			}
			public String ContactAreaCode
			{
				get { return data.ContactAreaCode; }
				set { CheckChanged(data.ContactAreaCode, value); data.ContactAreaCode = value; }
			}
			public String Postcode
			{
				get { return data.Postcode; }
				set { CheckChanged(data.Postcode, value); data.Postcode = value; }
			}
			public SysId CurrencyId
			{
				get { return data.CurrencyId; }
				set { CheckChanged(data.CurrencyId, value); data.CurrencyId = value; }
			}
			// Costing.
			public SysId TaxCodeId
			{
				get { return data.TaxCodeId; }
				set { CheckChanged(data.TaxCodeId, value); data.TaxCodeId = value; }
			}
			public decimal AmountEst
			{
				get { return data.AmountEst; }
				set { CheckChanged(data.AmountEst, value); data.AmountEst = value; }
			}
			public decimal AmountMax
			{
				get { return data.AmountMax; }
				set { CheckChanged(data.AmountMax, value); data.AmountMax = value; }
			}
			public decimal AmountNet
			{
				get { return data.AmountNet; }
				set { CheckChanged(data.AmountNet, value); data.AmountNet = value; }
			}
			public decimal AmountTax
			{
				get { return data.AmountTax; }
				set { CheckChanged(data.AmountTax, value); data.AmountTax = value; }
			}
			public decimal AmountTot
			{
				get { return data.AmountTot; }
				set { CheckChanged(data.AmountTot, value); data.AmountTot = value; }
			}
			public decimal TimeEst
			{
				get { return data.TimeEst; }
				set { CheckChanged(data.TimeEst, value); data.TimeEst = value; }
			}
			public decimal TimeAct
			{
				get { return data.TimeAct; }
				set { CheckChanged(data.TimeAct, value); data.TimeAct = value; }
			}
			public decimal TimeTot
			{
				get { return data.TimeTot; }
				set { CheckChanged(data.TimeTot, value); data.TimeTot = value; }
			}
			// Specification.
			public SysId LocationIdStock
			{
				get { return data.LocationIdStock; }
				set { CheckChanged(data.LocationIdStock, value); data.LocationIdStock = value; }
			}
			public decimal Weight
			{
				get { return data.Weight; }
				set { CheckChanged(data.Weight, value); data.Weight = value; }
			}
			public SysId UomIdWeight
			{
				get { return data.UomIdWeight; }
				set { CheckChanged(data.UomIdWeight, value); data.UomIdWeight = value; }
			}
			public String BoxCount
			{
				get { return data.BoxCount; }
				set { CheckChanged(data.BoxCount, value); data.BoxCount = value; }
			}
			// Delivery.
			public String DeliveryStatusCode
			{
				get { return data.DeliveryStatusCode; }
				set { CheckChanged(data.DeliveryStatusCode, value); data.DeliveryStatusCode = value; }
			}
			public String DeliveryTypeCode
			{
				get { return data.DeliveryTypeCode; }
				set { CheckChanged(data.DeliveryTypeCode, value); data.DeliveryTypeCode = value; }
			}
			public String DeliveryMethodCode
			{
				get { return data.DeliveryMethodCode; }
				set { CheckChanged(data.DeliveryMethodCode, value); data.DeliveryMethodCode = value; }
			}
			public String DeliveryCourierCode
			{
				get { return data.DeliveryCourierCode; }
				set { CheckChanged(data.DeliveryCourierCode, value); data.DeliveryCourierCode = value; }
			}
			public String DeliveryBookInCode
			{
				get { return data.DeliveryBookInCode; }
				set { CheckChanged(data.DeliveryBookInCode, value); data.DeliveryBookInCode = value; }
			}
			public String StockPickerCode
			{
				get { return data.StockPickerCode; }
				set { CheckChanged(data.StockPickerCode, value); data.StockPickerCode = value; }
			}
			public String DeliveryRef
			{
				get { return data.DeliveryRef; }
				set { CheckChanged(data.DeliveryRef, value); data.DeliveryRef = value; }
			}
			public String DeliveryComment
			{
				get { return data.DeliveryComment; }
				set { CheckChanged(data.DeliveryComment, value); data.DeliveryComment = value; }
			}
			public decimal DeliveryAmountNet
			{
				get { return data.DeliveryAmountNet; }
				set { CheckChanged(data.DeliveryAmountNet, value); data.DeliveryAmountNet = value; }
			}
			public SysId TaxCodeIdDelivery
			{
				get { return data.TaxCodeIdDelivery; }
				set { CheckChanged(data.TaxCodeIdDelivery, value); data.TaxCodeIdDelivery = value; }
			}
			public decimal DeliveryAmountTax
			{
				get { return data.DeliveryAmountTax; }
				set { CheckChanged(data.DeliveryAmountTax, value); data.DeliveryAmountTax = value; }
			}
			public decimal DeliveryAmountTot
			{
				get { return data.DeliveryAmountTot; }
				set { CheckChanged(data.DeliveryAmountTot, value); data.DeliveryAmountTot = value; }
			}
			public decimal CostLabourRateHour
			{
				get { return data.CostLabourRateHour; }
				set { CheckChanged(data.CostLabourRateHour, value); data.CostLabourRateHour = value; }
			}
			public String DeliveryDepartment
			{
				get { return data.DeliveryDepartment; }
				set { CheckChanged(data.DeliveryDepartment, value); data.DeliveryDepartment = value; }
			}
			public String DeliveryNominalCode
			{
				get { return data.DeliveryNominalCode; }
				set { CheckChanged(data.DeliveryNominalCode, value); data.DeliveryNominalCode = value; }
			}
			internal void PopulateFrom(Data data)
			{
				AffiliateIdOwner = data.AffiliateIdOwner;
				AssociationId = data.AssociationId;
				TransactionType = data.TransactionType;
				Ref = data.Ref;
				RefInt = data.RefInt;
				RefExt = data.RefExt;

				RaisedBy = data.RaisedBy;
				AffiliateIdRaise = data.AffiliateIdRaise;
				AssociationIdOffice = data.AssociationIdOffice;
				ContactName = data.ContactName;
				Likelihood = data.Likelihood;
				TransactionIdSource = data.TransactionIdSource;
				ReferCode = data.ReferCode;
				ReferSource = data.ReferSource;
				AffiliateIdRefer = data.AffiliateIdRefer;
				AssociationIdContract = data.AssociationIdContract;
				AssociationIdDelivery = data.AssociationIdDelivery;
				Raised = data.Raised;
				Required = data.Required;
				InProgress = data.InProgress;
				DeliveredEst = data.DeliveredEst;
				DeliveredAct = data.DeliveredAct;
				Closed = data.Closed;
				Department = data.Department;
				DescBrief = data.DescBrief;
				DescIntro = data.DescIntro;
				DescOutline = data.DescOutline;
				DescDetail = data.DescDetail;
				ResponseCode = data.ResponseCode;
				ContactAreaCode = data.ContactAreaCode;
				Postcode = data.Postcode;
				CurrencyId = data.CurrencyId;

				TaxCodeId = data.TaxCodeId;
				AmountEst = data.AmountEst;
				AmountMax = data.AmountMax;
				AmountNet = data.AmountNet;
				AmountTax = data.AmountTax;
				AmountTot = data.AmountTot;
				TimeEst = data.TimeEst;
				TimeAct = data.TimeAct;
				TimeTot = data.TimeTot;
				LocationIdStock = data.LocationIdStock;

				Weight = data.Weight;
				UomIdWeight = data.UomIdWeight;
				BoxCount = data.BoxCount;
				DeliveryStatusCode = data.DeliveryStatusCode;
				DeliveryTypeCode = data.DeliveryTypeCode;
				DeliveryMethodCode = data.DeliveryMethodCode;
				DeliveryCourierCode = data.DeliveryCourierCode;
				DeliveryBookInCode = data.DeliveryBookInCode;
				StockPickerCode = data.StockPickerCode;
				DeliveryRef = data.DeliveryRef;
				DeliveryComment = data.DeliveryComment;

				DeliveryAmountNet = data.DeliveryAmountNet;
				TaxCodeIdDelivery = data.TaxCodeIdDelivery;
				DeliveryAmountTax = data.DeliveryAmountTax;
				DeliveryAmountTot = data.DeliveryAmountTot;
				CostLabourRateHour = data.CostLabourRateHour;
				DeliveryDepartment = data.DeliveryDepartment;
				DeliveryNominalCode = data.DeliveryNominalCode;

				base.PopulateFrom(data);
			}
			public Data Clone()
			{
				Data data = new Data();
				data.PopulateFrom(this);
				return data;
			}
		}

		//-------------------------------------------------------------------
		public new class ErrField : SacsHierarchyItem.ErrField
		{
			// Identifies the field that has invalid data.
			public ValidValue AffiliateIdOwner { get; set; } = ValidValue.Valid;
			public ValidValue AssociationId { get; set; } = ValidValue.Valid;
			public ValidValue TransactionType { get; set; } = ValidValue.Valid;
			public ValidValue Ref { get; set; } = ValidValue.Valid;
			public ValidValue RefInt { get; set; } = ValidValue.Valid;
			public ValidValue RefExt { get; set; } = ValidValue.Valid;
			public ValidValue RaisedBy { get; set; } = ValidValue.Valid;
			public ValidValue AffiliateIdRaise { get; set; } = ValidValue.Valid;
			public ValidValue AssociationIdOffice { get; set; } = ValidValue.Valid;
			public ValidValue ContactName { get; set; } = ValidValue.Valid;
			public ValidValue Likelihood { get; set; } = ValidValue.Valid;
			public ValidValue TransactionIdSource { get; set; } = ValidValue.Valid;
			public ValidValue ReferCode { get; set; } = ValidValue.Valid;
			public ValidValue ReferSource { get; set; } = ValidValue.Valid;
			public ValidValue AffiliateIdRefer { get; set; } = ValidValue.Valid;
			public ValidValue AssociationIdContract { get; set; } = ValidValue.Valid;
			public ValidValue AssociationIdDelivery { get; set; } = ValidValue.Valid;
			public ValidValue Raised { get; set; } = ValidValue.Valid;
			public ValidValue Required { get; set; } = ValidValue.Valid;
			public ValidValue InProgress { get; set; } = ValidValue.Valid;
			public ValidValue DeliveredEst { get; set; } = ValidValue.Valid;
			public ValidValue DeliveredAct { get; set; } = ValidValue.Valid;
			public ValidValue Closed { get; set; } = ValidValue.Valid;
			public ValidValue Department { get; set; } = ValidValue.Valid;
			public ValidValue DescBrief { get; set; } = ValidValue.Valid;
			public ValidValue DescIntro { get; set; } = ValidValue.Valid;
			public ValidValue DescOutline { get; set; } = ValidValue.Valid;
			public ValidValue DescDetail { get; set; } = ValidValue.Valid;
			public ValidValue ResponseCode { get; set; } = ValidValue.Valid;
			public ValidValue ContactAreaCode { get; set; } = ValidValue.Valid;
			public ValidValue CurrencyId { get; set; } = ValidValue.Valid;
			public ValidValue TaxCodeId { get; set; } = ValidValue.Valid;
			public ValidValue AmountEst { get; set; } = ValidValue.Valid;
			public ValidValue AmountMax { get; set; } = ValidValue.Valid;
			public ValidValue AmountNet { get; set; } = ValidValue.Valid;
			public ValidValue AmountTax { get; set; } = ValidValue.Valid;
			public ValidValue AmountTot { get; set; } = ValidValue.Valid;
			public ValidValue TimeEst { get; set; } = ValidValue.Valid;
			public ValidValue TimeAct { get; set; } = ValidValue.Valid;
			public ValidValue TimeTot { get; set; } = ValidValue.Valid;
			public ValidValue LocationIdStock { get; set; } = ValidValue.Valid;
			public ValidValue Weight { get; set; } = ValidValue.Valid;
			public ValidValue UomIdWeight { get; set; } = ValidValue.Valid;
			public ValidValue BoxCount { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryStatusCode { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryTypeCode { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryMethodCode { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryCourierCode { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryBookInCode { get; set; } = ValidValue.Valid;
			public ValidValue StockPickerCode { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryRef { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryComment { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryAmountNet { get; set; } = ValidValue.Valid;
			public ValidValue TaxCodeIdDelivery { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryAmountTax { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryAmountTot { get; set; } = ValidValue.Valid;
			public ValidValue CostLabourRateHour { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryDepartment { get; set; } = ValidValue.Valid;
			public ValidValue DeliveryNominalCode { get; set; } = ValidValue.Valid;
		}

		//-------------------------------------------------------------------
		// Data members.
		private readonly Data data = new Data();
		public static readonly Byte Flag_BusinessDevelopment = 0x01;
		public static readonly Byte Flag_NetCalculatedFromTotal = 0x02;
		public static readonly Byte Flag_AutomaticallyAllocated = 0x03;
		public static readonly Byte Flag_DeliveryCalculatedFromTotal = 0x04;
		public static readonly Byte Flag_PartialAllocation = 0x05;
		public static readonly Byte Flag_FullAllocation = 0x06;
		public static readonly Byte Flag_ReplacementOrder = 0x07;

		//-------------------------------------------------------------------
		// Construction.
		protected SbmTransaction(ISbmUserContext_Core userContext, SysId id, SysId affiliateIdOwner, SysId associationId, Sbm.TransactionType transactionType) : base(userContext, id)
		{
			base.SetData(data);
			Id = id;
			AffiliateIdOwner = affiliateIdOwner;
			AssociationId = associationId;
			TransactionType = transactionType;
			Status = DefaultStatus;
		}

		//-------------------------------------------------------------------
		// Transaction status.
		public static SaStatus DefaultStatus { get { return SaStatus.Preparation; } }
		private static readonly List<SaStatus> transactionStatuses = new List<SaStatus>()
		{
			SaStatus.Preparation,
			SaStatus.Active,
			SaStatus.InProgress,
			SaStatus.Submitted,
			SaStatus.Successful,
			SaStatus.Completed,
			SaStatus.Confirmed,
			SaStatus.Failed,
			SaStatus.Accepted,
			SaStatus.Rejected,
			SaStatus.Cancelled,
		};
		public static SaStatus GetDefaultStatusForTransactionType(Sbm.TransactionType transactionType)
		{
			return DefaultStatus;
		}
		public static List<SaStatus> GetTransactionStatuses(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.Any:
				case Sbm.TransactionType.Unknown:
					return new List<SaStatus>(transactionStatuses);
				case Sbm.TransactionType.SalesLead:
					return new List<SaStatus>()
					{
						//SaStatus.Preparation,
						SaStatus.Active,
						SaStatus.Successful,
						SaStatus.Failed,
						SaStatus.Cancelled,
					};
				case Sbm.TransactionType.SalesQuote:
				case Sbm.TransactionType.PurchaseQuote:
					return new List<SaStatus>()
					{
						SaStatus.Preparation,
						SaStatus.Submitted,
						SaStatus.Accepted,
						SaStatus.Rejected,
						SaStatus.Cancelled,
					};
				case Sbm.TransactionType.SalesOrder:
					return new List<SaStatus>()
					{
						SaStatus.Preparation,
						SaStatus.InProgress,
						/*if (SbmGlobals.SessionProfile.GetOwnerOption_AllowOption(Sbm.OrgOption_AllowOption.SalesOrder_OnHold))
							SaStatus.OnHold,*/
						SaStatus.Completed,
						SaStatus.Cancelled,
					};
				case Sbm.TransactionType.Project:
				case Sbm.TransactionType.SalesPO:
				case Sbm.TransactionType.PurchaseOrder:
				case Sbm.TransactionType.PurchaseSO:
					return new List<SaStatus>()
					{
						SaStatus.Preparation,
						SaStatus.InProgress,
						SaStatus.Completed,
						SaStatus.Cancelled,
					};
				case Sbm.TransactionType.ProformaSalesOrder:
				case Sbm.TransactionType.ProformaSalesInvoice:
				case Sbm.TransactionType.ProformaPurchaseOrder:
				case Sbm.TransactionType.ProformaPurchaseInvoice:
					return new List<SaStatus>()
					{
						SaStatus.Preparation,
						SaStatus.Confirmed,
						SaStatus.Cancelled,
					};
				case Sbm.TransactionType.SalesDispatch:
				case Sbm.TransactionType.PurchaseDelivery:
					return new List<SaStatus>()
					{
						SaStatus.Preparation,
						SaStatus.Completed,
						SaStatus.Cancelled,
					};
				case Sbm.TransactionType.SalesInvoice:
				case Sbm.TransactionType.PurchaseInvoice:
					return new List<SaStatus>()
					{
						SaStatus.Preparation,
						SaStatus.Submitted,
						SaStatus.Completed,
						SaStatus.Cancelled,
					};
			}
			return new List<SaStatus>();
		}
		public static DataValue.TriStateType GetStatusTriState(SaStatus status)
		{
			switch (status)
			{
				case SaStatus.Active:
					return DataValue.TriStateType.Green;
				case SaStatus.Completed:
					return DataValue.TriStateType.Green;
				case SaStatus.OnHold:
					return DataValue.TriStateType.Amber;
				case SaStatus.InProgress:
					return DataValue.TriStateType.Amber;
				case SaStatus.Failed:
					return DataValue.TriStateType.Red;
				case SaStatus.Cancelled:
					return DataValue.TriStateType.Red;
				case SaStatus.Deleted:
					return DataValue.TriStateType.Purple;
			}
			return DataValue.TriStateType.Unknown;
		}

		//-------------------------------------------------------------------
		private static readonly List<SaStatus> dispatchStatuses = new List<SaStatus>()
		{
			SaStatus.Required,
			SaStatus.InProgress,
			SaStatus.Completed,
			SaStatus.Cancelled,
		};
		public static List<SaStatus> DispatchStatuses { get { return new List<SaStatus>(dispatchStatuses); } }

		//-------------------------------------------------------------------
		// Status Categories.
		public static List<TypeCodeDesc> GetTransactionStatusCats(ISbmUserContext_Core userContext, Sbm.TransactionType transactionType)
		{
			List<TypeCodeDesc> statusCats = new List<TypeCodeDesc>();
			List<TypeCodeDesc> statusCatsFull = SbmSystem.GetCodesOfType(userContext, Sbm.SystemCode.TransactionStatusCat);
			switch (transactionType)
			{
				// NB Changes here may also need to be made in SapTransaction::GetTaxEffectiveDate()
				// and SapphireConsole::UseInProgressTaxDateAsTaxPoint().
				// Transaction types that have no 'Pending' stage.
				case Sbm.TransactionType.SalesLead:
					statusCats.AddRange(statusCatsFull.FindAll(item => item.Type == (int)StatusCat.Open));
					statusCats.AddRange(statusCatsFull.FindAll(item => item.Type == (int)StatusCat.Closed));
					break;
				// Transaction types that have no 'Open' stage.
				case Sbm.TransactionType.ProformaSalesOrder:
				case Sbm.TransactionType.SalesDispatch:
				case Sbm.TransactionType.ProformaPurchaseOrder:
				case Sbm.TransactionType.PurchaseDelivery:
				case Sbm.TransactionType.ProformaSalesInvoice:
					statusCats.AddRange(statusCatsFull.FindAll(item => item.Type == (int)StatusCat.Pending));
					statusCats.AddRange(statusCatsFull.FindAll(item => item.Type == (int)StatusCat.Closed));
					break;
				default:
					// All other types have the complete set.
					statusCats = statusCatsFull;
					break;
			}
			return statusCats;
		}

		//-------------------------------------------------------------------
		// Utilities.
		public List<Sbm.AssociationType> GetAssociationTypes()
		{
			return GetAssociationTypes(TransactionType);
		}
		public static List<Sbm.AssociationType> GetAssociationTypes(Sbm.TransactionType transactionType)
		{
			List<Sbm.AssociationType> associationTypes = new List<Sbm.AssociationType>();
			if (SbmTransaction.IsSalesType(transactionType))
				associationTypes.Add(Sbm.AssociationType.Customer);
			else if (SbmTransaction.IsPurchaseType(transactionType))
				associationTypes.Add(Sbm.AssociationType.Supplier);
			else if (transactionType == Sbm.TransactionType.Project)
			{
				associationTypes.Add(Sbm.AssociationType.Internal);
				associationTypes.Add(Sbm.AssociationType.Associate);
				associationTypes.Add(Sbm.AssociationType.Member);
			}
			return associationTypes;
		}
		public static SysId GetTransactionTypeStatusId(Sbm.TransactionType transactionType, SbmTransaction.StatusCat transactionStatusCat)
		{
			return new SysId(((int)transactionType * 100) + (int)transactionStatusCat);
		}

		//-------------------------------------------------------------------
		public DateTime GetTaxEffectiveDate()
		{
			return GetTaxEffectiveDate(UserContext, TransactionType, Status, Raised, InProgress, Closed);
		}
		public static DateTime GetTaxEffectiveDate(ISbmUserContext_Core userContext, Sbm.TransactionType transactionType, SaStatus status, DateTime raised, DateTime inProgress, DateTime closed)
		{
			// Original thinking was that the status would have an effect on the tax point.
			SbmTransaction.StatusCat transactionStatusCat = GetCategoryForStatus(status);

			// Nov-08 Current thinking is that the only differences is whether the 'In Progress' date has been specified and whether that should be used in preference to the 'Raised' date.
			if (DateUtil.IsValid(inProgress) && (transactionStatusCat == SbmTransaction.StatusCat.Open || transactionStatusCat == SbmTransaction.StatusCat.Closed))
			{
				using (SbmSessionConsole sessionConsole = SbmGlobals.Application.CreateSessionConsole(userContext))
				{
					if (sessionConsole != null && sessionConsole.UseInProgressTaxDateAsTaxPoint(transactionType))
						return inProgress;
				}
			}
			// Otherwise, use 'Raised' date.
			if (DateUtil.IsValid(raised))
				return raised;
			return DateTime.Today;
		}

		//-------------------------------------------------------------------
		public bool RefreshTotals(List<SbmRequirement> requirements)
		{
			return RefreshTotals(requirements.ToDataList());
		}
		public bool RefreshTotals(List<SbmRequirement.Data> requirements)
		{
			// Recalculate the amounts stored against the transaction in line with the list of requirements.
			ClearErrorState();
			if (this == null) return SetErrorState("transaction not specified");
			if (!HasErrorState())
			{
				// Total weight.
				decimal totalWeight = requirements.GetTotalWeight(UomIdWeight);
				Weight = totalWeight;

				// Set the allocation status.
				ClearAllocationStatus();
				if (requirements.Count > 0)
				{
					if (requirements.IsFullAllocation()) FullAllocation = true;
					else if (requirements.IsPartialAllocation()) PartialAllocation = true;
				}

				// Calculate the totals from the list of requirements.;
				decimal newAmountNet = 0.0m;
				decimal newAmountTax = 0.0m;
				decimal newAmountTot = 0.0m;
				decimal newTimeEst = 0.0m;
				decimal newTimeAct = 0.0m;
				if (requirements.Count > 0)
					requirements.CalculateTotals(ref newAmountNet, ref newAmountTax, ref newAmountTot, ref newTimeEst, ref newTimeAct);

				// Include delivery amounts.
				newAmountNet += DeliveryAmountNet;
				newAmountTax += DeliveryAmountTax;
				newAmountTot += DeliveryAmountTot;

				// Store amounts:
				AmountNet = newAmountNet;
				AmountTax = newAmountTax;
				AmountTot = newAmountTot;
				TimeEst = newTimeEst;
				TimeAct = newTimeAct;
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		public bool RefreshRequiredDate(List<SbmRequirement> requirements, ISacsMessageConsole messageConsole)
		{
			return RefreshRequiredDate(requirements.ToDataList(), messageConsole);
		}
		public bool RefreshRequiredDate(List<SbmRequirement.Data> requirements, ISacsMessageConsole messageConsole)
		{
			// The 'Required' date on Sales Orders should not be before the earliest & 'Required' date set against unclosed requirements.
			ClearErrorState();
			if (this == null) return SetErrorState("transaction not specified");
			if (!HasErrorState() && TransactionType == Sbm.TransactionType.SalesOrder && requirements.Count > 0)
			{
				// The list must not include unclosed items whose required date is defaulted to that of the transaction:
				if (requirements.HasUnclosedItems() && !requirements.HasUnclosedItemsWithDefaultRequired())
				{
					// Check if the earliest 'Required' date against the list of unclosed requirements is later than the 'Required' date against this transaction.
					DateTime requiredEarliest = requirements.GetEarliestRequiredDateForUnclosedItems();
					if (DateUtil.IsValid(requiredEarliest) && (!DateUtil.IsValid(Required) || Required < requiredEarliest))
					{
						bool updateRequired = true;
						if (messageConsole != null)
						{
							String transactionType = SbmSystem.GetCodesOfType(UserContext, Sbm.SystemCode.TransactionStatusCat).GetDescForType(TransactionType);
							if (StringUtil.IsEmpty(transactionType)) transactionType = "Transaction";
							String message =
								"The earliest 'Required' date against unclosed\nrequirements for this " + transactionType + " is " +
								requiredEarliest.ToString() + ".\n\nDo you want to set this value against this " + transactionType + "?" +
								(DateUtil.IsValid(Required) ? "\n\nThe current required date is " + Required.ToString() : "");
							updateRequired = messageConsole.ShowMessageConfirm(message);
						}
						if (updateRequired)
						{
							// Set 'Required' date to earliest value against unclosed requirement.
							Required = requiredEarliest;
						}
					}
				}
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		public bool RefreshStatus(List<SbmRequirement> requirements, ISacsMessageConsole messageConsole)
		{
			return RefreshStatus(requirements.ToDataList(), messageConsole);
		}
		public bool RefreshStatus(List<SbmRequirement.Data> requirements, ISacsMessageConsole messageConsole)
		{
			// If the are no unclosed requirements (completed or cancelled) left against a sales order, its status should be set to 'Completed'.
			ClearErrorState();
			if (this == null) return SetErrorState("transaction not specified");
			if (!HasErrorState() && TransactionType == Sbm.TransactionType.SalesOrder && requirements.Count > 0)
			{
				// If the list of requirements no longer has un-closed items the transaction status should be set to 'Completed'.
				if (TransactionStatusCat != SbmTransaction.StatusCat.Closed && !requirements.HasUnclosedItems())
				{
					bool completeTransaction = true;
					if (messageConsole != null)
					{
						String transactionType = SbmSystem.GetCodesOfType(UserContext, Sbm.SystemCode.TransactionStatusCat).GetDescForType(TransactionType);
						if (StringUtil.IsEmpty(transactionType)) transactionType = "Transaction";
						String message =
							"All of the requirements against this " + transactionType + "\nhave been completed.\n\nSet the status to 'Completed'?";
						completeTransaction = messageConsole.ShowMessageConfirm(message);
					}
					if (completeTransaction)
					{
						// Set status to completed and set the status dates.
						Status = SaStatus.Completed;
						if (!DateUtil.IsValid(InProgress))
							InProgress = DateTime.MinValue;
						Closed = DateTime.MinValue;
					}
				}
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		public bool RefreshStatusDates()
		{
			ClearErrorState();

			// Raised date must be set.
			if (!DateUtil.IsValid(Raised)) Raised = DateTime.Today;
			if (TransactionStatusCat != SbmTransaction.StatusCat.Pending)
			{
				// In progress date must be set.
				if (!DateUtil.IsValid(InProgress)) InProgress = DateTime.Today;
				if (TransactionStatusCat == SbmTransaction.StatusCat.Closed)
				{
					if (!DateUtil.IsValid(Closed)) Closed = DateTime.Today;
				}
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		public DateTime GetStockAllocationDate(SbmRequirement requirement)
		{
			DateTime invalidDateTime = DateTime.MinValue;
			DateTime raisedDate = Raised.Date;
			DateTime inProgressDate = invalidDateTime;
			DateTime requiredDate = invalidDateTime;
			DateTime completedDate = invalidDateTime;
			if (TransactionStatusCat != SbmTransaction.StatusCat.Pending)
			{
				// In progress date.
				inProgressDate = InProgress.Date;
				// Required date.
				if (requirement != null && requirement.Required.Date.IsValid())
					requiredDate = requirement.Required.Date;
				else requiredDate = Required.Date;
			}
			if (TransactionStatusCat == SbmTransaction.StatusCat.Closed)
			{
				// Closed date.
				if (requirement != null && requirement.Completed.Date.IsValid())
					completedDate = requirement.Completed.Date;
				else completedDate = Closed.Date;
			}

			// Use whichever date is set in the following precedence order:
			DateTime stockAllocation = completedDate;
			if (!DateUtil.IsValid(stockAllocation))
				stockAllocation = requiredDate;
			if (!DateUtil.IsValid(stockAllocation))
				stockAllocation = inProgressDate;
			if (!DateUtil.IsValid(stockAllocation))
				stockAllocation = raisedDate;
			if (!DateUtil.IsValid(stockAllocation))
				stockAllocation = DateTime.Today;
			return stockAllocation;
		}
		public abstract bool IsReadOnly();
		public abstract bool DetailsAreReadOnly();

		//-------------------------------------------------------------------
		// Properties.
		public Data GetData() { return data.Clone(); }
		public void SetData(Data data)
		{
			// Properties that cannot be changed if previously specified.
			if (SysId.IsValid(Id) && SysId.ToInt(Id) != SysId.ToInt(data.Id))
				throw new NotSupportedException($"{SysUtil.Fn} Id cannot be changed");
			// Populate individual properties to ensure that 'Changed' indicator is kept up to date.
			this.data.PopulateFrom(data);
		}

		//-------------------------------------------------------------------
		// Attributes.
		public SysId AffiliateIdOwner
		{
			get { return data.AffiliateIdOwner; }
			set { data.AffiliateIdOwner = value; }
		}
		public SysId AssociationId
		{
			get { return data.AssociationId; }
			set { data.AssociationId = value; }
		}
		public Sbm.TransactionType TransactionType
		{
			get { return data.TransactionType; }
			set { data.TransactionType = value; }
		}

		public static Sbm.TransactionType GetAlternativeType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.SalesOrder: return Sbm.TransactionType.SalesOrder;
				case Sbm.TransactionType.ProformaSalesOrder: return Sbm.TransactionType.ProformaSalesOrder;
				case Sbm.TransactionType.SalesInvoice: return Sbm.TransactionType.SalesInvoice;
				case Sbm.TransactionType.ProformaSalesInvoice: return Sbm.TransactionType.ProformaSalesInvoice;
				case Sbm.TransactionType.PurchaseOrder: return Sbm.TransactionType.PurchaseOrder;
				case Sbm.TransactionType.ProformaPurchaseOrder: return Sbm.TransactionType.ProformaPurchaseOrder;
				case Sbm.TransactionType.PurchaseInvoice: return Sbm.TransactionType.PurchaseInvoice;
				case Sbm.TransactionType.ProformaPurchaseInvoice: return Sbm.TransactionType.ProformaPurchaseInvoice;
			}
			return Sbm.TransactionType.Unknown;
		}

		public static bool IsSalesType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.SalesLead:
				case Sbm.TransactionType.SalesQuote:
				case Sbm.TransactionType.ProformaSalesOrder:
				case Sbm.TransactionType.SalesOrder:
				case Sbm.TransactionType.SalesPO:
				case Sbm.TransactionType.SalesDispatch:
				case Sbm.TransactionType.ProformaSalesInvoice:
				case Sbm.TransactionType.SalesInvoice:
					return true;
			}
			return false;
		}
		public static bool IsPurchaseType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.PurchaseQuote:
				case Sbm.TransactionType.PurchaseSO:
				case Sbm.TransactionType.ProformaPurchaseOrder:
				case Sbm.TransactionType.PurchaseOrder:
				case Sbm.TransactionType.PurchaseDelivery:
				case Sbm.TransactionType.ProformaPurchaseInvoice:
				case Sbm.TransactionType.PurchaseInvoice:
					return true;
			}
			return false;
		}
		public static bool IsProformaType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.ProformaSalesOrder:
				case Sbm.TransactionType.ProformaSalesInvoice:
				case Sbm.TransactionType.ProformaPurchaseOrder:
				case Sbm.TransactionType.ProformaPurchaseInvoice:
					return true;
			}
			return false;
		}
		public static bool IsQuoteType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.SalesQuote:
				case Sbm.TransactionType.PurchaseQuote:
					return true;
			}
			return false;
		}
		public static bool IsOrderType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.ProformaSalesOrder:
				case Sbm.TransactionType.SalesOrder:
				case Sbm.TransactionType.ProformaPurchaseOrder:
				case Sbm.TransactionType.PurchaseOrder:
					return true;
			}
			return false;
		}
		public static bool IsDeliveryType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.SalesDispatch:
				case Sbm.TransactionType.PurchaseDelivery:
					return true;
			}
			return false;
		}
		public static bool IsInvoiceType(Sbm.TransactionType transactionType)
		{
			switch (transactionType)
			{
				case Sbm.TransactionType.ProformaSalesInvoice:
				case Sbm.TransactionType.SalesInvoice:
				case Sbm.TransactionType.ProformaPurchaseInvoice:
				case Sbm.TransactionType.PurchaseInvoice:
					return true;
			}
			return false;
		}
		public static bool AreEquivalentTypes(Sbm.TransactionType transactionType1, Sbm.TransactionType transactionType2)
		{
			// Identical transaction types or corresponding proforma:
			if (transactionType1 == transactionType2) return true;
			if (transactionType1 == Sbm.TransactionType.SalesOrder && transactionType2 == Sbm.TransactionType.ProformaSalesOrder) return true;
			if (transactionType1 == Sbm.TransactionType.ProformaSalesOrder && transactionType2 == Sbm.TransactionType.SalesOrder) return true;
			if (transactionType1 == Sbm.TransactionType.SalesInvoice && transactionType2 == Sbm.TransactionType.ProformaSalesInvoice) return true;
			if (transactionType1 == Sbm.TransactionType.ProformaSalesInvoice && transactionType2 == Sbm.TransactionType.SalesInvoice) return true;
			if (transactionType1 == Sbm.TransactionType.PurchaseOrder && transactionType2 == Sbm.TransactionType.ProformaPurchaseOrder) return true;
			if (transactionType1 == Sbm.TransactionType.ProformaPurchaseOrder && transactionType2 == Sbm.TransactionType.PurchaseOrder) return true;
			return false;
		}



		public String Ref
		{
			get { return data.Ref; }
			set { data.Ref = value; }
		}
		public int RefInt
		{
			get { return data.RefInt; }
			set { data.RefInt = value; }
		}
		public String RefExt
		{
			get { return data.RefExt; }
			set { data.RefExt = value; }
		}
		public String RaisedBy
		{
			get { return data.RaisedBy; }
			set { data.RaisedBy = value; }
		}
		public SysId AffiliateIdRaise
		{
			get { return data.AffiliateIdRaise; }
			set { data.AffiliateIdRaise = value; }
		}
		public SysId AssociationIdOffice
		{
			get { return data.AssociationIdOffice; }
			set { data.AssociationIdOffice = value; }
		}
		public String ContactName
		{
			get { return data.ContactName; }
			set { data.ContactName = value; }
		}
		public String Likelihood
		{
			get { return data.Likelihood; }
			set { data.Likelihood = value; }
		}
		public SysId TransactionIdSource
		{
			get { return data.TransactionIdSource; }
			set { data.TransactionIdSource = value; }
		}
		public String ReferCode
		{
			get { return data.ReferCode; }
			set { data.ReferCode = value; }
		}
		public String ReferSource
		{
			get { return data.ReferSource; }
			set { data.ReferSource = value; }
		}
		public SysId AffiliateIdRefer
		{
			get { return data.AffiliateIdRefer; }
			set { data.AffiliateIdRefer = value; }
		}
		public SysId AssociationIdContract
		{
			get { return data.AssociationIdContract; }
			set { data.AssociationIdContract = value; }
		}
		public SysId AssociationIdDelivery
		{
			get { return data.AssociationIdDelivery; }
			set { data.AssociationIdDelivery = value; }
		}
		public DateTime Raised
		{
			get { return data.Raised; }
			set { data.Raised = value; }
		}
		public DateTime Required
		{
			get { return data.Required; }
			set { data.Required = value; }
		}
		public DateTime InProgress
		{
			get { return data.InProgress; }
			set { data.InProgress = value; }
		}
		public DateTime DeliveredEst
		{
			get { return data.DeliveredEst; }
			set { data.DeliveredEst = value; }
		}
		public DateTime DeliveredAct
		{
			get { return data.DeliveredAct; }
			set { data.DeliveredAct = value; }
		}
		public DateTime Closed
		{
			get { return data.Closed; }
			set { data.Closed = value; }
		}
		public String Department
		{
			get { return data.Department; }
			set { data.Department = value; }
		}
		public String DescBrief
		{
			get { return data.DescBrief; }
			set { data.DescBrief = value; }
		}
		public String DescIntro
		{
			get { return data.DescIntro; }
			set { data.DescIntro = value; }
		}
		public String DescOutline
		{
			get { return data.DescOutline; }
			set { data.DescOutline = value; }
		}
		public String DescDetail
		{
			get { return data.DescDetail; }
			set { data.DescDetail = value; }
		}
		public String ResponseCode
		{
			get { return data.ResponseCode; }
			set { data.ResponseCode = value; }
		}
		public String ContactAreaCode
		{
			get { return data.ContactAreaCode; }
			set { data.ContactAreaCode = value; }
		}
		public String Postcode
		{
			get { return data.Postcode; }
			set { data.Postcode = value; }
		}
		public SysId CurrencyId
		{
			get { return data.CurrencyId; }
			set { data.CurrencyId = value; }
		}
		public SysId TaxCodeId
		{
			get { return data.TaxCodeId; }
			set { data.TaxCodeId = value; }
		}
		public decimal AmountEst
		{
			get { return data.AmountEst; }
			set { data.AmountEst = value; }
		}
		public decimal AmountMax
		{
			get { return data.AmountMax; }
			set { data.AmountMax = value; }
		}
		public decimal AmountNet
		{
			get { return data.AmountNet; }
			set { data.AmountNet = value; }
		}
		public decimal AmountTax
		{
			get { return data.AmountTax; }
			set { data.AmountTax = value; }
		}
		public decimal AmountTot
		{
			get { return data.AmountTot; }
			set { data.AmountTot = value; }
		}
		public decimal TimeEst
		{
			get { return data.TimeEst; }
			set { data.TimeEst = value; }
		}
		public decimal TimeAct
		{
			get { return data.TimeAct; }
			set { data.TimeAct = value; }
		}
		public decimal TimeTot
		{
			get { return data.TimeTot; }
			set { data.TimeTot = value; }
		}
		public SysId LocationIdStock
		{
			get { return data.LocationIdStock; }
			set { data.LocationIdStock = value; }
		}
		public decimal Weight
		{
			get { return data.Weight; }
			set { data.Weight = value; }
		}
		public SysId UomIdWeight
		{
			get { return data.UomIdWeight; }
			set { data.UomIdWeight = value; }
		}
		public String BoxCount
		{
			get { return data.BoxCount; }
			set { data.BoxCount = value; }
		}
		public String DeliveryStatusCode
		{
			get { return data.DeliveryStatusCode; }
			set { data.DeliveryStatusCode = value; }
		}
		public String DeliveryTypeCode
		{
			get { return data.DeliveryTypeCode; }
			set { data.DeliveryTypeCode = value; }
		}
		public String DeliveryMethodCode
		{
			get { return data.DeliveryMethodCode; }
			set { data.DeliveryMethodCode = value; }
		}
		public String DeliveryCourierCode
		{
			get { return data.DeliveryCourierCode; }
			set { data.DeliveryCourierCode = value; }
		}
		public String DeliveryBookInCode
		{
			get { return data.DeliveryBookInCode; }
			set { data.DeliveryBookInCode = value; }
		}
		public String StockPickerCode
		{
			get { return data.StockPickerCode; }
			set { data.StockPickerCode = value; }
		}
		public String DeliveryRef
		{
			get { return data.DeliveryRef; }
			set { data.DeliveryRef = value; }
		}
		public String DeliveryComment
		{
			get { return data.DeliveryComment; }
			set { data.DeliveryComment = value; }
		}
		public decimal DeliveryAmountNet
		{
			get { return data.DeliveryAmountNet; }
			set { data.DeliveryAmountNet = value; }
		}
		public SysId TaxCodeIdDelivery
		{
			get { return data.TaxCodeIdDelivery; }
			set { data.TaxCodeIdDelivery = value; }
		}
		public decimal DeliveryAmountTax
		{
			get { return data.DeliveryAmountTax; }
			set { data.DeliveryAmountTax = value; }
		}
		public decimal DeliveryAmountTot
		{
			get { return data.DeliveryAmountTot; }
			set { data.DeliveryAmountTot = value; }
		}
		public decimal CostLabourRateHour
		{
			get { return data.CostLabourRateHour; }
			set { data.CostLabourRateHour = value; }
		}
		public String DeliveryDepartment
		{
			get { return data.DeliveryDepartment; }
			set { data.DeliveryDepartment = value; }
		}
		public String DeliveryNominalCode
		{
			get { return data.DeliveryNominalCode; }
			set { data.DeliveryNominalCode = value; }
		}

		//-------------------------------------------------------------------
		// Status category.
		public static SbmTransaction.StatusCat GetCategoryForStatus(SaStatus saStatus)
		{
			SbmTransaction.StatusCat category = SbmTransaction.StatusCat.Closed;
			switch (saStatus)
			{
				case SaStatus.Preparation:
					category = SbmTransaction.StatusCat.Pending;
					break;
				case SaStatus.Active:
				case SaStatus.InProgress:
				case SaStatus.OnHold:
				case SaStatus.Submitted:
					category = SbmTransaction.StatusCat.Open;
					break;
				default:
					category = SbmTransaction.StatusCat.Closed;
					break;
			}
			return category;
		}
		public SbmTransaction.StatusCat TransactionStatusCat
		{
			get { return GetCategoryForStatus(Status); }
		}

		//-------------------------------------------------------------------
		// Flags.
		public bool BusinessDevelopment
		{
			get { return GetFlag(Flag_BusinessDevelopment); }
			set { SetFlag(Flag_BusinessDevelopment, value); }
		}
		public bool NetCalculatedFromTotal
		{
			get { return GetFlag(Flag_NetCalculatedFromTotal); }
			set { SetFlag(Flag_NetCalculatedFromTotal, value); }
		}
		public bool AutomaticallyAllocated
		{
			get { return GetFlag(Flag_AutomaticallyAllocated); }
			set { SetFlag(Flag_AutomaticallyAllocated, value); }
		}
		public bool DeliveryCalculatedFromTotal
		{
			get { return GetFlag(Flag_DeliveryCalculatedFromTotal); }
			set { SetFlag(Flag_DeliveryCalculatedFromTotal, value); }
		}
		public bool PartialAllocation
		{
			get { return GetFlag(Flag_PartialAllocation); }
			set
			{
				SetFlag(Flag_PartialAllocation, value);
				if (value) FullAllocation = false;
			}
		}
		public bool FullAllocation
		{
			get { return GetFlag(Flag_FullAllocation); }
			set
			{
				SetFlag(Flag_FullAllocation, value);
				if (value) PartialAllocation = false;
			}
		}
		public void ClearAllocationStatus()
		{
			PartialAllocation = false;
			FullAllocation = false;
		}
		public bool ReplacementOrder
		{
			get { return GetFlag(Flag_ReplacementOrder); }
			set { SetFlag(Flag_ReplacementOrder, value); }
		}
		//-------------------------------------------------------------------
		public Sbm.ItemStockAllocationStatus GetStockAllocationStatus()
		{
			// Derived from allocations flags.
			if (FullAllocation) return Sbm.ItemStockAllocationStatus.Full;
			if (PartialAllocation) return Sbm.ItemStockAllocationStatus.Partial;
			return Sbm.ItemStockAllocationStatus.None;
		}
		public void SetDefaults(SbmRequirement requirement)
		{
			if (this == null || requirement != null) return;

			// Requirement must not be 'Closed':
			// Sarand Feb-08 - continue to default required date even after requirement is closed.
			//if (requirement. GetStatusCat() == eSapReqStacClosed) return;

			// Intecept requirements without 'Required' date and default to value set against transaction:
			if (requirement.RequiredDateDefaulted || !DateUtil.IsValid(requirement.Required))
			{
				// Bring the requirement into line with the transaction,
				// even if the transaction has no required date:
				requirement.Required = Required;
				requirement.RequiredDateDefaulted = true;
			}
		}

		//-------------------------------------------------------------------
		//          A s s o c i a t e d   D a t a   E l e m e n t s          
		//-------------------------------------------------------------------
		public abstract bool IsReferencedByOtherTransactions();
		public abstract bool HasRequirements(SbmRequirement.StatusCat requirementStatusCat = SbmRequirement.StatusCat.NotDeleted);
		public abstract bool HasConstituents(SbmConstituent.StatusCat constituentStatusCat = SbmConstituent.StatusCat.NotDeleted);
		public abstract bool HasContainerItems();
		public abstract bool HasStockMovements();
		public abstract bool HasPendingStockMovements();
		public abstract bool HasDiaryLinks();
		//public abstract void SetDefaults(class SbmRequirement *) const;
		public abstract long GetRequirementCount(SbmRequirement.StatusCat requirementStatusCat = SbmRequirement.StatusCat.NotDeleted);
		public abstract List<SbmRequirement> GetRequirements(SbmRequirement.StatusCat requirementStatusCat = SbmRequirement.StatusCat.NotDeleted);
		public abstract bool ItemsRequireJobNumber();
		public abstract bool UpdateRequirements(List<SbmRequirement> requirements);
		public abstract bool CommitAssociatedData();
		//-------------------------------------------------------------------
		public abstract bool ClearDependentData();
		//-------------------------------------------------------------------
		// Payments.
		public abstract bool HasPayments();
		public abstract List<SbmTransactionPayment> GetPayments();
		public abstract bool SetPayments(List<SbmTransactionPayment> transactionPaymentsNew);
		public abstract bool CommitPayments();

		//-------------------------------------------------------------------
		//                            P a r a m s
		//-------------------------------------------------------------------
		/// <summary>Parameters - used to define the filters that should be applied to a List of Transactions</summary>
		// List parameters.
		public enum StatusCat
		{
			/// <summary>Pending or open</summary>
			NotClosed = -4,
			/// <summary>Anything but 'Cancelled' status</summary>
			NotCancelled = -3,
			/// <summary>'Completed' only</summary>
			Completed = -2,
			/// <summary>Any, or Unknown status.</summary>
			Any = 0,
			/// <summary>Database value: Preparation</summary>
			Pending = 1,
			/// <summary>Database value: In Progress</summary>
			Open = 2,
			/// <summary>Database value: Completed, Cancelled</summary>
			Closed = 3,
			NotDeleted = -99,
			Default = NotDeleted,
		}
		/// <summary>Item list parameters.</summary>
		public new class Params : SacsHierarchyItem.Params
		{
			// List filtering.
			public List<SysId> IdsIncluded { get; set; } = new List<SysId>();
			public List<SysId> IdsExcluded { get; set; } = new List<SysId>();
			// Transaction.
			public SysId AssocId { get; set; }
			public SysId TransIdSource { get; set; }
			public Sbm.TransactionType TransactionType { get; set; } = Sbm.TransactionType.Any;
			public SysId LocationIdStock { get; set; }
			public String AssocPartial { get; set; }
			public String AddressPartial { get; set; }
			public String PostcodePartial { get; set; }
			public String TransRefFull { get; set; }
			public String TransRefPartial { get; set; }
			public String TransRefExtFull { get; set; }
			public String TransRefExtPartial { get; set; }
			public String TransDescBriefPartial { get; set; }
			public String DefaultNominalCodeFull { get; set; }
			public String DefaultNominalCodePartial { get; set; }
			public String ContactAreaCode { get; set; }
			public String AccountManagerCode { get; set; }
			public String AccountHandlerCode { get; set; }
			public String DeliveryStatusCode { get; set; }
			public String DeliveryTypeCode { get; set; }
			public String DeliveryMethodCode { get; set; }
			public String DeliveryCourierCode { get; set; }
			public String DeliveryBookInCode { get; set; }
			public DateTime RaisedFrom { get; set; }
			public DateTime RaisedTo { get; set; }
			public DateTime RequiredFrom { get; set; }
			public DateTime RequiredTo { get; set; }
			public DateTime ClosedFrom { get; set; }
			public DateTime ClosedTo { get; set; }
			public decimal AmountNetLt { get; set; } = Decimal.MinValue;
			public decimal AmountNetGt { get; set; } = Decimal.MinValue;
			public String NotesPartial { get; set; }
			// Active period.
			/// <summary>Active on specific date. [Date period below ignored if this date is valid]</summary>
			public DateTime ActiveOn { get; set; }
			/// <summary>Active during the period, or at any time from or to the specified date if only one is valid.</summary>
			public DateTime ActiveFrom { get; set; }
			/// <summary>Active during the period, or at any time from or to the specified date if only one is valid.</summary>
			public DateTime ActiveTo { get; set; }
			/// <summary>True (default) = Active at any time during period, False = Active throughout period. [Used when complete date range specified]</summary>
			public bool ActiveAnyDayDuringPeriod { get; set; }
			/* Requirement details */
			public SysId ReqntCommodityId { get; set; }
			public SysId ReqntAssetId { get; set; }
			public String ReqntProductCodeFull { get; set; }
			public String ReqntProductCodePartial { get; set; }
			// Stored as product code for 'Project' transactions (populating this value will force the transaction type).
			public String ReqntProjectTaskCodeFull { get; set; }
			public String ReqntProjectTaskCodePartial { get; set; }
			public String ReqntJobNumberFull { get; set; }
			public String ReqntJobNumberPartial { get; set; }
			public String ReqntAssetSerialFull { get; set; }
			public String ReqntAssetSerialPartial { get; set; }
			public String ReqntDescDetailPartial { get; set; }
			public String ReqntNotesPartial { get; set; }
			// Match Transaction reference against any referenced requirement.
			public String SourceReqntTransRef { get; set; }
			/// <summary>Transaction status.</summary>
			public StatusCat StatusCat { get; set; } = StatusCat.Default;
			/// <summary>Results will be throttled unless a significant filter is applied.</summary>			
			public bool ForceFullResults { get; set; } = false;
			// Utilities.
			public List<StringPair> GetDisplayValues()
			{
				List<StringPair> values = new List<StringPair>();
				return values;
			}
			public bool RequiresVolumeThrottle()
			{
				// The volume of transaction must be throttled if no 'significant' filter is requested.
				// Test each 'significant' element of the filter and return 'false' if any of the values are set.
				// NB Elements without a test in the list below are not regarded as 'significant'.
				if (ForceFullResults) return false;
				if (IdsIncluded.Count > 0) return false;
				if (SysId.IsValid(TransIdSource)) return false;
				if (StatusCat == StatusCat.Pending || StatusCat == StatusCat.Open) return false;
				if (!StringUtil.IsEmpty(AssocPartial)) return false;
				if (!StringUtil.IsEmpty(AddressPartial)) return false;
				if (!StringUtil.IsEmpty(PostcodePartial)) return false;
				if (!StringUtil.IsEmpty(TransRefFull)) return false;
				if (!StringUtil.IsEmpty(TransRefPartial)) return false;
				if (!StringUtil.IsEmpty(TransRefExtFull)) return false;
				if (!StringUtil.IsEmpty(TransRefExtPartial)) return false;
				if (!StringUtil.IsEmpty(TransDescBriefPartial)) return false;
				if (!StringUtil.IsEmpty(DefaultNominalCodeFull)) return false;
				if (!StringUtil.IsEmpty(DefaultNominalCodePartial)) return false;
				if (!StringUtil.IsEmpty(ContactAreaCode)) return false;
				if (!StringUtil.IsEmpty(AccountManagerCode)) return false;
				if (!StringUtil.IsEmpty(AccountHandlerCode)) return false;
				if (!StringUtil.IsEmpty(DeliveryStatusCode)) return false;
				if (!StringUtil.IsEmpty(DeliveryTypeCode)) return false;
				if (!StringUtil.IsEmpty(DeliveryMethodCode)) return false;
				if (!StringUtil.IsEmpty(DeliveryCourierCode)) return false;
				if (!StringUtil.IsEmpty(DeliveryBookInCode)) return false;
				if (DateUtil.IsValid(RaisedFrom)) return false;
				if (DateUtil.IsValid(RaisedTo)) return false;
				if (DateUtil.IsValid(RequiredFrom)) return false;
				if (DateUtil.IsValid(RequiredTo)) return false;
				if (DateUtil.IsValid(ClosedFrom)) return false;
				if (DateUtil.IsValid(ClosedTo)) return false;
				if (AmountNetLt > Decimal.MinValue) return false;
				if (AmountNetGt > Decimal.MinValue) return false;
				if (!StringUtil.IsEmpty(NotesPartial)) return false;
				// Transaction active period.
				if (DateUtil.IsValid(ActiveOn)) return false;
				if (DateUtil.IsValid(ActiveFrom)) return false;
				if (DateUtil.IsValid(ActiveTo)) return false;
				// Requirement details.
				if (SysId.IsValid(ReqntCommodityId)) return false;
				if (SysId.IsValid(ReqntAssetId)) return false;
				if (!StringUtil.IsEmpty(ReqntProductCodeFull)) return false;
				if (!StringUtil.IsEmpty(ReqntProductCodePartial)) return false;
				if (!StringUtil.IsEmpty(ReqntProjectTaskCodeFull)) return false;
				if (!StringUtil.IsEmpty(ReqntProjectTaskCodePartial)) return false;
				if (!StringUtil.IsEmpty(ReqntJobNumberFull)) return false;
				if (!StringUtil.IsEmpty(ReqntJobNumberPartial)) return false;
				if (!StringUtil.IsEmpty(ReqntAssetSerialFull)) return false;
				if (!StringUtil.IsEmpty(ReqntAssetSerialPartial)) return false;
				if (!StringUtil.IsEmpty(ReqntDescDetailPartial)) return false;
				if (!StringUtil.IsEmpty(ReqntNotesPartial)) return false;
				// Match Transaction reference against any referenced requirement.
				if (!StringUtil.IsEmpty(SourceReqntTransRef)) return false;
				return true;
			}
		}

		//-------------------------------------------------------------------
	}

	//=======================================================================
	//                    T r a n s a c t i o n   L i s t
	//=======================================================================
	public static class SbmTransactionList
	{
		/// <summary>Check whether currency exists/locate in list with specified Id.</summary>
		public static bool Find(this List<SbmTransaction> values, SbmTransaction transaction)
		{
			if (transaction == null) return false;
			return (values.Find(item => item == transaction) != null);
		}
		public static bool FindById(this List<SbmTransaction> values, SysId id)
		{
			if (!SysId.IsValid(id)) return false;
			return values.Exists(item => item.Id.Equals(id));
		}
	}

	//=======================================================================
}