Common-VS2019/SacsStandardBase/Base/Interfaces/SaInterfaceDataItem.cs

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

namespace Sarand.Net.Standard.Base.Interfaces
{
	//=======================================================================
	public class SaInterfaceDataItem : SacsHierarchyItem
	{
		//-------------------------------------------------------------------
		// Columns.
		public enum Column
		{
			Pos = 0,
			Id,
			// Interface.
			InterfaceId,
			// Data item.
			Direction,
			Direction_Desc,
			ExternalReference,
			ItemType,
			ItemType_Desc,
			ItemId,
			Item_Caption,
			ProcessStatus,
			ProcessStatus_Desc,
			ProcessStatus_Ind,
			ProcessStatusBy,
			ProcessStatusBy_Name,
			ProcessStatusAt,
			ProcessStatusAt_Date,
			ProcessStatusAt_Time,
			ItemStatus,
			ItemStatus_Desc,
			ItemStatus_Ind,
			ItemStatusBy,
			ItemStatusBy_Name,
			ItemStatusAt,
			ItemStatusAt_Date,
			ItemStatusAt_Time,
			// Common properties.
			Notes,
			CreateOn_Date,
			UpdateOn_Date,
		}

		//-------------------------------------------------------------------
		/// <summary>Properties other than common.</summary>
		public class DataProperties
		{
			public SysId InterfaceId { get; set; } = null;
			public SaInterfaceProcessDirection Direction { get; set; } = SaInterfaceProcessDirection.Unknown;
			public ItemId ItemId { get; set; } = new ItemId();
			public String ExternalReference { get; set; } = String.Empty;
			public SaStatus ProcessStatus { get; set; } = SaStatus.Unknown;
			public SysId ProcessStatusBy { get; set; } = null;
			public DateTime ProcessStatusAt { get; set; } = DateTime.MinValue;
			public SaStatus ItemStatus { get; set; } = SaStatus.Unknown;
			public SysId ItemStatusBy { get; set; } = null;
			public DateTime ItemStatusAt { get; set; } = DateTime.MinValue;
		}

		//-------------------------------------------------------------------
		// Data.
		public new class Data : SacsHierarchyItem.Data
		{
			// Data members.
			private readonly DataProperties data = new DataProperties();
			// Construction.
			public Data ()
			{
				ProcessStatus = DefaultProcessStatus;
				ItemStatus = DefaultItemStatus;
			}
			// Properties.
			public SysId InterfaceId
			{
				get { return data.InterfaceId; }
				set { CheckChanged(data.InterfaceId, value); data.InterfaceId = value; }
			}
			public SaInterfaceProcessDirection Direction
			{
				get { return data.Direction; }
				set { CheckChanged((int)data.Direction, (int)value); data.Direction = value; }
			}
			public ItemId ItemId
			{
				get { return data.ItemId; }
				set { CheckChanged(data.ItemId, value); data.ItemId = value; }
			}
			public String ExternalReference
			{
				get { return data.ExternalReference; }
				set { CheckChanged(data.ExternalReference, value); data.ExternalReference = value; }
			}
			public SaStatus ProcessStatus
			{
				get { return data.ProcessStatus; }
				set { CheckChanged((int)data.ProcessStatus, (int)value); data.ProcessStatus = value; }
			}
			public SysId ProcessStatusBy
			{
				get { return data.ProcessStatusBy; }
				set { CheckChanged(data.ProcessStatusBy, value); data.ProcessStatusBy = value; }
			}
			public DateTime ProcessStatusAt
			{
				get { return data.ProcessStatusAt; }
				set { CheckChanged(data.ProcessStatusAt, value); data.ProcessStatusAt = value; }
			}
			public SaStatus ItemStatus
			{
				get { return data.ItemStatus; }
				set { CheckChanged((int)data.ItemStatus, (int)value); data.ItemStatus = value; }
			}
			public SysId ItemStatusBy
			{
				get { return data.ItemStatusBy; }
				set { CheckChanged(data.ItemStatusBy, value); data.ItemStatusBy = value; }
			}
			public DateTime ItemStatusAt
			{
				get { return data.ItemStatusAt; }
				set { CheckChanged(data.ItemStatusAt, value); data.ItemStatusAt = value; }
			}
			// Population.
			internal void PopulateFrom (Data data)
			{
				InterfaceId = data.InterfaceId;
				Direction = data.Direction;
				ItemId = data.ItemId;
				ExternalReference = data.ExternalReference;
				ProcessStatus = data.ProcessStatus;
				ProcessStatusBy = data.ProcessStatusBy;
				ProcessStatusAt = data.ProcessStatusAt;
				ItemStatus = data.ItemStatus;
				ItemStatusBy = data.ItemStatusBy;
				ItemStatusAt = data.ItemStatusAt;
				base.PopulateFrom(data);
			}
			public Data Clone ()
			{
				Data data = new Data();
				data.PopulateFrom(this);
				return data;
			}
		}

