using Sarand.BusinessMgr.Net.Standard.Base.App;
using Sarand.BusinessMgr.Net.Standard.Base.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Bus;
using Sarand.BusinessMgr.Net.Standard.Dbas.Internal;
using Sarand.BusinessMgr.Net.Standard.Dbas.UpdateLog;
using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.Utils;
using Sarand.Net.Standard.Dbas.Base;
using Sarand.Net.Standard.Dbas.Data;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	// Commodity Manager - Portfolio Item.
	//=======================================================================
	partial class SbmCommodityMgr_Dbas
	{
		//-------------------------------------------------------------------
		// Utilities.
		private List<StringPair> GetLogProperties(SbmPortfolioItem portfolioItem)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(portfolioItem.Id)),
				new StringPair("Type",PortfolioItemTypes.GetDescForType(portfolioItem.Type, portfolioItem.Type.ToString())),
				new StringPair("Code",portfolioItem.Code),
				new StringPair("Status",portfolioItem.StatusCode)
			};
		}
		//-------------------------------------------------------------------
		// Item types.
		public override List<Sbm.PortfolioItemType> GetPortfolioItemTypesInUse()
		{
			List<Sbm.PortfolioItemType> types = new List<Sbm.PortfolioItemType>();
			// Construct the query.
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_PortfolioItem);
			qry.Columns.Add("DISTINCT " + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Type));
			qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_AffIdOwner) + "=" + AffiliateId_Owner.ToString());
			using (DbResultSet dbResultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.ToString()))
			{
				if (dbResultSet != null && dbResultSet.NextRecord())
				{
					NamedValue.Map values = dbResultSet.GetRecordValues();
					types.Add((Sbm.PortfolioItemType)values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type)).AsLong());
				}
			}
			return types;
		}

		//-------------------------------------------------------------------
		// Sequence by parent.
		public override ushort GetMinSeqForParent(SysId idParent, Sbm.PortfolioItemType eType)
		{
			ClearErrorState();
			String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
			String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
			String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
			List<String> filters = new List<string>();
			filters.Add(colType + "=" + ((int)eType).ToString());
			filters.Add(colItemIdParent + "=" + idParent.ToString());
			return (ushort)Database.GetRowValue(TableName_PortfolioItem, "Min(" + colSeq + ")", filters.Concat(" AND ", "(", ")")).AsLong();
		}
		public override ushort GetMaxSeqForParent(SysId idParent, Sbm.PortfolioItemType eType)
		{
			ClearErrorState();
			String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
			String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
			String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
			List<String> filters = new List<string>();
			filters.Add(colType + "=" + ((int)eType).ToString());
			filters.Add(colItemIdParent + "=" + idParent.ToString());
			return (ushort)Database.GetRowValue(TableName_PortfolioItem, "Max(" + colSeq + ")", filters.Concat(" AND ", "(", ")")).AsLong();
		}
		// Category item Ids for parent.
		public override List<SysId> GetCategoryItemIds(SysId idParentItem)
		{
			List<SysId> itemIds = new List<SysId>();
			String colId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
			String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
			String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
			String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
			// Identify item above this one in the list.
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_PortfolioItem);
			qry.Columns.Add(colId);
			qry.Filters.Add(colType + "=" + ((int)Sbm.PortfolioItemType.Category).ToString());
			qry.Filters.Add(colItemIdParent + "=" + idParentItem.ToString());
			qry.OrderBy.Add(colSeq);
			using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
			{
				while (resultSet != null && resultSet.NextRecord())
				{
					NamedValue.Map values = resultSet.GetRecordValues();
					itemIds.Add(new SysId((int)values.GetLong(colId)));
				}
			}
			return itemIds;
		}
		// Comodity
		public override List<SysId> GetCommodityItemIds(SysId idParentItem, ref List<SysId> commodityIds, bool includeSubCategories)
		{
			List<SysId> itemIds = new List<SysId>();
			String sColId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id, false);
			String sColType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type, false);
			String sColItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, false);
			String sColSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq, false);
			String sColCmdId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, false);

			// Identify item above this one in the list:
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_PortfolioItem);
			qry.Columns.Add(sColId);
			qry.Columns.Add(sColType);
			if (commodityIds != null) qry.Columns.Add(sColCmdId);
			if (!includeSubCategories) qry.Filters.Add(sColType + "=" + ((int)Sbm.PortfolioItemType.Commodity).ToString());
			qry.Filters.Add(sColItemIdParent + "=" + idParentItem.ToString());
			qry.OrderBy.Add(sColSeq);
			using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
			{
				while (resultSet != null && resultSet.NextRecord())
				{
					NamedValue.Map values = resultSet.GetRecordValues();
					SysId itemId = new SysId((int)values.GetLong(sColId));
					if (values.GetLong(sColType) == (int)Sbm.PortfolioItemType.Category)
					{
						// Category item - search sub categories.
						if (includeSubCategories)
							itemIds.AddRange(GetCommodityItemIds(itemId, ref commodityIds, includeSubCategories));
					}
					else
					{
						// Commodity item.
						itemIds.Add(itemId);
						if (commodityIds != null)
							commodityIds.Add(new SysId((int)values.GetLong(sColCmdId)));
					}
				}
			}
			return itemIds;
		}
		//-------------------------------------------------------------------
		public override bool ResequenceChildren(SysId parentItemId)
		{
			ClearErrorState();

			// Two separate sequences for categories and commodities.
			ushort iSeq_Category = 0;
			ushort iSeq_Commodity = 0;

			// Parameters to retrieve children.
			SbmPortfolioItem.Params prmPortfolioItem = new SbmPortfolioItem.Params();
			prmPortfolioItem.ParentItemId = parentItemId;
			foreach (SbmPortfolioItem portfolioItem in GetPortfolioItemList(prmPortfolioItem))
			{
				if (portfolioItem.Type == Sbm.PortfolioItemType.Commodity)
					portfolioItem.Sequence = ++iSeq_Commodity;
				else
					portfolioItem.Sequence = ++iSeq_Category;
				if (!UpdatePortfolioItem(portfolioItem, DbUpdateInfo))
					SetErrorState(ErrorStateMessage);
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		private bool ResequenceSubsequentItems(SbmPortfolioItem portfolioItem)
		{
			if (!SysId.IsValid(portfolioItem.Id)) return true;

			// Item properties.
			Sbm.PortfolioItemType eType = portfolioItem.Type;
			SysId idItemParent = portfolioItem.ItemIdParent;
			SysId idItemLeave = portfolioItem.Id;
			ushort itemSequence = portfolioItem.Sequence;

			// Common database items.
			String colId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
			String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
			String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
			String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);

			// Find out how many items exist with this sequence.
			long itemsWithSameSequence = 0;
			List<String> filters = new List<string>();
			filters.Add(colId + "!=" + SysId.ToInt(idItemLeave));
			filters.Add(colType + "=" + ((int)eType).ToString());
			filters.Add(colItemIdParent + "=" + SysId.ToInt(idItemParent));
			filters.Add(colSeq + "=" + itemSequence.ToString());
			itemsWithSameSequence = Database.GetRowCount(TableName_PortfolioItem, filters.Concat(" AND ", "(", ")"));
			// Don't need to resequence if there are no other items with this sequence:
			if (itemsWithSameSequence < 1) return true;

			// Identify the next sequence value other than this item.
			ushort nextSequence = 0;
			filters = new List<string>();
			filters.Add(colId + "<>" + SysId.ToInt(idItemLeave));
			filters.Add(colType + "=" + ((int)eType).ToString());
			filters.Add(colItemIdParent + "=" + SysId.ToInt(idItemParent));
			filters.Add(colSeq + ">=" + itemSequence.ToString());
			nextSequence = (ushort)Database.GetRowValue(TableName_PortfolioItem, "Min(" + colSeq + ")", filters.Concat(" AND ", "(", ")")).AsLong();

			// Check whether resequence is required:
			if ((itemsWithSameSequence == 0 && nextSequence > itemSequence) || (itemsWithSameSequence > 1 && nextSequence == itemSequence))
			{
				// Update subsequent items' sequences to make room for the specified item.
				List<StringPair> columnValues = new List<StringPair>();
				if (itemsWithSameSequence == 0)
				{
					// No items with same sequence - item must have been deleted
					// so decrement the sequence for all subsequent items.
					SacsDatabase.AddValuePair(columnValues, colSeq, colSeq + "-" + (nextSequence - itemSequence).ToString(), false);
				}
				else
				{
					// Item must have been inserted into sequence so increment
					// all other items with sequence or higher:
					SacsDatabase.AddValuePair(columnValues, colSeq, colSeq + "+1", false);
				}
				Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
				if (Database.HasErrorState())
					return SetErrorState(Database.ErrorStateMessage);
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Create Item.
		public override SbmPortfolioItem CreatePortfolioItem(Sbm.PortfolioItemType portfolioItemType)
		{
			return new SbmPortfolioItem_Dbas(Internals, new SysId(), AffiliateId_Owner, portfolioItemType, 0);
		}
		private SbmPortfolioItem_Dbas CreatePortfolioItem(PortfolioItem_Db dbPortfolioItem)
		{
			ClearErrorState();
			SbmPortfolioItem_Dbas portfolioItem = new SbmPortfolioItem_Dbas(Internals, new SysId(dbPortfolioItem._Id), new SysId(dbPortfolioItem._AffIdOwner), (Sbm.PortfolioItemType)dbPortfolioItem._Type, (ushort)dbPortfolioItem._Flags);
			PopulateFrom(dbPortfolioItem, portfolioItem);
			return portfolioItem;
		}

		//-------------------------------------------------------------------
		// Get Item.
		public override SbmPortfolioItem GetPortfolioItem(SbmPortfolioItem.Params prm)
		{
			return GetPortfolioItem(GetPortfolioItemQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmPortfolioItem GetPortfolioItem(String filter)
		{
			ClearErrorState();
			long count = GetPortfolioItemCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple Portfolio Items found");
				return null;
			}
			SbmPortfolioItem portfolioItem = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
					dbPortfolioItem.PopulateFrom(dbCommand, aliasPortfolioItem, filter);
					portfolioItem = CreatePortfolioItem(dbPortfolioItem);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return portfolioItem;
		}

		//-------------------------------------------------------------------
		// Validate Item.
		public override bool IsValidPortfolioItemData(SbmPortfolioItem.Data data, SbmPortfolioItem.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidPortfolioItemData(data, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Insert PortfolioItem.
		public override bool InsertPortfolioItem(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidPortfolioItem(portfolioItem)) return false;
			if (SysId.IsValid(portfolioItem.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
					PopulateTo(dbPortfolioItem, portfolioItem, dbUpdateInfo);
					if (PortfolioItem_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbPortfolioItem._Id = SysId.ToInt(Database.GetNextId("PortfolioItem", dbUpdateInfo));
					}
					dbPortfolioItem.ExecuteInsertCommand(dbCommand);
					portfolioItem.Id = new SysId(dbPortfolioItem._Id);
					portfolioItem.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));

					// Move other items for same parent down sequence.
					ResequenceSubsequentItems(portfolioItem);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update PortfolioItem.
		public override bool UpdatePortfolioItem(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidPortfolioItem(portfolioItem)) return false;
			if (!SysId.IsValid(portfolioItem.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!portfolioItem.Changed)
			{
				if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve PortfolioItem.
					dbConnection.Open();
					PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
					dbPortfolioItem.PopulateFrom(dbCommand, aliasPortfolioItem, "Id=" + SysId.ToString(portfolioItem.Id));
					SbmUpdateLogItemMonitor_PortfolioItem updateLogMonitor = new SbmUpdateLogItemMonitor_PortfolioItem(Internals, CreatePortfolioItem(dbPortfolioItem));

					// Update properties.
					PopulateTo(dbPortfolioItem, portfolioItem, dbUpdateInfo);
					dbPortfolioItem.ExecuteUpdateCommand(dbCommand);
					portfolioItem.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Updated. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));

					// Record updates.
					updateLogMonitor.RecordUpdatedValues(portfolioItem);
					updateLogMonitor.LogUpdates();

					// Move other items for same parent down sequence.
					ResequenceSubsequentItems(portfolioItem);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Verify moving item.
		public override bool CanMoveItemUp(SbmPortfolioItem portfolioItem)
		{
			ClearErrorState();
			ushort minSequence = GetMinSeqForParent(portfolioItem.ItemIdParent, portfolioItem.Type);
			return !HasErrorState() && minSequence < portfolioItem.Sequence;
		}
		public override bool CanMoveItemDown(SbmPortfolioItem portfolioItem)
		{
			ClearErrorState();
			ushort maxSequence = GetMaxSeqForParent(portfolioItem.ItemIdParent, portfolioItem.Type);
			return !HasErrorState() && maxSequence > portfolioItem.Sequence;
		}

		//-------------------------------------------------------------------
		// Move item.
		public override bool MoveItemUp(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			String colId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
			String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
			String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
			String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);

			// Identify item above this one in the list.
			SysId itemIdPrev = new SysId();
			ushort sequencePrev = 0;
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_PortfolioItem);
			qry.Columns.Add(colId);
			qry.Columns.Add(colSeq);
			qry.Filters.Add(colType + "=" + ((int)portfolioItem.Type).ToString());
			qry.Filters.Add(colItemIdParent + "=" + SysId.ToInt(portfolioItem.ItemIdParent));
			qry.Filters.Add(colSeq + "<" + portfolioItem.Sequence);
			qry.OrderBy.Add(colSeq + " DESC");
			qry.RowLimit = 2;
			using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
			{
				// Only need to read first record.
				if (resultSet != null && resultSet.NextRecord())
				{
					NamedValue.Map values = resultSet.GetRecordValues();
					itemIdPrev = new SysId((int)values.GetLong(colId));
					sequencePrev = (ushort)values.GetLong(colSeq);
				}
			}

			// Verify the previous item.
			if (SysId.IsValid(itemIdPrev) && sequencePrev > 0 && sequencePrev < portfolioItem.Sequence)
			{
				// Update previous item to replace the selected item's position in sequence.
				List<StringPair> columnValues = new List<StringPair>();
				SacsDatabase.AddValuePair(columnValues, colSeq, portfolioItem.Sequence.ToString(), false);
				List<String> filters = new List<string>();
				filters.Add(colId + "=" + SysId.ToInt(itemIdPrev));
				if (Database.HasErrorState())
					return SetErrorState(Database.ErrorStateMessage);
				Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
				if (Database.HasErrorState())
					return SetErrorState(Database.ErrorStateMessage);

				// Update the selected item with its new position in sequence.
				columnValues = new List<StringPair>();
				SacsDatabase.AddValuePair(columnValues, colSeq, sequencePrev.ToString(), false);
				filters = new List<string>();
				filters.Add(colId + "=" + SysId.ToInt(portfolioItem.Id));
				Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
				if (Database.HasErrorState())
					return SetErrorState(Database.ErrorStateMessage);
				// Update the item's sequence.
				portfolioItem.Sequence = sequencePrev;
			}
			return !HasErrorState();
		}
		public override bool MoveItemDown(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			String sColId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
			String sColType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
			String sColItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
			String sColSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);

			// Identify item above this one in the list.
			SysId itemIdNext = new SysId();
			ushort sequenceNext = 0;
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_PortfolioItem);
			qry.Columns.Add(sColId);
			qry.Columns.Add(sColSeq);
			qry.Filters.Add(sColType + "=" + ((int)portfolioItem.Type).ToString());
			qry.Filters.Add(sColItemIdParent + "=" + SysId.ToInt(portfolioItem.ItemIdParent));
			qry.Filters.Add(sColSeq + ">" + portfolioItem.Sequence);
			qry.OrderBy.Add(sColSeq + " ASC");
			qry.RowLimit = 2;
			using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
			{
				// Only need to read first record.
				if (resultSet != null && resultSet.NextRecord())
				{
					NamedValue.Map values = resultSet.GetRecordValues();
					itemIdNext = new SysId((int)values.GetLong(sColId));
					sequenceNext = (ushort)values.GetLong(sColSeq);
				}
			}

			// Verify the next item.
			if (SysId.IsValid(itemIdNext) && sequenceNext > 0 && sequenceNext > portfolioItem.Sequence)
			{
				// Update next item to replace the selected item's position in sequence:
				List<StringPair> columnValues = new List<StringPair>();
				SacsDatabase.AddValuePair(columnValues, sColSeq, portfolioItem.Sequence.ToString(), false);
				List<String> filters = new List<string>();
				filters.Add(sColId + "=" + SysId.ToInt(itemIdNext));
				Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
				if (Database.HasErrorState())
					return SetErrorState(Database.ErrorStateMessage);

				// Update the selected item with its new position in sequence:
				columnValues = new List<StringPair>();
				SacsDatabase.AddValuePair(columnValues, sColSeq, sequenceNext.ToString(), false);
				filters = new List<string>();
				filters.Add(sColId + "=" + SysId.ToInt(portfolioItem.Id));
				Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
				if (Database.HasErrorState())
					return SetErrorState(Database.ErrorStateMessage);
				// Update the item's sequence.
				portfolioItem.Sequence = sequenceNext;
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Delete Item.
		public override bool PortfolioItemCanBeDeleted(SbmPortfolioItem portfolioItem)
		{
			ClearErrorState();
			if (!base.PortfolioItemCanBeDeleted(portfolioItem)) return false;
			return true;
		}
		public override bool DeletePortfolioItem(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!PortfolioItemCanBeDeleted(portfolioItem)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve PortfolioItem.
					dbConnection.Open();
					PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
					dbPortfolioItem.PopulateFrom(dbCommand, aliasPortfolioItem, "Id=" + portfolioItem.Id.ToString());
					// Delete PortfolioItem.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem) + " WHERE Id=" + SysId.ToString(portfolioItem.Id) + ";";
					dbCommand.ExecuteNonQuery();
					portfolioItem.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));

					// Move other items for same parent down sequence.
					ResequenceSubsequentItems(portfolioItem);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(PortfolioItem_Db dbPortfolioItem, SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
		{
			dbPortfolioItem._Id = portfolioItem.Id.ToInt();
			dbPortfolioItem._AffIdOwner = SysId.ToInt(portfolioItem.AffiliateIdOwner);
			dbPortfolioItem._ItemIdParent = SysId.ToInt(portfolioItem.ItemIdParent);
			dbPortfolioItem._Seq = (short)portfolioItem.Sequence;
			dbPortfolioItem._Type = (short)portfolioItem.Type;
			dbPortfolioItem._ItemIdRef = SysId.ToInt(portfolioItem.ItemIdRef);
			dbPortfolioItem._Code = portfolioItem.Code;
			dbPortfolioItem._ShortCut = portfolioItem.ShortCut;
			dbPortfolioItem._Caption = portfolioItem.Caption;
			dbPortfolioItem._DescBrief = portfolioItem.DescBrief;
			dbPortfolioItem._DescDetail = portfolioItem.DescDetail;
			dbPortfolioItem._CommodityId = SysId.ToInt(portfolioItem.CommodityId);
			// Common properties.
			dbPortfolioItem._Notes = portfolioItem.Notes;
			dbPortfolioItem._Flags = (short)portfolioItem.Flags;
			dbPortfolioItem._Status = SacsSystem.GetStatusCode(portfolioItem.Status);
			if (!SysId.IsValid(portfolioItem.Id))
			{
				dbPortfolioItem._CreateOn = DateTime.UtcNow;
				dbPortfolioItem._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbPortfolioItem._CreateHost = dbUpdateInfo.Host;
			}
			dbPortfolioItem._UpdateOn = DateTime.UtcNow;
			dbPortfolioItem._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbPortfolioItem._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(PortfolioItem_Db dbPortfolioItem, SbmPortfolioItem portfolioItem)
		{
			portfolioItem.Id = new SysId(dbPortfolioItem._Id);
			//portfolioItem.AffiliateIdOwner = new SysId(dbPortfolioItem._AffIdOwner);
			portfolioItem.ItemIdParent = new SysId(dbPortfolioItem._ItemIdParent);
			portfolioItem.Sequence = (ushort)dbPortfolioItem._Seq;
			//portfolioItem.Type = (Sbm.PortfolioItemType)dbPortfolioItem._Type;
			portfolioItem.ItemIdRef = new SysId(dbPortfolioItem._ItemIdRef);
			portfolioItem.Code = dbPortfolioItem._Code;
			portfolioItem.Caption = dbPortfolioItem._Caption;
			portfolioItem.DescBrief = dbPortfolioItem._DescBrief;
			portfolioItem.DescDetail = dbPortfolioItem._DescDetail;
			portfolioItem.CommodityId = new SysId(dbPortfolioItem._CommodityId ?? 0);
			// Common properties.
			portfolioItem.Notes = dbPortfolioItem._Notes;
			portfolioItem.Status = SacsSystem.GetStatusForCode(dbPortfolioItem._Status);
			portfolioItem.SetCreateStamp(dbPortfolioItem._CreateOn ?? default(DateTime), new SysId(dbPortfolioItem._CreateBy ?? 0), dbPortfolioItem._CreateHost);
			portfolioItem.SetUpdateStamp(dbPortfolioItem._UpdateOn ?? default(DateTime), new SysId(dbPortfolioItem._UpdateBy ?? 0), dbPortfolioItem._UpdateHost);
			portfolioItem.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasPortfolioItem = "aPrtItm";
		private static readonly String aliasPortfolioItem_Parent = "PrtItm_Prt";
		private static readonly String prefixPortfolioItem_Parent = aliasPortfolioItem_Parent + "_";
		private static readonly String aliasPortfolioItem_Commodity = "PrtItm_Cmd";
		private static readonly String prefixPortfolioItem_Commodity = aliasPortfolioItem_Commodity + "_";

		// Column definition population.
		private void SetPortfolioItemColDfn
			(ColumnDfn col, String caption, int width, SbmDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SbmDbDfn.GetTableForColumn(dbCol) == SbmDbDfn.TableIdx.PortfolioItem)
				alias = aliasPortfolioItem;
			col.Set(caption, width, (int)dbCol, prefix + SbmDbDfn.GetColumnName(dbCol, false), SbmDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SbmDbDfn.ColumnIdx.Unknown)
				col.MaxLength = (int)SbmDbDfn.GetColTextLen(dbCol);
		}
		//-------------------------------------------------------------------
		// Getting PortfolioItem column definition.
		public override ColumnDfn GetPortfolioItemColumnDfn(SbmPortfolioItem.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SbmPortfolioItem.Column.Pos:
					SetPortfolioItemColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SbmPortfolioItem.Column.Id:
					SetPortfolioItemColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.PortfolioItem_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				// Parent.
				case SbmPortfolioItem.Column.ItemIdParent:
					SetPortfolioItemColDfn(columnDfn, "Parent #", 80, SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmPortfolioItem.Column.Parent_Code:
					SetPortfolioItemColDfn(columnDfn, "Parent code", 100, SbmDbDfn.ColumnIdx.PortfolioItem_Code, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Parent, prefixPortfolioItem_Parent);
					columnDfn.ReadOnly = true;
					break;
				case SbmPortfolioItem.Column.Parent_Caption:
					SetPortfolioItemColDfn(columnDfn, "Parent", 120, SbmDbDfn.ColumnIdx.PortfolioItem_Caption, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Parent, prefixPortfolioItem_Parent);
					columnDfn.ReadOnly = true;
					break;
				// Commodity.
				case SbmPortfolioItem.Column.CommodityId:
					SetPortfolioItemColDfn(columnDfn, "Commodity #", 80, SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmPortfolioItem.Column.Commodity_Code:
					SetPortfolioItemColDfn(columnDfn, "Commodity code", 100, SbmDbDfn.ColumnIdx.Commodity_Code, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
					columnDfn.ReadOnly = true;
					break;
				case SbmPortfolioItem.Column.Commodity_DescBrief:
					SetPortfolioItemColDfn(columnDfn, "Commodity", 120, SbmDbDfn.ColumnIdx.Commodity_DescBrief, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
					columnDfn.ReadOnly = true;
					break;
				case SbmPortfolioItem.Column.Commodity_SalesPrice:
					SetPortfolioItemColDfn(columnDfn, "Commodity price", 100, SbmDbDfn.ColumnIdx.Commodity_SalesPrice, ColumnAlignment.Right, DataValue.DataType.Decimal, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
					columnDfn.ReadOnly = true;
					break;
				case SbmPortfolioItem.Column.Commodity_SalesPrice_Fmt:
					SetPortfolioItemColDfn(columnDfn, "Commodity price", 100, SbmDbDfn.ColumnIdx.Commodity_SalesPrice, ColumnAlignment.Right, DataValue.DataType.String, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
					columnDfn.ReadOnly = true;
					break;
				// Portfolio Item Properties.
				case SbmPortfolioItem.Column.ItemIdRef:
					SetPortfolioItemColDfn(columnDfn, "Ref #", 80, SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdRef, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmPortfolioItem.Column.Type:
					SetPortfolioItemColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Type, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmPortfolioItem.Column.Type_Desc:
					SetPortfolioItemColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Type);
					break;
				case SbmPortfolioItem.Column.Sequence:
					SetPortfolioItemColDfn(columnDfn, "Seq", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Seq, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmPortfolioItem.Column.Code:
					SetPortfolioItemColDfn(columnDfn, "Code", 80, SbmDbDfn.ColumnIdx.PortfolioItem_Code);
					break;
				case SbmPortfolioItem.Column.Caption:
					SetPortfolioItemColDfn(columnDfn, "Caption", 120, SbmDbDfn.ColumnIdx.PortfolioItem_Caption);
					break;
				case SbmPortfolioItem.Column.DescBrief:
					SetPortfolioItemColDfn(columnDfn, "DescBrief", 160, SbmDbDfn.ColumnIdx.PortfolioItem_DescBrief);
					break;
				case SbmPortfolioItem.Column.DescDetail:
					SetPortfolioItemColDfn(columnDfn, "DescDetail", 240, SbmDbDfn.ColumnIdx.PortfolioItem_DescDetail);
					break;
				case SbmPortfolioItem.Column.ShortCut:
					SetPortfolioItemColDfn(columnDfn, "Shortcut", 80, SbmDbDfn.ColumnIdx.PortfolioItem_ShortCut);
					break;
				case SbmPortfolioItem.Column.Publish_Y:
					SetPortfolioItemColDfn(columnDfn, "Publish", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Flags, ColumnAlignment.Center);
					break;
				case SbmPortfolioItem.Column.Publish_Tick:
					SetPortfolioItemColDfn(columnDfn, "Publish", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Flags, ColumnAlignment.Center, DataValue.DataType.Bool);
					columnDfn.BoolFormat = ColumnBoolFormat.Tick;
					break;
				// Common properties.
				case SbmPortfolioItem.Column.Notes:
					SetPortfolioItemColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.PortfolioItem_Notes);
					break;
				case SbmPortfolioItem.Column.Status:
					SetPortfolioItemColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Status, ColumnAlignment.Center);
					break;
				case SbmPortfolioItem.Column.Status_Desc:
					SetPortfolioItemColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Status, ColumnAlignment.Center);
					break;
				case SbmPortfolioItem.Column.Status_Ind:
					SetPortfolioItemColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmPortfolioItem.Column.CreateOn_Date:
					SetPortfolioItemColDfn(columnDfn, "Created", 80, SbmDbDfn.ColumnIdx.PortfolioItem_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SbmPortfolioItem.Column.UpdateOn_Date:
					SetPortfolioItemColDfn(columnDfn, "Updated", 80, SbmDbDfn.ColumnIdx.PortfolioItem_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// Item query filter.
		public override List<string> GetPortfolioItemQueryFilter(SbmPortfolioItem.Params prm)
		{
			List<String> filter = new List<String>();

			// Portfolio Item Id.
			String colPortfolioItem_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, aliasPortfolioItem);
			String includedIds = prm.IdsIncluded.Concat(",");
			if (!StringUtil.IsEmpty(includedIds))
				filter.Add(colPortfolioItem_Id + " IN (" + includedIds + ")");
			String excludedIds = prm.IdsExcluded.Concat(",");
			if (!StringUtil.IsEmpty(excludedIds))
				filter.Add(colPortfolioItem_Id + " NOT IN (" + excludedIds + ")");

			//---------------------------------------------------------------
			// Parent.
			String colPortfolioItem_ItemIdParent = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, aliasPortfolioItem);
			if (SysId.IsValid(prm.ParentItemId))
				filter.Add(colPortfolioItem_ItemIdParent + "=" + prm.AncestorItemId.ToString());
			// Ancestor.
			if (SysId.IsValid(prm.AncestorItemId))
			{
				String sPrtItm1 = "PrtItm1";
				String sPrtItm2 = "PrtItm2";
				String sPrtItm3 = "PrtItm3";
				String sPrtItm4 = "PrtItm4";
				// Query immediate parent:
				DbQuery qry = new DbQuery(Database.DbmsType);
				qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm1);
				qry.Columns.Add("1");
				// Parent #2:
				DbQueryJoin join1 = new DbQueryJoin(DbJoinType.LeftOuter);
				join1.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm2);
				join1.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm2) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm1));
				qry.Joins.Add(join1);
				// Parent #3:
				DbQueryJoin join2 = new DbQueryJoin(DbJoinType.LeftOuter);
				join2.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm3);
				join2.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm3) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm2));
				qry.Joins.Add(join2);
				// Parent #4:
				DbQueryJoin join3 = new DbQueryJoin(DbJoinType.LeftOuter);
				join3.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm4);
				join3.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm4) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm3));
				qry.Joins.Add(join3);
				// Filter to ensure that at least one of the parents matches the specified ancestor:
				qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm1) + "=" + colPortfolioItem_ItemIdParent);
				List<String> filter1 = new List<string>();
				filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm1) + "=" + SysId.ToString(prm.AncestorItemId));
				filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm2) + "=" + SysId.ToString(prm.AncestorItemId));
				filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm3) + "=" + SysId.ToString(prm.AncestorItemId));
				filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm4) + "=" + SysId.ToString(prm.AncestorItemId));
				filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm4) + "=" + SysId.ToString(prm.AncestorItemId));
				qry.Filters.Add(filter1.Concat(" OR ", "(", ")"));
				filter.Add("EXISTS (" + qry.BuildQuery() + ")");
			}

			//---------------------------------------------------------------
			// Commodity Id.
			String colPortfolioItem_CommodityId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, aliasPortfolioItem);
			String includedCommodityIds = prm.IncludedCommodityIds.Concat(",");
			if (!StringUtil.IsEmpty(includedCommodityIds))
				filter.Add(colPortfolioItem_CommodityId + " IN (" + includedCommodityIds + ")");
			String excludedCommodityIds = prm.ExcludedCommodityIds.Concat(",");
			if (!StringUtil.IsEmpty(excludedCommodityIds))
				filter.Add(colPortfolioItem_CommodityId + " NOT IN (" + excludedCommodityIds + ")");

			// Commodity code.
			if (!StringUtil.IsEmpty(prm.CommodityCodeFull) || !StringUtil.IsEmpty(prm.CommodityCodePartial))
			{
				String sCmdAlias = "Cmd1";
				DbQuery qry = new DbQuery(Database.DbmsType);
				qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Commodity), sCmdAlias);
				qry.Columns.Add("1");
				qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Id, sCmdAlias) + "=" + colPortfolioItem_CommodityId);
				if (!StringUtil.IsEmpty(prm.CommodityCodeFull))
					qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Code, sCmdAlias) + "='" + DbQuery.FormatForCondition(prm.CommodityCodeFull) + "'");
				else if (!StringUtil.IsEmpty(prm.CommodityCodePartial))
					qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Code, sCmdAlias) + " LIKE '%" + DbQuery.FormatForLike(prm.CommodityCodePartial) + "%'");
				filter.Add("EXISTS (" + qry.BuildQuery() + ")");
			}

			//---------------------------------------------------------------
			// Type.
			String colPortfolioItem_Type = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Type, aliasPortfolioItem);
			if ((int)prm.PortfolioItemType > 0)
				filter.Add(colPortfolioItem_Type + "=" + ((int)prm.PortfolioItemType).ToString());

			//---------------------------------------------------------------
			// Sequence.
			String colPortfolioItem_Seq = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Seq, aliasPortfolioItem);
			if (prm.Sequence > 0)
				filter.Add(colPortfolioItem_Seq + "=" + prm.Sequence);

			//---------------------------------------------------------------
			// Full & Partial Code.
			String colPortfolioItem_Code = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Code, aliasPortfolioItem);
			if (!StringUtil.IsEmpty(prm.CodeFull))
				filter.Add(colPortfolioItem_Code + "='" + DbQuery.FormatForCondition(prm.CodeFull) + "'");
			if (!StringUtil.IsEmpty(prm.CodePartial))
				filter.Add(colPortfolioItem_Code + " LIKE '%" + DbQuery.FormatForLike(prm.CodePartial) + "%'");

			//---------------------------------------------------------------
			// Shortcut.
			String colPortfolioItem_ShortCut = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ShortCut, aliasPortfolioItem);
			if (!StringUtil.IsEmpty(prm.ShortCut))
				filter.Add(colPortfolioItem_ShortCut + " = '" + DbQuery.FormatForCondition(prm.ShortCut) + "'");

			// Status.
			String colPortfolioItem_Status = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Status, aliasPortfolioItem);
			if (prm.StatusCat == SbmPortfolioItem.StatusCat.NotDeleted)
				filter.Add(colPortfolioItem_Status + " NOT IN ('" + StatusDeleted + "')");

			//--------------------------------------------------------------- -
			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}

		//-------------------------------------------------------------------
		// Item sort columns.
		public List<String> GetPortfolioItemSortColumns(SbmPortfolioItem.Params prm)
		{
			// Sort sequence.
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for PortfolioItem columns in case of conflict.
				String sortCol = String.Empty;
				if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.PortfolioItem)
				{
					sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasPortfolioItem);
				}
				else
				{
					sortCol = columnDfn.DataName;
					if (!StringUtil.IsEmpty(columnDfn.SortDataName))
						sortCol = columnDfn.SortDataName;
				}
				if (!sortCol.IsEmpty())
				{
					DbOrderByNullMode orderByNullMode = DbOrderByNullMode.Default; // eSaOrderByDemoteNulls, eSaOrderByPromoteNulls
					sortColumnNames.Add(DbQuery.FormatForOrderBy(sortCol, columnDfn.SortAscending, orderByNullMode).Concat(", "));
				}
			}
			sortColumnNames.RemoveBlanks();
			if (sortColumnNames.IsEmpty())
			{
				// Default sort columns:
				sortColumnNames.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_AffIdOwner, aliasPortfolioItem) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Item count.
		private long GetPortfolioItemCount(String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem) + " As " + aliasPortfolioItem, filter);
		}
		public override long GetPortfolioItemCount(SbmPortfolioItem.Params prm)
		{
			ClearErrorState();
			return GetPortfolioItemCount(GetPortfolioItemQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SbmPortfolioItem> GetPortfolioItemList(SbmPortfolioItem.Params prm)
		{
			ClearErrorState();
			List<SbmPortfolioItem> portfolioItems = new List<SbmPortfolioItem>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), aliasPortfolioItem);
			PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
			qry.Columns.AddRange(dbPortfolioItem.ExistingColumnNames);
			qry.Filters.AddRange(GetPortfolioItemQueryFilter(prm));
			qry.OrderBy.AddRange(GetPortfolioItemSortColumns(prm));
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbPortfolioItem = new PortfolioItem_Db(DbInfo);
							dbPortfolioItem.PopulateFrom(dbDataReader);
							portfolioItems.Add(CreatePortfolioItem(dbPortfolioItem));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return portfolioItems;
		}

		//-------------------------------------------------------------------
		// Item query execution.
		public override DbResultSet ExecutePortfolioItemQuery(List<ColumnDfn> columns, SbmPortfolioItem.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), aliasPortfolioItem);

			//---------------------------------------------------------------
			// PortfolioItem Properties - add columns as defined in query list.
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.ItemIdParent))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.CommodityId))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.ItemIdRef))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdRef, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.Type) || columns.HasId((int)SbmPortfolioItem.Column.Type_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Type, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.Sequence))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Seq, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.Code))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Code, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.Caption))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Caption, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.DescBrief))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_DescBrief, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.DescDetail))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_DescDetail, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.ShortCut))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ShortCut, aliasPortfolioItem));
			// Common Properties
			if (columns.HasId((int)SbmPortfolioItem.Column.Notes))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Notes, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.Publish_Y) || columns.HasId((int)SbmPortfolioItem.Column.Publish_Tick))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Flags, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.Status) || columns.HasId((int)SbmPortfolioItem.Column.Status_Desc) || columns.HasId((int)SbmPortfolioItem.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Status, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CreateOn, aliasPortfolioItem));
			if (columns.HasId((int)SbmPortfolioItem.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_UpdateOn, aliasPortfolioItem));

			//---------------------------------------------------------------
			// Parent item.
			bool hasParentItemCols = columns.HasId((int)SbmPortfolioItem.Column.Parent_Code) || columns.HasId((int)SbmPortfolioItem.Column.Parent_Caption);
			if (hasParentItemCols)
			{
				// Parent item join.
				DbQueryJoin joinParent = new DbQueryJoin(DbJoinType.LeftOuter);
				joinParent.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), aliasPortfolioItem_Parent);
				joinParent.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, aliasPortfolioItem_Parent) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, aliasPortfolioItem));
				query.Joins.Add(joinParent);
				List<SbmDbDfn.ColumnIdx> dbCols = new List<SbmDbDfn.ColumnIdx>();
				dbCols.Add(SbmDbDfn.ColumnIdx.PortfolioItem_Code);
				dbCols.Add(SbmDbDfn.ColumnIdx.PortfolioItem_Caption);
				foreach (SbmDbDfn.ColumnIdx dbColumn in dbCols)
					query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasPortfolioItem_Parent), prefixPortfolioItem_Parent + SbmDbDfn.GetColumnName(dbColumn, false));
			}

			//---------------------------------------------------------------
			// Commodity.
			bool hasCommodityCols =
				columns.HasId((int)SbmPortfolioItem.Column.Commodity_Code) || columns.HasId((int)SbmPortfolioItem.Column.Commodity_DescBrief) ||
				columns.HasId((int)SbmPortfolioItem.Column.Commodity_SalesPrice) || columns.HasId((int)SbmPortfolioItem.Column.Commodity_SalesPrice_Fmt);
			if (hasCommodityCols)
			{
				// Commodity join.
				DbQueryJoin joinCommodity = new DbQueryJoin(DbJoinType.LeftOuter);
				joinCommodity.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Commodity), aliasPortfolioItem_Commodity);
				joinCommodity.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Id, aliasPortfolioItem_Commodity) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, aliasPortfolioItem));
				query.Joins.Add(joinCommodity);
				List<SbmDbDfn.ColumnIdx> dbCols = new List<SbmDbDfn.ColumnIdx>();
				dbCols.Add(SbmDbDfn.ColumnIdx.Commodity_Code);
				dbCols.Add(SbmDbDfn.ColumnIdx.Commodity_DescBrief);
				dbCols.Add(SbmDbDfn.ColumnIdx.Commodity_SalesPrice);
				foreach (SbmDbDfn.ColumnIdx dbColumn in dbCols)
					query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasPortfolioItem_Commodity), prefixPortfolioItem_Commodity + SbmDbDfn.GetColumnName(dbColumn, false));
			}

			//---------------------------------------------------------------------
			// Populate filter.
			query.Filters.AddRange(GetPortfolioItemQueryFilter(prm));

			if (prm.IdsIncluded.Count != 1)
			{
				// Configure sort sequence.
				foreach (String sortColumn in GetPortfolioItemSortColumns(prm))
					query.OrderBy.Add(sortColumn);
			}

			//---------------------------------------------------------------------
			//return new DbResultSet_DataTableReader(Database, query.BuildQuery());
			return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery(prm.ResultsPaging));
		}
		//-------------------------------------------------------------------
	}
	//=======================================================================
}