BusinessMgr-2019/SaBusMgrStandardDbas/Dbas/Bus/SbmProcess_Dbas.cs

using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Bus;
using Sarand.BusinessMgr.Net.Standard.Base.Mgr;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.ItemData;
using Sarand.Net.Standard.Base.Utils;
using System;
using System.Collections.Generic;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Bus
{
	//=======================================================================
	class SbmProcess_Dbas : SbmProcess
	{
		//-------------------------------------------------------------------
		// Data members.
		private readonly SbmInternals internals;
		private readonly List<TypeCodeDesc> itemDataTypes;
		private static readonly String codeDelim = ",";

		//-------------------------------------------------------------------
		// Construction.
		public SbmProcess_Dbas(SbmInternals internals, SysId id, SysId affIdOwner, Sbm.ProcessCategory processCategory, ushort flags) :
			base(internals.UserContext, id, affIdOwner, processCategory)
		{
			this.internals = internals;
			itemDataTypes = internals.GetSystemCodes(Sbm.SystemCode.ItemDataType);
			Flags = flags;
		}
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				// NB Do not dispose the Internals - owned by manager.
			}
			base.Dispose(disposing);
		}

		//-------------------------------------------------------------------
		// Properties.

		//-------------------------------------------------------------------
		// Associated codes.
		public override String GetCodeForCostCode(SbmProcessCostCode processCostCode)
		{
			switch (processCostCode)
			{
				case SbmProcessCostCode.Fixed_Unit: return itemDataTypes.GetCodeForType(Sbm.ItemDataType.Process_FixedCost_Unit);
				case SbmProcessCostCode.Fixed_Job: return itemDataTypes.GetCodeForType(Sbm.ItemDataType.Process_FixedCost_Job);
				case SbmProcessCostCode.Labour_Unit: return itemDataTypes.GetCodeForType(Sbm.ItemDataType.Process_LabourCost_Unit);
				case SbmProcessCostCode.Labour_Job: return itemDataTypes.GetCodeForType(Sbm.ItemDataType.Process_LabourCost_Job);
			}
			return "";
		}
		public override bool HasCostCodes()
		{
			ClearErrorState();
			if (!SysId.IsValid(Id)) return false;

			SaItemData.Params prmItemData = new SaItemData.Params();
			prmItemData.IncludedItemIds.Add(new ItemId((short)Sbm.ItemType.Process, Id));
			prmItemData.IncludedDataTypes.Add(GetCodeForCostCode(SbmProcessCostCode.Fixed_Unit));
			prmItemData.IncludedDataTypes.Add(GetCodeForCostCode(SbmProcessCostCode.Fixed_Job));
			prmItemData.IncludedDataTypes.Add(GetCodeForCostCode(SbmProcessCostCode.Labour_Unit));
			prmItemData.IncludedDataTypes.Add(GetCodeForCostCode(SbmProcessCostCode.Labour_Job));
			return internals.ItemDataConsole.ItemDataExists(prmItemData);
		}
		public override bool HasCostCodes(SbmProcessCostCode processCostCode)
		{
			ClearErrorState();
			if (!SysId.IsValid(Id)) return false;
			bool bHas = false;
			// Identify process code type code.
			String itemDataTypeCode = GetCodeForCostCode(processCostCode);
			if (!StringUtil.IsEmpty(itemDataTypeCode))
			{
				SaItemData.Params prmItemData = new SaItemData.Params();
				prmItemData.IncludedItemIds.Add(new ItemId((short)Sbm.ItemType.Process, Id));
				prmItemData.IncludedDataTypes.Add(itemDataTypeCode);
				bHas = internals.ItemDataConsole.ItemDataExists(prmItemData);
			}
			return bHas;
		}
		public override List<String> GetCostCodes(SbmProcessCostCode processCostCode)
		{
			List<String> costCodes = new List<String>();
			ClearErrorState();
			// Identify process code type code.
			String itemDataTypeCode = GetCodeForCostCode(processCostCode);
			if (!SysId.IsValid(Id) && !StringUtil.IsEmpty(itemDataTypeCode))
			{
				SaItemData.Params prmItemData = new SaItemData.Params();
				prmItemData.IncludedItemIds.Add(new ItemId((short)Sbm.ItemType.Process, Id));
				prmItemData.IncludedDataTypes.Add(itemDataTypeCode);
				List<SaItemData> itemDatas = internals.ItemDataConsole.GetItemDataList(prmItemData);
				foreach (SaItemData itemData in itemDatas)
				{
					if (itemData == null) continue;
					costCodes.AddRange(StringListUtil.Split(itemData.ItemData, codeDelim));
					break;
				}
				itemDatas.Clear();
			}
			return costCodes;
		}
		public override bool StoreCostCodes(SbmProcessCostCode processCostCode, List<String> costCodes)
		{
			ClearErrorState();
			if (StringUtil.IsEmpty(costCodes.Concat(codeDelim))) return ClearCostCodes(processCostCode);
			// Identify process code type code.
			String itemDataTypeCode = GetCodeForCostCode(processCostCode);
			if (!SysId.IsValid(Id) && !StringUtil.IsEmpty(itemDataTypeCode))
			{
				SaItemData.Params prmItemData = new SaItemData.Params();
				prmItemData.IncludedItemIds.Add(new ItemId((short)Sbm.ItemType.Process, Id));
				prmItemData.IncludedDataTypes.Add(itemDataTypeCode);
				List<SaItemData> itemDatas = internals.ItemDataConsole.GetItemDataList(prmItemData);
				// ToDo itemData condition.
				//itemDatas.GotoStart();
				SaItemData itemData = null;//itemDatas.Count == 1 ? itemDatas.Remove(1) : null;
				itemDatas.Clear();
				if (itemData == null)
				{
					// Code type not found - create a new entry.
					itemData = internals.ItemDataConsole.CreateItemData(new ItemId((short)Sbm.ItemType.Process, Id));
					itemData.DataType = itemDataTypeCode;
				}
				if (itemData != null)
				{
					// Populate item data for these codes.
					itemData.ItemData = costCodes.Concat(codeDelim);
					if (!internals.ItemDataConsole.Store(itemData, internals.DbUpdateInfo))
					{
						SetErrorState(internals.ItemDataConsole.ErrorStateMessage);
					}
				}
			}
			return !HasErrorState();
		}
		public override bool ClearCostCodes(SbmProcessCostCode processCostCode)
		{
			ClearErrorState();
			// Identify process code type code.
			String itemDataTypeCode = GetCodeForCostCode(processCostCode);
			if (!SysId.IsValid(Id) && !StringUtil.IsEmpty(itemDataTypeCode))
			{
				if (!internals.ItemDataConsole.ClearItemData(new ItemId((short)Sbm.ItemType.Process, Id), itemDataTypeCode, internals.DbUpdateInfo))
				{
					SetErrorState(internals.ItemDataConsole.ErrorStateMessage);
				}
			}
			return !HasErrorState();
		}
		public override bool ClearCostCodes()
		{
			ClearErrorState();
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Associated data.
		public override bool HasReferences()
		{
			if (!SysId.IsValid(Id)) return false;
			if (internals.DataItemMgr.HasItemLinks(Sbm.ItemType.Process, Id)) return true;
			// Is this process referenced by Constituents.
			ISacsDatabase db = SbmGlobals.Application.GetBusMgrDatabase(internals.SessionContext); if (db != null) return true;

			// Constituents.
			String filter = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Constituent_Id) + "=" + SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Constituent_ProcessId) + "=" + Id.ToString();
			return db.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Constituent), filter) > 0;
		}
		public override bool HasItemData()
		{
			ClearErrorState();
			if (!SysId.IsValid(Id)) return false;
			SaItemData.Params prmItemData = new SaItemData.Params();
			prmItemData.IncludedItemIds.Add(new ItemId((short)Sbm.ItemType.Process, Id));
			return internals.ItemDataConsole.ItemDataExists(prmItemData);
		}
		public override bool ClearAssociatedData()
		{
			ClearErrorState();
			if (!SysId.IsValid(Id)) return SetErrorState("item not specified");
			// Clear Item data records.
			SaItemData.Params prmItemData = new SaItemData.Params();
			prmItemData.IncludedItemIds.Add(new ItemId((short)Sbm.ItemType.Process, Id));
			List<SaItemData> itemDatas = internals.ItemDataConsole.GetItemDataList(prmItemData);
			foreach (SaItemData itemData in itemDatas)
			{
				internals.ItemDataConsole.Remove(itemData, internals.DbUpdateInfo);
			}
			itemDatas.Clear();
			return !HasErrorState();
		}

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