		//-------------------------------------------------------------------
		// Error field - identify properties with validation error.
		public new class ErrField : SacsHierarchyItem.ErrField
		{
			// Identifies the field that has invalid data.
			public ValidValue InterfaceId { get; set; } = ValidValue.Valid;
			public ValidValue Direction { get; set; } = ValidValue.Valid;
			public ValidValue ItemType { get; set; } = ValidValue.Valid;
			public ValidValue ItemId { get; set; } = ValidValue.Valid;
			public ValidValue ExternalReference { get; set; } = ValidValue.Valid;
			public ValidValue ProcessStatus { get; set; } = ValidValue.Valid;
			public ValidValue ProcessStatusBy { get; set; } = ValidValue.Valid;
			public ValidValue ProcessStatusAt { get; set; } = ValidValue.Valid;
			public ValidValue ItemStatus { get; set; } = ValidValue.Valid;
			public ValidValue ItemStatusBy { get; set; } = ValidValue.Valid;
			public ValidValue ItemStatusAt { get; set; } = ValidValue.Valid;
		}

		//-------------------------------------------------------------------
		// Data members.
		private readonly Data data = new Data();
		// Flags.
		public static readonly Byte Flag_OnHold = 0x01;

		//-------------------------------------------------------------------
		// Construction.
		public SaInterfaceDataItem (SysId id, SysId interfaceId, SaInterfaceProcessDirection direction, ItemId itemId, String externalReference) :
			base(id)
		{
			base.SetData(data);
			InterfaceId = interfaceId;
			Direction = direction;
			ItemId = itemId;
			ExternalReference = externalReference;
			ProcessStatus = DefaultProcessStatus;
			ItemStatus = DefaultItemStatus;
		}

		//-------------------------------------------------------------------
		// Process statuses.
		private static readonly List<SaStatus> validProcessStatuses = new List<SaStatus>()
		{
			SaStatus.Awaiting,
			SaStatus.Completed,
			SaStatus.Cancelled,
			SaStatus.Failed
		};
		public static SaStatus DefaultProcessStatus { get { return AwaitingProcessStatus; } }
		public static SaStatus AwaitingProcessStatus { get { return SaStatus.Awaiting; } }
		public static SaStatus CompletedProcessStatus { get { return SaStatus.Completed; } }
		public static SaStatus CancelledProcessStatus { get { return SaStatus.Cancelled; } }
		public static SaStatus FailedProcessStatus { get { return SaStatus.Failed; } }
		public static List<SaStatus> ValidProcessStatuses { get { return new List<SaStatus>(validProcessStatuses); } }
		public static DataValue.TriStateType GetProcessStatusTriState (SaStatus status)
		{
			switch (status)
			{
				case SaStatus.Completed:
					return Core.DataValue.TriStateType.Green;
				case SaStatus.Awaiting:
					return Core.DataValue.TriStateType.Amber;
				case SaStatus.Cancelled:
					return Core.DataValue.TriStateType.Red;
				case SaStatus.Failed:
					return Core.DataValue.TriStateType.Yellow;
				case SaStatus.Deleted:
					return Core.DataValue.TriStateType.Purple;
			}
			return Core.DataValue.TriStateType.Unknown;
		}

		//-------------------------------------------------------------------
		// Item Statuses.
		private static readonly List<SaStatus> validItemStatuses = new List<SaStatus>()
		{
			SaStatus.InProgress,
			SaStatus.Imported,
			SaStatus.Exported,
			SaStatus.Cancelled,
		};
		public static SaStatus DefaultItemStatus { get { return SaStatus.Unknown; } }
		public static List<SaStatus> ValidItemStatuses { get { return new List<SaStatus>(validItemStatuses); } }
		public static DataValue.TriStateType GetItemStatusTriState (SaStatus status)
		{
			switch (status)
			{
				case SaStatus.Imported:
				case SaStatus.Exported:
					return Core.DataValue.TriStateType.Green;
				case SaStatus.InProgress:
					return Core.DataValue.TriStateType.Amber;
				case SaStatus.Cancelled:
					return Core.DataValue.TriStateType.Red;
				case SaStatus.Deleted:
					return Core.DataValue.TriStateType.Purple;
			}
			return Core.DataValue.TriStateType.Unknown;
		}

