using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.ItemDocs;
using Sarand.Net.Standard.Dbas.Base;
using Sarand.Net.Standard.Dbas.Data;
using Sarand.Net.Standard.Dbas.ItemDocs.Internal;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.Net.Standard.Dbas.ItemDocs
{
	//=======================================================================
	internal class SaItemDocMgr_Dbas : SaItemDocMgr
	{
		//-------------------------------------------------------------------
		// Data members.
		private SaItemDocConsole_Dbas itemDocConsole = null;

		//-------------------------------------------------------------------
		// Static initialisation.
		static SaItemDocMgr_Dbas ()
		{
		}

		//-------------------------------------------------------------------
		// Construction.
		internal SaItemDocMgr_Dbas (SaItemDocConsole_Dbas itemDocConsole)
		{
			this.itemDocConsole = itemDocConsole;
			DbInfo = new DbDataItem.DatabaseInfo(itemDocConsole.Database);
		}

		//-------------------------------------------------------------------
		// Properties.
		public String TableName_ItemDoc { get { return SaItemDocsDbDfn.GetTableName(SaItemDocsDbDfn.TableIdx.SaItemDoc); } }
		internal ISacsDatabase Database { get { return itemDocConsole.Database; } }
		private DbDataItem.DatabaseInfo DbInfo { get; }
		public override bool DatabaseIsValid { get { return (Database != null && Database.GetTableNames().Contains(TableName_ItemDoc)); } }
		public override bool CanUpdateDatabase { get { return DatabaseIsValid; } }

		//*******************************************************************
		//                         I t e m   D a t a
		//*******************************************************************
		// Utilities.
		public override bool ItemHasDocs (ItemId itemId, bool ignoreDeleted = true)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return false;
			SaItemDoc.Params prmItemDoc = new SaItemDoc.Params();
			prmItemDoc.ItemIdsIncluded.Add(itemId);
			prmItemDoc.StatusCat = (ignoreDeleted ? SaItemDoc.StatusCat.NotDeleted : SaItemDoc.StatusCat.Any);
			return (GetItemDocCount(prmItemDoc) > 0);
		}
		public override bool ItemHasDocs (ItemId itemId, SaItemDocConsole.Category category, bool ignoreDeleted = true)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return false;
			if ((int)category < 1) return false;
			SaItemDoc.Params prmItemDoc = new SaItemDoc.Params();
			prmItemDoc.ItemIdsIncluded.Add(itemId);
			prmItemDoc.Category = category;
			prmItemDoc.StatusCat = (ignoreDeleted ? SaItemDoc.StatusCat.NotDeleted : SaItemDoc.StatusCat.Any);
			return (GetItemDocCount(prmItemDoc) > 0);
		}

		//-------------------------------------------------------------------
		// Create Item.
		public override SaItemDoc CreateItemDoc (ItemId itemId, SaItemDocConsole.Category category)
		{
			ClearErrorState();
			return new SaItemDoc_Dbas(null, itemId, category, 0);
		}
		private SaItemDoc CreateItemDoc (SaItemDoc_Db dbItemDoc)
		{
			ClearErrorState();
			SaItemDoc itemDoc = new SaItemDoc_Dbas(null, new ItemId(dbItemDoc._ItemType, new SysId(dbItemDoc._ItemId)), (SaItemDocConsole.Category)dbItemDoc._Category, (ushort)dbItemDoc._Flags);
			PopulateFrom(dbItemDoc, itemDoc);
			return itemDoc;
		}
		private SaItemDoc CreateItemDoc (DbDataReader dataReader)
		{
			SaItemDoc_Db dbItemDoc = new SaItemDoc_Db(DbInfo);
			dbItemDoc.PopulateFrom(dataReader);
			return CreateItemDoc(dbItemDoc);
		}

		//-------------------------------------------------------------------
		// Item exists.
		public override bool ItemDocExists (SysId id)
		{
			ClearErrorState();
			if (!SysId.IsValid(id)) return false;
			SaItemDoc.Params prmItemDoc = new SaItemDoc.Params();
			prmItemDoc.IdsIncluded.Add(id);
			prmItemDoc.StatusCat = SaItemDoc.StatusCat.Any;
			return (GetItemDocCount(prmItemDoc) > 0);
		}

		//-------------------------------------------------------------------
		// Get Item.
		public override SaItemDoc GetItemDoc (SysId id)
		{
			ClearErrorState();
			if (!SysId.IsValid(id)) return null;
			SaItemDoc.Params prmItemDoc = new SaItemDoc.Params();
			prmItemDoc.IdsIncluded.Add(id);
			prmItemDoc.StatusCat = SaItemDoc.StatusCat.Any;
			return GetItemDoc(prmItemDoc);
		}
		public override SaItemDoc GetItemDoc (SaItemDoc.Params prmItemDoc)
		{
			return GetItemDoc(GetItemDocQueryFilter(prmItemDoc).Concat(" And ", "(", ")"));
		}
		private SaItemDoc GetItemDoc (String filter)
		{
			ClearErrorState();
			if (GetItemDocCount(filter) != 1) return null;
			SaItemDoc itemDoc = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaItemDoc_Db dbItemDoc = new SaItemDoc_Db(DbInfo);
					dbItemDoc.PopulateFrom(dbCommand, aliasItemDoc, filter);
					itemDoc = CreateItemDoc(dbItemDoc);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return itemDoc;
		}

		//-------------------------------------------------------------------
		// Validate ItemDoc.
		public override bool IsValidItemDocData (SaItemDoc.Data itemDocData, SaItemDoc.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidItemDocData(itemDocData, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Insert ItemDoc.
		public override bool InsertItemDoc (SaItemDoc itemDoc, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidItemDoc(itemDoc)) return false;
			if (SysId.IsValid(itemDoc.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaItemDoc_Db dbItemDoc = new SaItemDoc_Db(DbInfo);
					PopulateTo(dbItemDoc, itemDoc, dbUpdateInfo);
					if (SaItemDoc_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbItemDoc._Id = SysId.ToInt(Database.GetNextId("SaItemDoc", dbUpdateInfo));
					}
					dbItemDoc.ExecuteInsertCommand(dbCommand);
					itemDoc.Id = new SysId(dbItemDoc._Id);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdateItemDoc (SaItemDoc itemDoc, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidItemDoc(itemDoc)) return false;
			if (!SysId.IsValid(itemDoc.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					SaItemDoc_Db dbItemDoc = new SaItemDoc_Db(DbInfo);
					dbItemDoc.PopulateFrom(dbCommand, aliasItemDoc, aliasItemDoc + ".Id=" + SysId.ToString(itemDoc.Id));
					// Update item.
					PopulateTo(dbItemDoc, itemDoc, dbUpdateInfo);
					dbItemDoc.ExecuteUpdateCommand(dbCommand);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Delete item.
		public override bool ItemDocCanBeDeleted (SaItemDoc itemDoc)
		{
			ClearErrorState();
			if (!base.ItemDocCanBeDeleted(itemDoc)) return false;
			return true;
		}
		public override bool DeleteItemDoc (SaItemDoc itemDoc, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemDocCanBeDeleted(itemDoc)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					SaItemDoc_Db dbItemDoc = new SaItemDoc_Db(DbInfo);
					dbItemDoc.PopulateFrom(dbCommand, aliasItemDoc, aliasItemDoc + ".Id=" + SysId.ToString(itemDoc.Id));
					// Delete item.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SaItemDocsDbDfn.GetTableName(SaItemDocsDbDfn.TableIdx.SaItemDoc) + " WHERE Id=" + SysId.ToString(itemDoc.Id) + ";";
					dbCommand.ExecuteNonQuery();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}
		public override bool ClearItemDocs (ItemId itemId, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return SetErrorState("Item Id must be specified");
			String colItemType = SaItemDocsDbDfn.GetColumnName(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType);
			String colItemId   = SaItemDocsDbDfn.GetColumnName(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemId);
			String query = "Delete From "+TableName_ItemDoc+" WHERE "+colItemType+"="+itemId.Type.ToString()+" AND "+colItemId+"="+SysId.ToString(itemId.Id);
			Database.ExecuteNonQuery(query);
			if (Database.HasErrorState())
				SetErrorState("Failed to clear Items - " + Database.ErrorStateMessage);
			return !HasErrorState();
		}
		public override bool ClearItemDocs (ItemId itemId, SaItemDocConsole.Category category, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!ItemId.IsValid(itemId)) return SetErrorState("Item Id must be specified");
			if ((int)category < 1) return SetErrorState("Category must be specified");
			String colItemType = SaItemDocsDbDfn.GetColumnName(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType);
			String colItemId   = SaItemDocsDbDfn.GetColumnName(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemId);
			String colCategory = SaItemDocsDbDfn.GetColumnName(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Category);
			String query = "Delete From " + TableName_ItemDoc + " WHERE " + colItemType + "=" + itemId.Type.ToString() + " AND " + colItemId + "=" + SysId.ToString(itemId.Id) + " AND " + colCategory + "='" + ((int)category).ToString() + "';";
			Database.ExecuteNonQuery(query);
			if (Database.HasErrorState())
				SetErrorState("Failed to clear Items - " + Database.ErrorStateMessage);
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo (SaItemDoc_Db dbItemDoc, SaItemDoc itemDoc, DbUpdateInfo dbUpdateInfo)
		{
			dbItemDoc._ItemType = itemDoc.ItemId.Type;
			dbItemDoc._ItemId = SysId.ToInt(itemDoc.ItemId.Id);
			dbItemDoc._Category = (short)itemDoc.Category;
			dbItemDoc._Type = itemDoc.DocType;
			dbItemDoc._DescBrief = itemDoc.DescBrief;
			dbItemDoc._Folder = itemDoc.Folder;
			dbItemDoc._Filename = itemDoc.Filename;
			dbItemDoc._MimeType = itemDoc.MimeType;
			dbItemDoc._ItemTypeAutoAssign = itemDoc.ItemTypeAutoAssign;
			// Common properties.
			dbItemDoc._Notes = itemDoc.Notes;
			dbItemDoc._Status = SacsSystem.GetStatusCode(itemDoc.Status);
			dbItemDoc._Flags = (short)itemDoc.Flags;
			if (!SysId.IsValid(itemDoc.Id))
			{
				dbItemDoc._CreateOn = DateTime.Now;
				dbItemDoc._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbItemDoc._CreateHost = dbUpdateInfo.Host;
			}
			dbItemDoc._UpdateOn = DateTime.Now;
			dbItemDoc._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbItemDoc._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom (SaItemDoc_Db dbItemDoc, SaItemDoc itemDoc)
		{
			//itemDoc.ItemId = new ItemId(dbItemDoc._ItemType, new SysId(dbItemDoc._ItemId));
			//itemDoc.Category = (SaItemDocConsole.Category)dbItemDoc._Category;
			itemDoc.DocType = dbItemDoc._Type;
			itemDoc.DescBrief = dbItemDoc._DescBrief;
			itemDoc.Folder = dbItemDoc._Folder;
			itemDoc.Filename = dbItemDoc._Filename;
			itemDoc.MimeType = dbItemDoc._MimeType;
			itemDoc.ItemTypeAutoAssign = dbItemDoc._ItemTypeAutoAssign;
			// Common properties.
			itemDoc.Notes = dbItemDoc._Notes;
			itemDoc.Status = SacsSystem.GetStatusForCode(dbItemDoc._Status);
			itemDoc.SetCreateStamp(dbItemDoc._CreateOn, new SysId(dbItemDoc._CreateBy), dbItemDoc._CreateHost);
			itemDoc.SetUpdateStamp(dbItemDoc._UpdateOn, new SysId(dbItemDoc._UpdateBy), dbItemDoc._UpdateHost);
			itemDoc.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// ItemDoc column definitions.
		private static readonly String aliasItemDoc = "aItmDoc";
		private void SetItemDocColDfn
			(ColumnDfn col, String caption, int width, SaItemDocsDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SaItemDocsDbDfn.GetTableForColumn(dbCol) == SaItemDocsDbDfn.TableIdx.SaItemDoc)
				alias = aliasItemDoc;
			col.Set(caption, width, (int)dbCol, prefix + SaItemDocsDbDfn.GetColumnName(dbCol, false), SaItemDocsDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
		}
		public override ColumnDfn GetItemDocColumnDfn (SaItemDoc.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId,caption,width);
			switch (columnId)
			{
				case SaItemDoc.Column.Pos:
					SetItemDocColDfn(columnDfn, "Pos", 45, SaItemDocsDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SaItemDoc.Column.Id:
					SetItemDocColDfn(columnDfn, "Id", 60, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaItemDoc.Column.ItemType:
					SetItemDocColDfn(columnDfn, "Item type", 80, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaItemDoc.Column.ItemType_Desc:
					SetItemDocColDfn(columnDfn, "Item type", 100, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType);
					columnDfn.ReadOnly = true;
					break;
				case SaItemDoc.Column.Category:
					SetItemDocColDfn(columnDfn, "Category", 70, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Category, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaItemDoc.Column.Category_Desc:
					SetItemDocColDfn(columnDfn, "Category", 90, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Category, ColumnAlignment.Center);
					columnDfn.ReadOnly = true;
					break;
				case SaItemDoc.Column.DocType:
					SetItemDocColDfn(columnDfn, "Type", 90, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Type, ColumnAlignment.Center);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Type);
					break;
				case SaItemDoc.Column.DocType_Desc:
					SetItemDocColDfn(columnDfn, "Type", 120, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Type);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Type);
					break;
				case SaItemDoc.Column.DescBrief:
					SetItemDocColDfn(columnDfn, "Caption", 120, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_DescBrief);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_DescBrief);
					break;
				case SaItemDoc.Column.Folder:
					SetItemDocColDfn(columnDfn, "Folder", 240, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Folder);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Folder);
					break;
				case SaItemDoc.Column.Filename:
					SetItemDocColDfn(columnDfn, "Filename", 120, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Filename);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Filename);
					break;
				case SaItemDoc.Column.MimeType:
					SetItemDocColDfn(columnDfn, "Mime", 80, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_MimeType, ColumnAlignment.Center);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_MimeType);
					break;
				// Common properties.
				case SaItemDoc.Column.Notes:
					SetItemDocColDfn(columnDfn, "Notes", 240, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Notes);
					columnDfn.MaxLength = (int)SaItemDocsDbDfn.GetColTextLen(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Notes);
					break;
				case SaItemDoc.Column.Status:
					SetItemDocColDfn(columnDfn, "Status", 80, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Status, ColumnAlignment.Center);
					break;
				case SaItemDoc.Column.Status_Desc:
					SetItemDocColDfn(columnDfn, "Status", 90, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Status, ColumnAlignment.Center);
					break;
				case SaItemDoc.Column.Status_Ind:
					SetItemDocColDfn(columnDfn, "Status", 80, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SaItemDoc.Column.CreateOn_Date:
					SetItemDocColDfn(columnDfn, "Created", 80, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaItemDoc.Column.UpdateOn_Date:
					SetItemDocColDfn(columnDfn, "Updated", 80, SaItemDocsDbDfn.ColumnIdx.SaItemDoc_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;
		}

		//-------------------------------------------------------------------
		// ItemDoc query filter.
		public override List<string> GetItemDocQueryFilter (SaItemDoc.Params prm)
		{
			List<String> filter = new List<String>();

			// Item Id.
			String colId = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Id, aliasItemDoc);
			String includedIds = prm.IdsIncluded.Concat(",");
			if (!includedIds.IsEmpty())
				filter.Add(colId + " IN (" + includedIds + ")");
			String excludedIds = prm.IdsExcluded.Concat(",");
			if (!excludedIds.IsEmpty())
				filter.Add(colId + " NOT IN (" + excludedIds + ")");

			// Item Ids.
			List<String> filterItemId = new List<String>();
			String colItemType = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType, aliasItemDoc);
			String colItemId = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemId, aliasItemDoc);
			foreach (ItemId itemId in prm.ItemIdsIncluded)
			{
				filterItemId.Add(colItemType + "=" + itemId.Type.ToString() + " And " + colItemId + "=" + SysId.ToString(itemId.Id));
			}
			if (filterItemId.Count > 0)
				filter.Add(filterItemId.Concat(" Or ", "(", ")"));

			// Category.
			String colCategory = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Category, aliasItemDoc);
			if ((int)prm.Category > 0)
				filter.Add(colCategory + "=" + ((int)prm.Category).ToString());

			// Document type.
			String colDocType = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Type, aliasItemDoc);
			if (!StringUtil.IsEmpty(prm.DocType))
				filter.Add(colDocType + "='" + DbQuery.FormatForCondition(prm.DocType) + "'");

			// Caption.
			String colDescBrief = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_DescBrief, aliasItemDoc);
			if (!StringUtil.IsEmpty(prm.DescBriefPartial))
				filter.Add(colDocType + " Like '%" + DbQuery.FormatForLike(prm.DescBriefPartial) + "%'");

			// Mime.
			String colMimeType = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_MimeType, aliasItemDoc);
			if (!StringUtil.IsEmpty(prm.MimeType))
				filter.Add(colMimeType + "='" + DbQuery.FormatForCondition(prm.MimeType) + "'");

			// Folder.
			String colFolder = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Folder, aliasItemDoc);
			if (!StringUtil.IsEmpty(prm.FolderFull))
				filter.Add(colFolder + "='" + DbQuery.FormatForCondition(prm.FolderFull) + "'");
			else if (!StringUtil.IsEmpty(prm.FolderPartial))
				filter.Add(colFolder + " Like '%" + DbQuery.FormatForLike(prm.FolderPartial) + "%'");

			// Filename.
			String colFilename = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Filename, aliasItemDoc);
			if (!StringUtil.IsEmpty(prm.FilenameFull))
				filter.Add(colFilename + "='" + DbQuery.FormatForCondition(prm.FilenameFull) + "'");

			// ToDo ItemDoc Filter - ItemTypeAutoAssign

			// Status.
			String colStatus = SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Status, aliasItemDoc);
			String statusCurrent = SacsSystem.GetStatusCode(SaStatus.Current);
			String statusDeleted = SacsSystem.GetStatusCode(SaStatus.Deleted);
			if (prm.StatusCat == SaItemDoc.StatusCat.CurrentOnly)
				filter.Add(colStatus + " In ('" + statusCurrent + "')");
			else if (prm.StatusCat == SaItemDoc.StatusCat.NotDeleted)
				filter.Add(colStatus + " Not In ('" + statusDeleted + "')");
			else if (prm.StatusCat == SaItemDoc.StatusCat.DeletedOnly)
				filter.Add(colStatus + " In ('" + statusDeleted + "')");

			if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
			return filter;
		}
		// ItemDoc sort columns.
		public List<String> GetItemDocSortColumns (SaItemDoc.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for ItemDoc columns in case of conflict.
				String sortCol = String.Empty;
				if (SaItemDocsDbDfn.GetTableForColumn((SaItemDocsDbDfn.ColumnIdx)columnDfn.DbColumn) == SaItemDocsDbDfn.TableIdx.SaItemDoc)
				{
					sortCol = SaItemDocsDbDfn.GetColumnNameQual((SaItemDocsDbDfn.ColumnIdx)columnDfn.DbColumn, aliasItemDoc);
				}
				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(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType, aliasItemDoc) + " DESC");
				sortColumnNames.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemId, aliasItemDoc) + " DESC");
				sortColumnNames.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Category, aliasItemDoc) + " DESC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// ItemDoc count.
		private long GetItemDocCount (String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SaItemDocsDbDfn.GetTableName(SaItemDocsDbDfn.TableIdx.SaItemDoc) + " As " + aliasItemDoc, filter);
		}
		public override long GetItemDocCount (SaItemDoc.Params prm)
		{
			ClearErrorState();
			return GetItemDocCount(GetItemDocQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SaItemDoc> GetItemDocList (SaItemDoc.Params prm)
		{
			ClearErrorState();
			List<SaItemDoc> itemDocs = new List<SaItemDoc>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(TableName_ItemDoc, aliasItemDoc);
			SaItemDoc_Db dbItemDoc = new SaItemDoc_Db(DbInfo);
			qry.Columns.AddRange(dbItemDoc.ExistingColumnNames);
			qry.Filters.AddRange(GetItemDocQueryFilter(prm));
			qry.OrderBy.AddRange(GetItemDocSortColumns(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())
							itemDocs.Add(CreateItemDoc(dbDataReader));
					}
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return itemDocs;
		}

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

			//---------------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SaItemDocsDbDfn.GetTableName(SaItemDocsDbDfn.TableIdx.SaItemDoc), aliasItemDoc);

			// Add columns as defined in query list.
			if (columns.HasId((int)SaItemDoc.Column.Id))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Id, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.ItemType) || columns.HasId((int)SaItemDoc.Column.ItemType_Desc))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemType, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.ItemId))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_ItemId, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.Category) || columns.HasId((int)SaItemDoc.Column.Category_Desc))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Category, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.DocType) || columns.HasId((int)SaItemDoc.Column.DocType_Desc))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Type, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.DescBrief))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_DescBrief, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.Folder))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Folder, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.Filename))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Filename, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.MimeType))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_MimeType, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.Notes))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Notes, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.Status) || columns.HasId((int)SaItemDoc.Column.Status_Desc) || columns.HasId((int)SaItemDoc.Column.Status_Ind))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_Status, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.CreateOn_Date))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_CreateOn, aliasItemDoc));
			if (columns.HasId((int)SaItemDoc.Column.UpdateOn_Date))
				query.Columns.Add(SaItemDocsDbDfn.GetColumnNameQual(SaItemDocsDbDfn.ColumnIdx.SaItemDoc_UpdateOn, aliasItemDoc));

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

			// Configure sort sequence.
			foreach (String sortColumn in GetItemDocSortColumns(prm))
				query.OrderBy.Add(sortColumn);

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

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