using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Sarand.Core.App;
using Sarand.Core.Base;
using Sarand.Core.Bus;
using Sarand.Core.Dbas.Base;
using Sarand.Win.Dbas.Base;
using Sarand.PatientMgr.Core.App;
using Sarand.PatientMgr.Core.Bus;
using Sarand.PatientMgr.Core.Mgr;
using Sarand.PatientMgr.Win.Dbas.Bus;
using Sarand.PatientMgr.Win.Dbas.Internal;
//using Sarand.PatientMgr.Win.Dbas.UpdateLog;
using Sarand.Win.Dbas.Data;

namespace Sarand.PatientMgr.Win.Dbas.Mgr
{
	//=======================================================================
	internal partial class SpmDepartmentMgr_Dbas : SpmDepartmentMgr
	{
		//*******************************************************************
		//                          F a c i l i t y
		//*******************************************************************
		// Utilities.

		//-------------------------------------------------------------------
		// Create Facility.
		public override SpmFacility CreateFacility(SysId facilityId, SysId departmentId, Spm.FacilityType facilityType)
		{
			return new SpmFacility_Dbas(UserContext, facilityId, departmentId, facilityType, 0);
		}
		private SpmFacility_Dbas CreateFacility(SwmFacility_Db dbFacility)
		{
			ClearErrorState();
			SpmFacility_Dbas facility = new SpmFacility_Dbas(UserContext, new SysId(dbFacility._Id), new SysId(dbFacility._DepartmentId), (Spm.FacilityType)dbFacility._Type, (ushort)dbFacility._Flags);
			PopulateFrom(dbFacility, facility);
			return facility;
		}

		//-------------------------------------------------------------------
		// Get Facility.
		public override SpmFacility GetFacility(SpmFacility.Params prm)
		{
			return GetFacility(GetFacilityQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SpmFacility GetFacility(String filter)
		{
			ClearErrorState();
			long count = GetFacilityCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple Facilityes found");
				return null;
			}
			SpmFacility facility = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SwmFacility_Db dbFacility = new SwmFacility_Db(DbInfo);
					dbFacility.PopulateFrom(dbCommand, aliasFacility, filter);
					facility = CreateFacility(dbFacility);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					Logger.Warn(GetType().Name + ".GetFacility\n\tQuery: " + dbCommand.CommandText + "\n\tException: " + exc.Message);
				}
			}
			return facility;
		}

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