		//-------------------------------------------------------------------
		// 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");
			if (SysId.IsValid(InterfaceId) && SysId.ToInt(InterfaceId) != SysId.ToInt(data.InterfaceId))
				throw new NotSupportedException($"{SysUtil.Fn} Interface cannot be changed");
			if ((int)Direction > 0 && (int)Direction != (int)data.Direction)
				throw new NotSupportedException($"{SysUtil.Fn} Direction cannot be changed");
			if (ItemId.Type >= 0 && ItemId.Type != data.ItemId.Type)
				throw new NotSupportedException($"{SysUtil.Fn} Item type cannot be changed");
			if (SysId.IsValid(ItemId.Id) && SysId.ToInt(ItemId.Id) != SysId.ToInt(data.ItemId.Id))
				throw new NotSupportedException($"{SysUtil.Fn} Item Id cannot be changed");
			if (!StringUtil.IsEmpty(ExternalReference) && !ExternalReference.Equals(data.ExternalReference))
				throw new NotSupportedException($"{SysUtil.Fn} External reference cannot be changed");
			// Populate individual properties to ensure that 'Changed' indicator is kept up to date.
			this.data.PopulateFrom(data);
		}
		public SysId InterfaceId
		{
			get { return data.InterfaceId; }
			protected set { data.InterfaceId = value; }
		}
		public SaInterfaceProcessDirection Direction
		{
			get { return data.Direction; }
			protected set { data.Direction = value; }
		}
		public ItemId ItemId
		{
			get { return data.ItemId; }
			protected set { data.ItemId = value; }
		}
		public String ExternalReference
		{
			get { return data.ExternalReference; }
			set { data.ExternalReference = value; }
		}
		public SaStatus ProcessStatus
		{
			get { return data.ProcessStatus; }
			set { data.ProcessStatus = value; }
		}
		public SysId ProcessStatusBy
		{
			get { return data.ProcessStatusBy; }
			set { data.ProcessStatusBy = value; }
		}
		public DateTime ProcessStatusAt
		{
			get { return data.ProcessStatusAt; }
			set { data.ProcessStatusAt = value; }
		}
		public SaStatus ItemStatus
		{
			get { return data.ItemStatus; }
			set { data.ItemStatus = value; }
		}
		public SysId ItemStatusBy
		{
			get { return data.ItemStatusBy; }
			set { data.ItemStatusBy = value; }
		}
		public DateTime ItemStatusAt
		{
			get { return data.ItemStatusAt; }
			set { data.ItemStatusAt = value; }
		}

		//-------------------------------------------------------------------
		// Flags.
		public bool OnHold
		{
			get { return GetFlag(Flag_OnHold); }
			set { SetFlag(Flag_OnHold, value); }
		}

		//-------------------------------------------------------------------
		// List parameters.
		public enum ProcessStatusCat
		{
			Any,
			AwaitingOnly,
			CompletedOnly,
		}
		public enum ItemStatusCat
		{
			Any,
			InProgressOnly,
			ImportedOnly,
			ExportedOnly,
			CancelledOnly,
		}
		/// <summary>
		/// Item list parameters.
		/// </summary>
		public new class Params : SacsHierarchyItem.Params
		{
			public List<SysId> IncludedIds { get; } = new List<SysId>();
			public List<SysId> ExcludedIds { get; } = new List<SysId>();
			public SysId InterfaceId { get; set; }
			public SaInterfaceProcessDirection Direction { get; set; } = SaInterfaceProcessDirection.Unknown;
			public short ItemType { get; set; }
			public List<ItemId> IncludedItemIds { get; } = new List<ItemId>();
			public String ExternalReference { get; set; }
			public ProcessStatusCat ProcessStatusCat { get; set; } = ProcessStatusCat.Any;
			public ItemStatusCat ItemStatusCat { get; set; } = ItemStatusCat.Any;
		}

		//-------------------------------------------------------------------
		/// <summary>Mode for filtering associated data items.</summary>
		public enum FilterMode
		{
			None,
			Exists,
			NotExists,
		}

		//-------------------------------------------------------------------
		//                              L i s t
		//-------------------------------------------------------------------
		public class List : List<SaInterfaceDataItem>
		{
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}