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.Data;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;

namespace Sarand.BusinessMgr.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	// Stock manager - Locations.
	//=======================================================================
	partial class SbmStockMgr_Dbas
	{
		//-------------------------------------------------------------------
		// Utilities.
		private List<StringPair> GetLogProperties(SbmLocation location)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(location.Id)),
				new StringPair("Code",location.Code),
				new StringPair("Status",location.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Associated data.

		public override bool LocationHasMovements(SysId locationId)
		{
			ClearErrorState();
			if (!SysId.IsValid(locationId)) return false;
			String tableMovement = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Movement);
			if (Database.TableExists(tableMovement))
			{
				List<String> filter = new List<String>();
				filter.Add($"{SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Movement_LocationIdFrom)}={SysId.ToLong(locationId)} Or {SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.Movement_LocationIdTo)}={SysId.ToLong(locationId)}");
				return Database.GetRowCount(tableMovement, filter.Concat(" AND ", "(", ")")) > 0;
			}
			return false;
		}
		public override bool LocationHasStockLevels(SysId locationId)
		{
			ClearErrorState();
			if (!SysId.IsValid(locationId)) return false;
			String tableStockLevel = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.StockLevel);
			if (Database.TableExists(tableStockLevel))
			{
				List<String> filter = new List<String>();
				filter.Add($"{SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.StockLevel_LocationId)}={SysId.ToLong(locationId)}");
				return Database.GetRowCount(tableStockLevel, filter.Concat(" AND ", "(", ")")) > 0;
			}
			return false;
		}

		//-------------------------------------------------------------------
		// Get Item.
		public override SbmLocation GetLocation(SbmLocation.Params prm)
		{
			return GetLocation(GetLocationQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmLocation GetLocation(String filter)
		{
			ClearErrorState();
			long count = GetLocationCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState(ErrorMessage.MultipleItemsFound);
				return null;
			}
			SbmLocation location = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Location_Db dbLocation = new Location_Db(DbInfo);
					dbLocation.PopulateFrom(dbCommand, aliasLocation, filter);
					location = CreateLocation(dbLocation);
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return location;
		}

		//-------------------------------------------------------------------
		// Create Location.
		public override SbmLocation CreateLocation(Sbm.LocationCategory locationCategory)
		{
			return new SbmLocation_Dbas(new SysId(), AffiliateId_Owner, locationCategory, 0);
		}
		private SbmLocation_Dbas CreateLocation(Location_Db dbLocation)
		{
			ClearErrorState();
			SbmLocation_Dbas location = new SbmLocation_Dbas(new SysId(dbLocation._Id), new SysId(dbLocation._AffIdOwner), (Sbm.LocationCategory)dbLocation._Category, (ushort)dbLocation._Flags);
			PopulateFrom(dbLocation, location);
			return location;
		}

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

		//-------------------------------------------------------------------
		// Insert Location.
		public override bool InsertLocation(SbmLocation location, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidLocation(location)) return false;
			if (SysId.IsValid(location.Id)) return SetErrorState(ErrorMessage.ValidItemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Location_Db dbLocation = new Location_Db(DbInfo);
					PopulateTo(dbLocation, location, dbUpdateInfo);
					if (Location_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbLocation._Id = SysId.ToInt(Database.GetNextId("Location", dbUpdateInfo));
					}
					dbLocation.ExecuteInsertCommand(dbCommand);
					location.Id = new SysId(dbLocation._Id);
					location.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted. " + GetLogProperties(location).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Update Location.
		public override bool UpdateLocation(SbmLocation location, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidLocation(location)) return false;
			if (!SysId.IsValid(location.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!location.Changed)
			{
				if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed. " + GetLogProperties(location).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve Location.
					dbConnection.Open();
					Location_Db dbLocation = new Location_Db(DbInfo);
					dbLocation.PopulateFrom(dbCommand, aliasLocation, "Id=" + SysId.ToString(location.Id));
					SbmUpdateLogItemMonitor_Location updateLogMonitor = new SbmUpdateLogItemMonitor_Location(Internals, CreateLocation(dbLocation));

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

					// Record updates.
					updateLogMonitor.RecordUpdatedValues(location);
					updateLogMonitor.LogUpdates();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Delete Location.
		public override bool LocationCanBeDeleted(SbmLocation location)
		{
			ClearErrorState();
			if (!base.LocationCanBeDeleted(location)) return false;
			return true;
		}
		public override bool DeleteLocation(SbmLocation location, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!LocationCanBeDeleted(location)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve Location.
					dbConnection.Open();
					Location_Db dbLocation = new Location_Db(DbInfo);
					dbLocation.PopulateFrom(dbCommand, aliasLocation, "Id=" + location.Id.ToString());
					// Delete Location.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Location) + " WHERE Id=" + SysId.ToString(location.Id) + ";";
					dbCommand.ExecuteNonQuery();
					location.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. " + GetLogProperties(location).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(Location_Db dbLocation, SbmLocation location, DbUpdateInfo dbUpdateInfo)
		{
			dbLocation._Id = location.Id.ToInt();
			dbLocation._AffIdOwner = location.AffiliateIdOwner.ToInt();
			dbLocation._Category = (short)location.LocationCategory;
			dbLocation._Code = location.Code;
			dbLocation._Name = location.Name;
			// Common properties.
			dbLocation._Notes = location.Notes;
			dbLocation._Flags = (short)location.Flags;
			dbLocation._Status = SacsSystem.GetStatusCode(location.Status);
			if (!SysId.IsValid(location.Id))
			{
				dbLocation._CreateOn = DateTime.UtcNow;
				dbLocation._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbLocation._CreateHost = dbUpdateInfo.Host;
			}
			dbLocation._UpdateOn = DateTime.UtcNow;
			dbLocation._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbLocation._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(Location_Db dbLocation, SbmLocation location)
		{
			location.Id = new SysId(dbLocation._Id);
			location.AffiliateIdOwner = new SysId(dbLocation._AffIdOwner);
			location.LocationCategory = (Sbm.LocationCategory)dbLocation._Category;
			location.Code = dbLocation._Code;
			location.Name = dbLocation._Name;
			// Common properties.
			location.Notes = dbLocation._Notes;
			location.Status = SacsSystem.GetStatusForCode(dbLocation._Status);
			location.SetCreateStamp(dbLocation._CreateOn, new SysId(dbLocation._CreateBy), dbLocation._CreateHost);
			location.SetUpdateStamp(dbLocation._UpdateOn ?? default(DateTime), new SysId(dbLocation._UpdateBy ?? 0), dbLocation._UpdateHost);
			location.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasLocation = "aLoc";
		private static readonly String colnameLocation_StockLevelCount = "LocStkLvlCount";

		// Column definition population.
		private void SetLocationColDfn
			(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.Location)
				alias = aliasLocation;
			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)Internals.GetColTextLen(dbCol);
		}

		//-------------------------------------------------------------------
		// Getting Location column definition.
		public override ColumnDfn GetLocationColumnDfn(SbmLocation.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SbmLocation.Column.Pos:
					SetLocationColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;

				// Location Properties.
				case SbmLocation.Column.Id:
					SetLocationColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.Location_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;

				case SbmLocation.Column.Code:
					SetLocationColDfn(columnDfn, "Code", 70, SbmDbDfn.ColumnIdx.Location_Code);
					break;
				case SbmLocation.Column.Name:
					SetLocationColDfn(columnDfn, "Name", 150, SbmDbDfn.ColumnIdx.Location_Name);
					break;
				case SbmLocation.Column.SalesStock_Y:
					SetLocationColDfn(columnDfn, "Sales", 50, SbmDbDfn.ColumnIdx.Location_Flags, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SbmLocation.Column.SalesStock_Tick:
					SetLocationColDfn(columnDfn, "Sales", 50, SbmDbDfn.ColumnIdx.Location_Flags, ColumnAlignment.Center, DataValue.DataType.Bool);
					columnDfn.BoolFormat = ColumnBoolFormat.Tick;
					break;
				case SbmLocation.Column.CalculateStock_Y:
					SetLocationColDfn(columnDfn, "Calc", 50, SbmDbDfn.ColumnIdx.Location_Flags, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SbmLocation.Column.CalculateStock_Tick:
					SetLocationColDfn(columnDfn, "Calc", 50, SbmDbDfn.ColumnIdx.Location_Flags, ColumnAlignment.Center, DataValue.DataType.Bool);
					columnDfn.BoolFormat = ColumnBoolFormat.Tick;
					break;

				// Common properties.
				case SbmLocation.Column.Notes:
					SetLocationColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.Location_Notes);
					break;
				case SbmLocation.Column.Status:
					SetLocationColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.Location_Status, ColumnAlignment.Center);
					break;
				case SbmLocation.Column.Status_Desc:
					SetLocationColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.Location_Status, ColumnAlignment.Center);
					break;
				case SbmLocation.Column.Status_Ind:
					SetLocationColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.Location_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmLocation.Column.CreateOn_Date:
					SetLocationColDfn(columnDfn, "Created", 80, SbmDbDfn.ColumnIdx.Location_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SbmLocation.Column.UpdateOn_Date:
					SetLocationColDfn(columnDfn, "Updated", 80, SbmDbDfn.ColumnIdx.Location_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;

				case SbmLocation.Column.StockLevelCount:
					SetLocationColDfn(columnDfn, "Levels", 80, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = colnameLocation_StockLevelCount;
					break;
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// Location query filter.
		public override List<string> GetLocationQueryFilter(SbmLocation.Params prm)
		{
			List<String> filter = new List<String>();

			// Location Id.
			String colLocation_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Id, aliasLocation);
			String includedIds = prm.IdsIncluded.Concat(",");
			if (!includedIds.IsEmpty())
				filter.Add(colLocation_Id + " IN (" + includedIds + ")");
			String excludedIds = prm.IdsExcluded.Concat(",");
			if (!excludedIds.IsEmpty())
				filter.Add(colLocation_Id + " NOT IN (" + excludedIds + ")");

			//---------------------------------------------------------------
			// Owner.
			String colLocation_AffIdOwner = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_AffIdOwner, aliasLocation);
			filter.Add(colLocation_AffIdOwner + "=" + AffiliateId_Owner.ToString());

			// Location Category.
			String colLocation_Category = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Category, aliasLocation);
			if ((int)prm.LocationCategory > 0)
				filter.Add(colLocation_Category + "=" + ((int)prm.LocationCategory).ToString());

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

			//---------------------------------------------------------------
			// Full & Partial Name.
			String colLocation_Name = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Name, aliasLocation);
			if (!StringUtil.IsEmpty(prm.Name))
				filter.Add(colLocation_Name + " = '" + DbQuery.FormatForCondition(prm.Name) + "'");
			if (!StringUtil.IsEmpty(prm.NamePartial))
				filter.Add(colLocation_Name + " LIKE '" + DbQuery.FormatForLike(prm.NamePartial) + "%'");

			//--------------------------------------------------------------- -
			// Stocking.
			String colLocation_Flags = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Flags, aliasLocation);
			if (prm.RestrictToSalesStock)
				filter.Add(DbQuery.BuildBitMappedFilter(colLocation_Flags, SbmLocation.Flag_SalesStock, true));

			if (prm.RestrictToCalculateStock)
				filter.Add(DbQuery.BuildBitMappedFilter(colLocation_Flags, SbmLocation.Flag_CalculateStock, true));

			// Status.
			String colLocation_Status = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Status, aliasLocation);
			if (prm.StatusCat == SbmLocation.StatusCat.ActiveOnly)
				filter.Add(colLocation_Status + "='" + StatusActive + "'");
			else if (prm.StatusCat == SbmLocation.StatusCat.InactiveOnly)
				filter.Add(colLocation_Status + "<>'" + StatusActive + "'");

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

		//-------------------------------------------------------------------
		// Location sort columns.
		public List<String> GetLocationSortColumns(SbmLocation.Params prm)
		{
			// Sort sequence.
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for Location columns in case of conflict.
				String sortCol = String.Empty;
				if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.Location)
				{
					sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasLocation);
				}
				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.Location_AffIdOwner, aliasLocation) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Location count.
		private long GetLocationCount(String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Location) + " As " + aliasLocation, filter);
		}
		public override long GetLocationCount(SbmLocation.Params prm)
		{
			ClearErrorState();
			return GetLocationCount(GetLocationQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Location list.
		public override List<SbmLocation> GetLocationList(SbmLocation.Params prm)
		{
			ClearErrorState();
			List<SbmLocation> Locations = new List<SbmLocation>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Location), aliasLocation);
			Location_Db dbLocation = new Location_Db(DbInfo);
			qry.Columns.AddRange(dbLocation.ExistingColumnNames);
			qry.Filters.AddRange(GetLocationQueryFilter(prm));
			qry.OrderBy.AddRange(GetLocationSortColumns(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())
						{
							dbLocation = new Location_Db(DbInfo);
							dbLocation.PopulateFrom(dbDataReader);
							Locations.Add(CreateLocation(dbLocation));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return Locations;
		}

		//-------------------------------------------------------------------
		// Location query execution.
		public override DbResultSet ExecuteLocationQuery(List<ColumnDfn> columns, SbmLocation.Params prm)
		{
			ClearErrorState();

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

			//---------------------------------------------------------------
			// Location Properties - add columns as defined in query list.
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Id, aliasLocation));
			if (columns.HasId(SbmLocation.Column.OwnerName))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_AffIdOwner, aliasLocation));
			if (columns.HasId(SbmLocation.Column.Category_Desc))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Category, aliasLocation));
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Code, aliasLocation));
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Name, aliasLocation));
			// Common Properties
			if (columns.HasId(SbmLocation.Column.Notes))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Notes, aliasLocation));

			if (columns.HasId(SbmLocation.Column.Flags) || columns.HasId(SbmLocation.Column.SalesStock_Tick) || columns.HasId(SbmLocation.Column.CalculateStock_Tick))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Flags, aliasLocation));

			if (columns.HasId(SbmLocation.Column.Status) || columns.HasId(SbmLocation.Column.Status_Desc) || columns.HasId(SbmLocation.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_Status, aliasLocation));
			if (columns.HasId(SbmLocation.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_CreateOn, aliasLocation));
			if (columns.HasId(SbmLocation.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Location_UpdateOn, aliasLocation));

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

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

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