		//-------------------------------------------------------------------
		// Insert Facility.
		public override bool InsertFacility(SpmFacility facility, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidFacility(facility)) return false;
			if (SysId.IsValid(facility.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SwmFacility_Db dbFacility = new SwmFacility_Db(DbInfo);
					PopulateTo(dbFacility, facility, dbUpdateInfo);
					if (SwmFacility_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						dbFacility._Id = SysId.ToInt(Database.GetNextId("Facility", dbUpdateInfo));
					}
					dbFacility.ExecuteInsertCommand(dbCommand);
					facility.Id = new SysId(dbFacility._Id);
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update Facility.
		public override bool UpdateFacility(SpmFacility facility, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidFacility(facility)) return false;
			if (!SysId.IsValid(facility.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve Facility.
					dbConnection.Open();
					SwmFacility_Db dbFacility = new SwmFacility_Db(DbInfo);
					dbFacility.PopulateFrom(dbCommand, aliasFacility, "Id=" + SysId.ToString(facility.Id));
					//SpmUpdateLogItemMonitor_Facility updateLogMonitor = new SpmUpdateLogItemMonitor_Facility(UserContext, CreateFacility(dbFacility));

					// Update properties.
					PopulateTo(dbFacility, facility, dbUpdateInfo);
					dbFacility.ExecuteUpdateCommand(dbCommand);

					/* Record updates.
					updateLogMonitor.RecordUpdatedValues(facility);
					updateLogMonitor.LogUpdates();*/
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Delete Facility.
		public override bool FacilityCanBeDeleted(SpmFacility facility)
		{
			ClearErrorState();
			if (!base.FacilityCanBeDeleted(facility)) return false;
			return true;
		}
		public override bool DeleteFacility(SpmFacility facility, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!FacilityCanBeDeleted(facility)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve Facility.
					dbConnection.Open();
					SwmFacility_Db dbFacility = new SwmFacility_Db(DbInfo);
					dbFacility.PopulateFrom(dbCommand, aliasFacility, "Id=" + facility.Id.ToString());
					// Delete Facility.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SpmDbDfn.GetTableName(SpmDbDfn.TableIdx.SwmFacility) + " WHERE Id=" + SysId.ToString(facility.Id) + ";";
					dbCommand.ExecuteNonQuery();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(SwmFacility_Db dbFacility, SpmFacility facility, DbUpdateInfo dbUpdateInfo)
		{
			dbFacility._Id = facility.Id.ToInt();
			dbFacility._Name = facility.Name;
			dbFacility._SortCode = facility.SortCode;
			dbFacility._Description = facility.Desc;
			dbFacility._TemplateMapType = (short)facility.TemplateMapType;
			dbFacility._ScheduleFreezeType = (short)facility.ScheduleFreezeType;
			dbFacility._ScheduleFreezeData = facility.ScheduleFreezeData;
			dbFacility._ApplicFrom = facility.ApplicationFrom;
			dbFacility._ApplicTo = facility.ApplicationTo;

			dbFacility._Notes = facility.Notes;
			dbFacility._Status = SacsSystem.GetStatusCode(facility.Status);
			dbFacility._Flags = (short)facility.Flags;
			if (!SysId.IsValid(facility.Id))
			{
				dbFacility._CreateOn = DateTime.UtcNow;
				dbFacility._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbFacility._CreateHost = dbUpdateInfo.Host;
			}
			dbFacility._UpdateOn = DateTime.UtcNow;
			dbFacility._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbFacility._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(SwmFacility_Db dbFacility, SpmFacility facility)
		{
			facility.Id = new SysId(dbFacility._Id);
			facility.Name = dbFacility._Name;
			facility.SortCode = dbFacility._SortCode;
			facility.Desc = dbFacility._Description;
			facility.TemplateMapType = (Spm.FacilityTemplateMapType)dbFacility._TemplateMapType;
			facility.ScheduleFreezeType = (Spm.ScheduleFreezeType)dbFacility._ScheduleFreezeType;
			facility.ScheduleFreezeData = dbFacility._ScheduleFreezeData;
			facility.ApplicationFrom = dbFacility._ApplicFrom;
			facility.ApplicationTo = dbFacility._ApplicTo;

			facility.Notes = dbFacility._Notes;
			facility.Status = SacsSystem.GetStatusForCode(dbFacility._Status);
			facility.SetCreateStamp(dbFacility._CreateOn, new SysId(dbFacility._CreateBy), dbFacility._CreateHost);
			facility.SetUpdateStamp(dbFacility._UpdateOn, new SysId(dbFacility._UpdateBy), dbFacility._UpdateHost);
			facility.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Facility column definitions.
		private static readonly String aliasFacility = "aFac";
		private void SetFacilityColDfn
			(ColumnDfn col, String caption, int width, SpmDbDfn.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SpmDbDfn.GetTableForColumn(dbCol) == SpmDbDfn.TableIdx.SwmFacility)
				alias = aliasFacility;
			col.Set(caption, width, (int)dbCol, prefix + SpmDbDfn.GetColumnName(dbCol, false), SpmDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SpmDbDfn.ColumnIdx.Unknown)
				col.MaxLength = (int)SpmDbDfn.GetColTextLen(dbCol);
		}
		//-------------------------------------------------------------------
		// Getting prmFacility column definition.
		public override ColumnDfn GetFacilityColumnDfn(SpmFacility.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SpmFacility.Column.Pos:
					SetFacilityColDfn(columnDfn, "Pos", 42, SpmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SpmFacility.Column.Id:
					SetFacilityColDfn(columnDfn, "Id", 40, SpmDbDfn.ColumnIdx.SwmFacility_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;

				// Facility Properties.
				case SpmFacility.Column.DepartmentId:
					SetFacilityColDfn(columnDfn, "DepartmentId", 45, SpmDbDfn.ColumnIdx.SwmFacility_DepartmentId, ColumnAlignment.Right);
					break;
				case SpmFacility.Column.Type:
					SetFacilityColDfn(columnDfn, "Type", 40, SpmDbDfn.ColumnIdx.SwmFacility_Type, ColumnAlignment.Center);
					break;
				case SpmFacility.Column.Type_Desc:
					SetFacilityColDfn(columnDfn, "Type", 90, SpmDbDfn.ColumnIdx.SwmFacility_Type, ColumnAlignment.Center);
					break;
				case SpmFacility.Column.Name:
					SetFacilityColDfn(columnDfn, "Name", 60, SpmDbDfn.ColumnIdx.SwmFacility_Name, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SpmFacility.Column.SortCode:
					SetFacilityColDfn(columnDfn, "SortCode", 60, SpmDbDfn.ColumnIdx.SwmFacility_SortCode, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SpmFacility.Column.Desc:
					SetFacilityColDfn(columnDfn, "Desc", 60, SpmDbDfn.ColumnIdx.SwmFacility_Description, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SpmFacility.Column.TemplateMapType:
					SetFacilityColDfn(columnDfn, "TemplateMapType", 40, SpmDbDfn.ColumnIdx.SwmFacility_Type, ColumnAlignment.Center);
					break;
				case SpmFacility.Column.ScheduleFreezeType:
					SetFacilityColDfn(columnDfn, "ScheduleFreezeType", 40, SpmDbDfn.ColumnIdx.SwmFacility_ScheduleFreezeType, ColumnAlignment.Center);
					break;
				case SpmFacility.Column.FreezeTime:
					SetFacilityColDfn(columnDfn, "ApplicationTo", 70, SpmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					break;
				case SpmFacility.Column.FreezeData:
					SetFacilityColDfn(columnDfn, "ScheduleFreezeData", 60, SpmDbDfn.ColumnIdx.SwmFacility_ScheduleFreezeData, ColumnAlignment.Center, DataValue.DataType.String);
					break;
				case SpmFacility.Column.ApplicFrom:
					SetFacilityColDfn(columnDfn, "ApplicationFrom", 70, SpmDbDfn.ColumnIdx.SwmFacility_ApplicFrom, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					break;
				case SpmFacility.Column.ApplicTo:
					SetFacilityColDfn(columnDfn, "ApplicationTo", 70, SpmDbDfn.ColumnIdx.SwmFacility_ApplicTo, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					break;			

				// Common properties.
				case SpmFacility.Column.Notes:
					SetFacilityColDfn(columnDfn, "Notes", 200, SpmDbDfn.ColumnIdx.SwmFacility_Notes);
					break;
				case SpmFacility.Column.Status:
					SetFacilityColDfn(columnDfn, "Status", 50, SpmDbDfn.ColumnIdx.SwmFacility_Status, ColumnAlignment.Center);
					break;
				case SpmFacility.Column.Status_Desc:
					SetFacilityColDfn(columnDfn, "Status", 50, SpmDbDfn.ColumnIdx.SwmFacility_Status, ColumnAlignment.Center);
					break;
				case SpmFacility.Column.Status_Ind:
					SetFacilityColDfn(columnDfn, "Status", 50, SpmDbDfn.ColumnIdx.SwmFacility_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SpmFacility.Column.CreateOn_Date:
					SetFacilityColDfn(columnDfn, "Created", 65, SpmDbDfn.ColumnIdx.SwmFacility_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SpmFacility.Column.UpdateOn_Date:
					SetFacilityColDfn(columnDfn, "Updated", 65, SpmDbDfn.ColumnIdx.SwmFacility_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;
		}

		//-------------------------------------------------------------------
		// Facility query filter.
		public override List<string> GetFacilityQueryFilter(SpmFacility.Params prm)
		{
			List<String> filters = new List<String>();

			// Facility Id.
			String includedIds = prm.IncludedIds.Concat(",");
			if (!includedIds.IsEmpty())
				filters.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Id, aliasFacility) + " IN (" + includedIds + ")");
			String excludedIds = prm.ExcludedIds.Concat(",");
			if (!excludedIds.IsEmpty())
				filters.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Id, aliasFacility) + " NOT IN (" + excludedIds + ")");

			// Applicable dates.
			DateTime nullDate = new DateTime(1970, 1, 1);
			String colApplicFrom = SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_ApplicFrom, aliasFacility);
			String colApplicTo = SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_ApplicTo, aliasFacility);
			if (DateUtil.IsValid(prm.Application))
			{
				// Looking for roles that are applicable on the specified date.
				filters.Add("(" + colApplicFrom + " IS NULL OR " + colApplicFrom + "=" + DbQuery.FormatDateForCondition(nullDate) + " OR " + colApplicFrom + "<" + DbQuery.FormatDateForCondition(DateUtil.IncrementDate(prm.Application, 1)) + ")");
				filters.Add("(" + colApplicTo + " IS NULL OR " + colApplicTo + "=" + DbQuery.FormatDateForCondition(nullDate) + " OR " + colApplicTo + ">=" + DbQuery.FormatDateForCondition(prm.Application) + ")");
			}
			else if (DateUtil.IsValid(prm.ApplicationFrom) || DateUtil.IsValid(prm.ApplicationTo))
			{
				// Looking for roles that overlap with the specified date range.
				if (DateUtil.IsValid(prm.ApplicationFrom) && DateUtil.IsValid(prm.ApplicationTo))
				{
					// Both from and to dates specified.
					filters.Add("(" + colApplicFrom + " IS NULL OR " + colApplicFrom + "=" + DbQuery.FormatDateForCondition(nullDate) + " OR " + colApplicFrom + "<" + DbQuery.FormatDateForCondition(DateUtil.IncrementDate(prm.ApplicationTo, 1)) + ")");
					filters.Add("(" + colApplicTo + " IS NULL OR " + colApplicTo + "=" + DbQuery.FormatDateForCondition(nullDate) + " OR " + colApplicTo + ">=" + DbQuery.FormatDateForCondition(prm.ApplicationFrom) + ")");
				}
				else if (DateUtil.IsValid(prm.ApplicationFrom))
				{
					// Only 'from' date specified - Matches with ApplicTo not specified or after 'from' date.
					filters.Add("(" + colApplicTo + " IS NULL OR " + colApplicTo + "=" + DbQuery.FormatDateForCondition(nullDate) + " OR " + colApplicTo + ">=" + DbQuery.FormatDateForCondition(prm.ApplicationFrom) + ")");
					String filter = filters[0];
				}
				else if (DateUtil.IsValid(prm.ApplicationTo))
				{
					// Only 'to' date specified - Matches with ApplicFrom not specified or before 'to' date.
					filters.Add("(" + colApplicFrom + " IS NULL OR " + colApplicFrom + "=" + DbQuery.FormatDateForCondition(nullDate) + " OR " + colApplicFrom + "<" + DbQuery.FormatDateForCondition(DateUtil.IncrementDate(prm.ApplicationTo, 1)) + ")");
					String filter = filters[0];
				}
			}


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

			if (filters.Count < 1) filters.Add("1=1");
			return filters;
		}

		//-------------------------------------------------------------------
		// Facility sort columns.
		public List<String> GetFacilitySortColumns(SpmFacility.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for Facility columns in case of conflict.
				String sortCol = String.Empty;
				if (SpmDbDfn.GetTableForColumn((SpmDbDfn.ColumnIdx)columnDfn.DbColumn) == SpmDbDfn.TableIdx.SwmFacility)
				{
					sortCol = SpmDbDfn.GetColumnNameQual((SpmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasFacility);
				}
				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(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Type, aliasFacility) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Facility count.
		private long GetFacilityCount(String filter)
		{
			ClearErrorState();
			return Database.GetRowCount(SpmDbDfn.GetTableName(SpmDbDfn.TableIdx.SwmFacility) + " As " + aliasFacility, filter);
		}
		public override long GetFacilityCount(SpmFacility.Params prm)
		{
			ClearErrorState();
			return GetFacilityCount(GetFacilityQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Facility list.
		public override List<SpmFacility> GetFacilityList(SpmFacility.Params prm)
		{
			List<SpmFacility> Facilityes = new List<SpmFacility>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(SpmDbDfn.GetTableName(SpmDbDfn.TableIdx.SwmFacility), aliasFacility);
			qry.Columns.AddRange(SwmFacility_Db.Fields);
			qry.Filters.AddRange(GetFacilityQueryFilter(prm));
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery();
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							SwmFacility_Db dbFacility = new SwmFacility_Db(DbInfo);
							dbFacility.PopulateFrom(dbDataReader);
							Facilityes.Add(CreateFacility(dbFacility));
						}
					}
				}
				catch (Exception exc)
				{
					Logger.Warn(GetType().Name + ".GetFacilityList\n\tQuery: " + dbCommand.CommandText + "\n\tException: " + exc.Message);
				}
			}
			return Facilityes;
		}

		//-------------------------------------------------------------------
		// Facility query execution.
		public override DbResultSet ExecuteFacilityQuery(List<ColumnDfn> columns, SpmFacility.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SpmDbDfn.GetTableName(SpmDbDfn.TableIdx.SwmFacility), aliasFacility);

			// Facility Properties - add columns as defined in query list.
			if (columns.HasId((int)SpmFacility.Column.Id))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Id, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.DepartmentId))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_DepartmentId, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.Type) || columns.HasId((int)SpmFacility.Column.Type_Desc))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Type, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.Name))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Name, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.SortCode))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_SortCode, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.Type))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Type, aliasFacility));

			// Common Properties
			if (columns.HasId((int)SpmFacility.Column.Notes))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Notes, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.Status) || columns.HasId((int)SpmFacility.Column.Status_Desc) || columns.HasId((int)SpmFacility.Column.Status_Ind))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_Status, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.CreateOn_Date))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_CreateOn, aliasFacility));
			if (columns.HasId((int)SpmFacility.Column.UpdateOn_Date))
				query.Columns.Add(SpmDbDfn.GetColumnNameQual(SpmDbDfn.ColumnIdx.SwmFacility_UpdateOn, aliasFacility));

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

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

			//---------------------------------------------------------------
			//return new DbResultSet_DataTableReader(Database, query.BuildQuery());
			return new Sarand.Win.Dbas.Data.DbResultSet_DataReader(Database, query.BuildQuery());
		}
		//-------------------------------------------------------------------
	}
	//=======================================================================
}