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.Interfaces;
using Sarand.Net.Standard.Base.ItemData;
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
{
	//=======================================================================
	// Asset manager - Asset Vehicles.
	//=======================================================================
	partial class SbmAssetMgr_Dbas
	{
		//-------------------------------------------------------------------
		// Utilities.
		private List<StringPair> GetLogProperties(SbmVehicle vehicle)
		{
			return new List<StringPair>()
			{
				new StringPair("Id",SysId.ToString(vehicle.Id)),
				new StringPair("Vin",vehicle.Vin),
				new StringPair("Status",vehicle.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Odometer Reading.
		public override bool SetVehicleOdometerReading(SbmVehicle vehicle, decimal odometer, DbUpdateInfo dbUpdateInfo)
		{
			if (vehicle == null || !SysId.IsValid(vehicle.Id) || odometer < 1) return false;
			DateTime todayDate = DateTime.MinValue;
			// Check whether there is already a reading for today.
			SbmVehicleEvent vehicleEventUpdated = null;
			SbmVehicleEvent.Params prm = new SbmVehicleEvent.Params();
			prm.VehicleId = vehicle.Id;
			prm.VehicleEventType = Sbm.VehicleEventType.Odometer;
			foreach (SbmVehicleEvent vehicleEvent in GetVehicleEventList(prm))
			{
				// Check whether this event should be used in preference to any previously found.
				if (vehicleEvent.StartOn.Date == todayDate)
				{
					// Always refresh any odometer reading recorded today.
					vehicleEventUpdated = vehicleEvent;
					break;
				}
				else if (vehicleEventUpdated == null && vehicleEvent.Odometer == odometer)
					vehicleEventUpdated = vehicleEvent; // Events with the same reading can be updated (to refresh the date).
				else if (vehicleEventUpdated == null && vehicleEvent.StartOn.Date > vehicleEventUpdated.StartOn.Date && vehicleEvent.Odometer == odometer)
					vehicleEventUpdated = vehicleEvent; // Events with the same reading and more recent date can be refreshed.
			}
			if (vehicleEventUpdated != null)
			{
				vehicleEventUpdated.StartOn = todayDate;
				vehicleEventUpdated.FinishOn = todayDate;
				vehicleEventUpdated.Odometer = odometer;
				if (UpdateVehicleEvent(vehicleEventUpdated, dbUpdateInfo))
				{
				}
#if _DEBUG
					else TRACE("SapVehicle::SetOdometerReading: Failed to update vehicle event - %s\n", assetMgr.ErrorStateMessage);
#endif
			}
			else
			{
				// Create a new reading.
				SbmVehicleEvent vehicleEvent = CreateVehicleEvent(vehicle.Id, Sbm.VehicleEventType.Odometer);
				if (vehicleEvent != null)
				{
					vehicleEventUpdated.StartOn = todayDate;
					vehicleEventUpdated.FinishOn = todayDate;
					vehicleEventUpdated.Odometer = odometer;
					if (InsertVehicleEvent(vehicleEvent, dbUpdateInfo))
					{
					}
#if _DEBUG
						else TRACE("SapVehicle::SetOdometerReading: Failed to add vehicle event - %s\n", assetMgr.ErrorStateMessage);
#endif
				}
#if _DEBUG
					else TRACE("SapVehicle::SetOdometerReading: Failed to create vehicle event - %s\n", assetMgr.ErrorStateMessage);
#endif
			}
			// Update this vehicle itself.
			vehicle.LatestOdo = odometer;
			vehicle.LatestOdoOn = todayDate;
			UpdateVehicle(vehicle, dbUpdateInfo);

			return true;
		}

		//-------------------------------------------------------------------
		// Associated data.
		public override bool VehicleHasAssets(SysId vehicleId)
		{
			if (!SysId.IsValid(vehicleId)) return false;
			String tableAsset = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaAsset);
			if (Database.TableExists(tableAsset))
			{
				List<String> filter = new List<String>();
				filter.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.SaAsset_ItemType) + "=" + ((int)Sbm.ItemType.Vehicle).ToString());
				filter.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.SaAsset_ItemId) + "=" + vehicleId.ToString());
				return Database.GetRowCount(tableAsset, filter.Concat(" AND ", "(", ")")) > 0;
			}
			return false;
		}

		public override bool VehicleHasProcesses(SysId vehicleId)
		{
			ClearErrorState();
			if (!SysId.IsValid(vehicleId)) return false;
			String tableAssetProcess = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaAssetProcess);
			if (Database.TableExists(tableAssetProcess))
			{
				List<String> filter = new List<String>();
				filter.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.SaAssetProcess_AssetId) + "=" + vehicleId.ToString());
				return Database.GetRowCount(tableAssetProcess, filter.Concat(" AND ", "(", ")")) > 0;
			}
			return false;
		}
		public override bool VehicleHasEvents(SysId vehicleId)
		{
			ClearErrorState();
			if (!SysId.IsValid(vehicleId)) return false;
			String tableVehicleEvent = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleEvent);
			if (Database.TableExists(tableVehicleEvent))
			{
				List<String> filter = new List<String>();
				filter.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.SaVehicleEvent_VehicleId) + "=" + vehicleId.ToString());
				return Database.GetRowCount(tableVehicleEvent, filter.Concat(" AND ", "(", ")")) > 0;
			}
			return false;
		}
		public override long GetVehicleFeatureCount(SysId vehicleId)
		{
			ClearErrorState();
			if (!SysId.IsValid(vehicleId)) return 0;
			String tableVehicleFeature = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature);
			if (Database.TableExists(tableVehicleFeature))
			{
				List<String> filter = new List<String>();
				filter.Add(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId) + "=" + vehicleId.ToString());
				return Database.GetRowCount(tableVehicleFeature, filter.Concat(" AND ", "(", ")"));
			}
			return 0;
		}
		public override bool VehicleHasFeatures(SysId vehicleId)
		{
			return GetVehicleFeatureCount(vehicleId) > 0;
		}
		public override bool VehicleHasInterfaceDataItems(SysId vehicleId)
		{
			ClearErrorState();
			if (!SysId.IsValid(vehicleId)) return false;
			return InterfaceConsole.ItemHasDataItems(new SbmItemId(Sbm.ItemType.Vehicle, vehicleId));
		}
		public override bool GetVehicleHpiCheckCount(SysId vehicleId)
		{
			ClearErrorState();
			if (!SysId.IsValid(vehicleId)) return false;

			// ToDo ItemDataConsole & SbmItemData.Params for HpiCheckCount
			/*SaItemDataConsole itemDataConsole = SbmGlobals.Application.GetItemDataConsole(userContext.SessionContext);
			if (itemDataConsole == null)
			{
				SbmItemData.Params prmData = new SbmItemData.Params();
				prmData.lItemId.Add(SaItemId.Id, Sbm.ItemType.Vehicle);
				List<TypeCodeDesc> itemDataTypes = SbmSystem.GetSystemCodes(Sbm.SystemCode.ItemDataType);
				prmData.lDataType.Add(itemDataTypes.GetCodeForType(Sbm.ItemData.Vehicle_HpiResponse));
				prmData.lDataType.RemoveEmpty();
				if (!StringUtil.IsEmpty(prmData.lDataType))
					itemDataConsole.GetItemDataCount(prmData);
			}*/
			return false;
		}
		public override bool VehicleHasItemData(SysId vehicleId)
		{
			ClearErrorState();
			if (!SysId.IsValid(vehicleId)) return false;
			SaItemData.Params prmData = new SaItemData.Params();
			prmData.ItemIdsIncluded.Add(new SbmItemId(Sbm.ItemType.Vehicle, vehicleId));
			return ItemDataConsole.ItemDataExists(prmData);
		}
		public override bool ClearVehicleDependentData(SbmVehicle vehicle, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (vehicle == null || !SysId.IsValid(vehicle.Id)) return false;
			if (!HasErrorState())
			{
				// Remove document references:
				if (!ItemDocConsole.ClearItemDocs(vehicle.GetItemId(), dbUpdateInfo))
					SetErrorState(ItemDocConsole.ErrorStateMessage);
			}
			if (!HasErrorState())
			{
				// Remove Item Data.
				if (!ItemDataConsole.ClearItemData(vehicle.GetItemId(), dbUpdateInfo))
					SetErrorState(ItemDataConsole.ErrorStateMessage);
			}
			if (!HasErrorState())
			{
				// Remove interface data items.
				if (!InterfaceConsole.ClearInterfaceDataItems(vehicle.GetItemId(), dbUpdateInfo))
					SetErrorState(InterfaceConsole.ErrorStateMessage);
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Get Item.
		public override SbmVehicle GetVehicle(SbmVehicle.Params prm)
		{
			return GetVehicle(GetVehicleQueryFilter(prm).Concat(" AND ", "(", ")"));
		}
		private SbmVehicle GetVehicle(String filter)
		{
			ClearErrorState();
			long count = GetVehicleCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState(ErrorMessage.MultipleItemsFound);
				return null;
			}
			SbmVehicle vehicle = null;
			// Query data.
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					SaVehicle_Db dbVehicle = new SaVehicle_Db(DbInfo);
					dbVehicle.PopulateFrom(dbCommand, aliasVehicle, filter);
					vehicle = CreateVehicle(dbVehicle);
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return vehicle;
		}


		//-------------------------------------------------------------------
		// Create Vehicle.
		public override SbmVehicle CreateVehicle()
		{
			ClearErrorState();
			return new SbmVehicle_Dbas(new SysId(), 0);
		}
		private SbmVehicle_Dbas CreateVehicle(SaVehicle_Db dbVehicle)
		{
			ClearErrorState();
			SbmVehicle_Dbas vehicle = new SbmVehicle_Dbas(new SysId(dbVehicle._Id), (ushort)dbVehicle._Flags);
			PopulateFrom(dbVehicle, vehicle);
			return vehicle;
		}

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

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

		//-------------------------------------------------------------------
		// Update Vehicle.
		public override bool UpdateVehicle(SbmVehicle vehicle, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!IsValidVehicle(vehicle)) return false;
			if (!SysId.IsValid(vehicle.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!vehicle.Changed)
			{
				if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed.{GetLogProperties(vehicle).Concat(": ").Concat("", "\n\t")}");
				return true;
			}
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve Vehicle.
					dbConnection.Open();
					SaVehicle_Db dbVehicle = new SaVehicle_Db(DbInfo);
					dbVehicle.PopulateFrom(dbCommand, aliasVehicle, $"Id={SysId.ToString(vehicle.Id)}");
					SbmUpdateLogItemMonitor_Vehicle updateLogMonitor = new SbmUpdateLogItemMonitor_Vehicle(Internals, CreateVehicle(dbVehicle));

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

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

		//-------------------------------------------------------------------
		// Delete Vehicle.
		public override bool VehicleCanBeDeleted(SbmVehicle vehicle)
		{
			ClearErrorState();
			if (!base.VehicleCanBeDeleted(vehicle)) return false;
			return true;
		}
		public override bool DeleteVehicle(SbmVehicle vehicle, DbUpdateInfo dbUpdateInfo)
		{
			ClearErrorState();
			if (!VehicleCanBeDeleted(vehicle)) return false;
			using (var dbConnection = Database.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve prm.
					dbConnection.Open();
					SaVehicle_Db dbVehicle = new SaVehicle_Db(DbInfo);
					dbVehicle.PopulateFrom(dbCommand, aliasVehicle, $"Id={vehicle.Id.ToString()}");
					// Delete prm.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = $"DELETE FROM {SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicle)} WHERE Id={SysId.ToString(vehicle.Id)};";
					dbCommand.ExecuteNonQuery();
					vehicle.Changed = false;
					if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted.{GetLogProperties(vehicle).Concat(": ").Concat("", "\n\t")}");
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return OK;
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(SaVehicle_Db dbVehicle, SbmVehicle vehicle, DbUpdateInfo dbUpdateInfo)
		{
			dbVehicle._Id = vehicle.Id.ToInt();
			dbVehicle._VehicleClassId = vehicle.VehicleClassId.ToInt();
			dbVehicle._RegNumber = vehicle.RegNumber;
			dbVehicle._VIN = vehicle.Vin;
			dbVehicle._CapCode = vehicle.CapCode;
			dbVehicle._KeyNumber = vehicle.KeyNumber;
			dbVehicle._KeyLocation = vehicle.KeyLocation;
			dbVehicle._EngineNumber = vehicle.EngineNumber;
			dbVehicle._EngineCapacity = vehicle.EngineCapacity;
			dbVehicle._Seats = vehicle.Seats;
			dbVehicle._Weight = vehicle.Weight;
			dbVehicle._ManufactureYear = vehicle.ManufactureYear;
			dbVehicle._BuildOn = vehicle.BuildOn;
			dbVehicle._FirstRegisterOn = vehicle.FirstRegisterOn;
			dbVehicle._RegisterOn = vehicle.RegisterOn;
			dbVehicle._RegNumberPrev = vehicle.RegNumberPrev;
			dbVehicle._PurchaseOdo = (int)vehicle.PurchaseOdo;
			dbVehicle._TachoCode = vehicle.TachoCode;
			dbVehicle._TachoId = vehicle.TachoId;
			dbVehicle._LastServiceOdo = (int)vehicle.LastServiceOdo;
			dbVehicle._LastServiceOn = vehicle.LastServiceOn;
			dbVehicle._NextServiceOdo = (int)vehicle.NextServiceOdo;
			dbVehicle._NextServiceOn = vehicle.NextServiceOn;
			dbVehicle._MotOn = vehicle.MotOn;
			dbVehicle._MotNo = vehicle.MotNo;
			dbVehicle._NextTaxOn = vehicle.NextTaxOn;
			dbVehicle._LatestOdo = (int)vehicle.LatestOdo;
			dbVehicle._LatestOdoOn = vehicle.LatestOdoOn;
			// Common properties.
			dbVehicle._Notes = vehicle.Notes;
			dbVehicle._Status = SacsSystem.GetStatusCode(vehicle.Status);
			dbVehicle._Flags = (short)vehicle.Flags;
			if (!SysId.IsValid(vehicle.Id))
			{
				dbVehicle._CreateOn = DateTime.UtcNow;
				dbVehicle._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbVehicle._CreateHost = dbUpdateInfo.Host;
			}
			dbVehicle._UpdateOn = DateTime.UtcNow;
			dbVehicle._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbVehicle._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(SaVehicle_Db dbVehicle, SbmVehicle vehicle)
		{
			//vehicle.Id = new SysId(dbVehicle._Id);
			vehicle.VehicleClassId = new SysId(dbVehicle._VehicleClassId ?? 0);
			vehicle.RegNumber = dbVehicle._RegNumber;
			vehicle.Vin = dbVehicle._VIN;
			vehicle.CapCode = dbVehicle._CapCode;
			vehicle.KeyNumber = dbVehicle._KeyNumber;
			vehicle.KeyLocation = dbVehicle._KeyLocation;
			vehicle.EngineNumber = dbVehicle._EngineNumber;
			vehicle.EngineCapacity = dbVehicle._EngineCapacity ?? 0;
			vehicle.Seats = dbVehicle._Seats ?? 0;
			vehicle.Weight = dbVehicle._Weight ?? 0;
			vehicle.ManufactureYear = dbVehicle._ManufactureYear ?? 0;
			vehicle.BuildOn = dbVehicle._BuildOn ?? default(DateTime);
			vehicle.FirstRegisterOn = dbVehicle._FirstRegisterOn ?? default(DateTime);
			vehicle.RegisterOn = dbVehicle._RegisterOn ?? default(DateTime);
			vehicle.RegNumberPrev = dbVehicle._RegNumberPrev;
			vehicle.PurchaseOdo = dbVehicle._PurchaseOdo ?? 0;
			vehicle.TachoCode = dbVehicle._TachoCode;
			vehicle.TachoId = dbVehicle._TachoId;
			vehicle.LastServiceOdo = dbVehicle._LastServiceOdo ?? 0;
			vehicle.LastServiceOn = dbVehicle._LastServiceOn ?? default(DateTime);
			vehicle.NextServiceOdo = dbVehicle._NextServiceOdo ?? 0;
			vehicle.NextServiceOn = dbVehicle._NextServiceOn ?? default(DateTime);
			vehicle.MotOn = dbVehicle._MotOn ?? default(DateTime);
			vehicle.MotNo = dbVehicle._MotNo;
			vehicle.NextTaxOn = dbVehicle._NextTaxOn ?? default(DateTime);
			vehicle.LatestOdo = dbVehicle._LatestOdo ?? 0;
			vehicle.LatestOdoOn = dbVehicle._LatestOdoOn ?? default(DateTime);
			// Common properties.
			vehicle.Notes = dbVehicle._Notes;
			vehicle.Status = SacsSystem.GetStatusForCode(dbVehicle._Status);
			vehicle.SetCreateStamp(dbVehicle._CreateOn ?? default(DateTime), new SysId(dbVehicle._CreateBy ?? 0), dbVehicle._CreateHost);
			vehicle.SetUpdateStamp(dbVehicle._UpdateOn ?? default(DateTime), new SysId(dbVehicle._UpdateBy ?? 0), dbVehicle._UpdateHost);
			vehicle.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Column definitions.
		private static readonly String aliasVehicle = "aVeh";
		private static readonly String aliasVehicle_VehicleClass = "Veh_VehCls";
		private static readonly String prefixVehicle_VehicleClass = aliasVehicle_VehicleClass + "_";
		// Column names.
		private static readonly String dataNameVehEventCount = "EvtCount";
		private static readonly String dataNameVehFeatureCount = "FtrCount";
		private static readonly String dataNameHpiCheckCount = "HpiCount";

		// Column definition population.
		private void SetVehicleColDfn
			(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.SaVehicle)
				alias = aliasVehicle;
			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 prm column definition.
		public override ColumnDfn GetVehicleColumnDfn(SbmVehicle.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				case SbmVehicle.Column.Pos:
					SetVehicleColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SbmVehicle.Column.Id:
					SetVehicleColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.SaVehicle_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;

				// Vehicle Properties.
				case SbmVehicle.Column.VehicleClass_Id:
					SetVehicleColDfn(columnDfn, "Cat Id", 45, SbmDbDfn.ColumnIdx.SaVehicle_VehicleClassId, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmVehicle.Column.VehicleClass_MakeCode:
					SetVehicleColDfn(columnDfn, "Make", 65, SbmDbDfn.ColumnIdx.SaVehicleClass_MakeCode, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_MakeDesc:
					SetVehicleColDfn(columnDfn, "Make", 75, SbmDbDfn.ColumnIdx.SaVehicleClass_MakeCode, ColumnAlignment.Left, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_Model:
					SetVehicleColDfn(columnDfn, "Model", 80, SbmDbDfn.ColumnIdx.SaVehicleClass_Model, ColumnAlignment.Left, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_Derivative:
					SetVehicleColDfn(columnDfn, "Derivative", 90, SbmDbDfn.ColumnIdx.SaVehicleClass_Derivative, ColumnAlignment.Left, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_DescBrief:
					SetVehicleColDfn(columnDfn, "Vehicle class", 120, SbmDbDfn.ColumnIdx.SaVehicleClass_DescBrief, ColumnAlignment.Left, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_Type:
					SetVehicleColDfn(columnDfn, "Type", 60, SbmDbDfn.ColumnIdx.SaVehicleClass_VehicleType, ColumnAlignment.Center, DataValue.DataType.Long, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_TypeDesc:
					SetVehicleColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.SaVehicleClass_VehicleType, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_CategoryCode:
					SetVehicleColDfn(columnDfn, "Category", 70, SbmDbDfn.ColumnIdx.SaVehicleClass_VehicleCategoryCode, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_CategoryDesc:
					SetVehicleColDfn(columnDfn, "Category", 70, SbmDbDfn.ColumnIdx.SaVehicleClass_VehicleCategoryCode, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_FuelTypeDesc:
					SetVehicleColDfn(columnDfn, "Fuel type", 70, SbmDbDfn.ColumnIdx.SaVehicleClass_FuelType, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_OdometerUnitsDesc:
					SetVehicleColDfn(columnDfn, "Odo units", 70, SbmDbDfn.ColumnIdx.SaVehicleClass_OdometerUnits, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_Seats:
					SetVehicleColDfn(columnDfn, "Seats", 50, SbmDbDfn.ColumnIdx.SaVehicleClass_Seats, ColumnAlignment.Center, DataValue.DataType.Long, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_InsuranceCode:
					SetVehicleColDfn(columnDfn, "Insurance", 70, SbmDbDfn.ColumnIdx.SaVehicleClass_InsuranceCode, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_InsuranceDesc:
					SetVehicleColDfn(columnDfn, "Insurance", 100, SbmDbDfn.ColumnIdx.SaVehicleClass_InsuranceCode, ColumnAlignment.Left, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.VehicleClass_Notes:
					SetVehicleColDfn(columnDfn, "Class Notes", 200, SbmDbDfn.ColumnIdx.SaVehicleClass_Notes, ColumnAlignment.Left, DataValue.DataType.String, aliasVehicle_VehicleClass, prefixVehicle_VehicleClass);
					break;
				case SbmVehicle.Column.RegNumber:
					SetVehicleColDfn(columnDfn, "Registration", 80, SbmDbDfn.ColumnIdx.SaVehicle_RegNumber);
					break;
				case SbmVehicle.Column.RegNumberPrev:
					SetVehicleColDfn(columnDfn, "Reg (prev)", 80, SbmDbDfn.ColumnIdx.SaVehicle_RegNumberPrev);
					break;
				case SbmVehicle.Column.Vin:
					SetVehicleColDfn(columnDfn, "Vin", 100, SbmDbDfn.ColumnIdx.SaVehicle_VIN);
					break;
				case SbmVehicle.Column.CapCode:
					SetVehicleColDfn(columnDfn, "CAP", 90, SbmDbDfn.ColumnIdx.SaVehicle_CapCode);
					break;
				case SbmVehicle.Column.KeyNumber:
					SetVehicleColDfn(columnDfn, "Key #", 90, SbmDbDfn.ColumnIdx.SaVehicle_KeyNumber);
					break;
				case SbmVehicle.Column.KeyLocation:
					SetVehicleColDfn(columnDfn, "Key loc.", 60, SbmDbDfn.ColumnIdx.SaVehicle_KeyLocation);
					break;
				case SbmVehicle.Column.EngineNumber:
					SetVehicleColDfn(columnDfn, "Engine no", 80, SbmDbDfn.ColumnIdx.SaVehicle_EngineNumber);
					break;
				case SbmVehicle.Column.BuildOn:
					SetVehicleColDfn(columnDfn, "Build on", 70, SbmDbDfn.ColumnIdx.SaVehicle_BuildOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.FirstRegisterOn:
					SetVehicleColDfn(columnDfn, "First reg.", 70, SbmDbDfn.ColumnIdx.SaVehicle_FirstRegisterOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.RegisterOn:
					SetVehicleColDfn(columnDfn, "Registered", 70, SbmDbDfn.ColumnIdx.SaVehicle_RegisterOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.PurchaseOdo:
					SetVehicleColDfn(columnDfn, "Purchase odo", 70, SbmDbDfn.ColumnIdx.SaVehicle_PurchaseOdo, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmVehicle.Column.TachoCode:
					SetVehicleColDfn(columnDfn, "Tacho", 100, SbmDbDfn.ColumnIdx.SaVehicle_TachoCode);
					break;
				case SbmVehicle.Column.TachoId:
					SetVehicleColDfn(columnDfn, "Tacho Id", 90, SbmDbDfn.ColumnIdx.SaVehicle_TachoId);
					break;
				case SbmVehicle.Column.LastServiceOdo:
					SetVehicleColDfn(columnDfn, "Last service odo", 70, SbmDbDfn.ColumnIdx.SaVehicle_LastServiceOdo, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmVehicle.Column.LastServiceOn:
					SetVehicleColDfn(columnDfn, "Last service", 70, SbmDbDfn.ColumnIdx.SaVehicle_LastServiceOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.NextServiceOdo:
					SetVehicleColDfn(columnDfn, "Next service odo", 70, SbmDbDfn.ColumnIdx.SaVehicle_NextServiceOdo, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmVehicle.Column.NextServiceOn:
					SetVehicleColDfn(columnDfn, "NextServiceOn", 70, SbmDbDfn.ColumnIdx.SaVehicle_NextServiceOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.MotOn:
					SetVehicleColDfn(columnDfn, "Mot due", 70, SbmDbDfn.ColumnIdx.SaVehicle_MotOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.MotNo:
					SetVehicleColDfn(columnDfn, "MOT No", 80, SbmDbDfn.ColumnIdx.SaVehicle_MotNo);
					break;
				case SbmVehicle.Column.NextTaxOn:
					SetVehicleColDfn(columnDfn, "Next Tax", 70, SbmDbDfn.ColumnIdx.SaVehicle_NextTaxOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				case SbmVehicle.Column.LatestOdo:
					SetVehicleColDfn(columnDfn, "Latest Odo", 70, SbmDbDfn.ColumnIdx.SaVehicle_LatestOdo, ColumnAlignment.Right, DataValue.DataType.Long);
					break;
				case SbmVehicle.Column.LatestOdoOn:
					SetVehicleColDfn(columnDfn, "Latest Odo", 70, SbmDbDfn.ColumnIdx.SaVehicle_LatestOdoOn, ColumnAlignment.Center, DataValue.DataType.Date);
					break;
				// Common properties.
				case SbmVehicle.Column.Notes:
					SetVehicleColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.SaVehicle_Notes);
					break;
				case SbmVehicle.Column.Flag:
					SetVehicleColDfn(columnDfn, "Flags", 40, SbmDbDfn.ColumnIdx.SaVehicle_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SbmVehicle.Column.Status:
					SetVehicleColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaVehicle_Status, ColumnAlignment.Center);
					break;
				case SbmVehicle.Column.Status_Desc:
					SetVehicleColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaVehicle_Status);
					break;
				case SbmVehicle.Column.Status_Ind:
					SetVehicleColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaVehicle_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SbmVehicle.Column.CreateOn_Date:
					SetVehicleColDfn(columnDfn, "Created", 65, SbmDbDfn.ColumnIdx.SaVehicle_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					columnDfn.ReadOnly = true;
					break;
				case SbmVehicle.Column.UpdateOn_Date:
					SetVehicleColDfn(columnDfn, "Updated", 65, SbmDbDfn.ColumnIdx.SaVehicle_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.DateFormat = "d-MMM-yy";
					columnDfn.ReadOnly = true;
					break;
				case SbmVehicle.Column.EventCount:
					SetVehicleColDfn(columnDfn, "Events", 60, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = dataNameVehEventCount;
					break;
				case SbmVehicle.Column.FeatureCount:
					SetVehicleColDfn(columnDfn, "Features", 60, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = dataNameVehFeatureCount;
					break;
				case SbmVehicle.Column.HpiCheckCount:
					SetVehicleColDfn(columnDfn, "HPI Checks", 70, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = dataNameHpiCheckCount;
					break;
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// Vehicle query filter.
		public override List<string> GetVehicleQueryFilter(SbmVehicle.Params prm)
		{
			List<String> filter = new List<String>();

			// Vehicle Id.
			String colVehicle_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicle);
			if (prm.IdsIncluded.HasValidIds())
				filter.Add($"{colVehicle_Id} IN ({prm.IdsIncluded.Concat(",")})");
			if (prm.IdsExcluded.HasValidIds())
				filter.Add($"{colVehicle_Id} NOT IN ({prm.IdsExcluded.Concat(",")})");

			//---------------------------------------------------------------
			// Vehicle Class.
			String colVehicle_VehicleClassId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_VehicleClassId, aliasVehicle);
			if (SysId.IsValid(prm.VehicleClassId))
				filter.Add($"{colVehicle_VehicleClassId}={prm.VehicleClassId.ToString()}");
			String classDesc = DbQuery.FormatForCondition(prm.ClassDescPartial);
			if (!StringUtil.IsEmpty(prm.MakeCode) || !classDesc.IsEmpty())
			{
				DbQuery qryVehicleClass = new DbQuery(Database.DbmsType);
				qryVehicleClass.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleClass), aliasVehicle_VehicleClass);
				qryVehicleClass.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleClass_Id, aliasVehicle_VehicleClass));
				if (!StringUtil.IsEmpty(prm.MakeCode))
					qryVehicleClass.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleClass_MakeCode, aliasVehicle_VehicleClass)}='{prm.MakeCode}'");
				if (!StringUtil.IsEmpty(classDesc))
					qryVehicleClass.Filters.Add($"{DbQuery.FormatFn_Left(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleClass_DescBrief, aliasVehicle_VehicleClass), prm.ClassDescPartial.Length)}='{classDesc}'");
				filter.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_VehicleClassId, aliasVehicle)} IN ({qryVehicleClass.BuildQuery()})");
			}
			//---------------------------------------------------------------
			// Partial Registration.
			if (!StringUtil.IsBlank(prm.RegNumberPartial))
				filter.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_RegNumber, aliasVehicle)} Like '%{DbQuery.FormatForLike(prm.RegNumberPartial)}%'");

			// Partial VIN:
			if (!StringUtil.IsBlank(prm.VinPartial))
				filter.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_VIN, aliasVehicle)} Like '%{DbQuery.FormatForLike(prm.VinPartial)}%'");

			//---------------------------------------------------------------
			// Associated Assets.
			if (SysId.IsValid(prm.AssetCatIdInclude) || SysId.IsValid(prm.AssetCatIdExclude) || SysId.IsValid(prm.AssetProcessIdNext))
			{
				String aliasVehicle_Asset = "aVehAst";
				DbQuery qryAsset = new DbQuery(Database.DbmsType);
				qryAsset.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaAsset), aliasVehicle_Asset);
				qryAsset.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaAsset_Id, aliasVehicle_Asset));
				qryAsset.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaAsset_ItemType, aliasVehicle_Asset)}={(int)Sbm.ItemType.Vehicle}");
				qryAsset.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaAsset_ItemId, aliasVehicle_Asset)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicle)}");
				String colAsset_AssetCategoryId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaAsset_AssetCategoryId, aliasVehicle_Asset);
				String colAsset_ProcessIdNext = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaAsset_ProcessIdNext, aliasVehicle_Asset);
				if (SysId.IsValid(prm.AssetCatIdInclude) || SysId.IsValid(prm.AssetProcessIdNext))
				{
					if (SysId.IsValid(prm.AssetCatIdInclude))
						qryAsset.Filters.Add($"{colAsset_AssetCategoryId}={prm.AssetCatIdInclude.ToString()}");
					if (SysId.IsValid(prm.AssetProcessIdNext))
						qryAsset.Filters.Add($"{colAsset_ProcessIdNext}={prm.AssetProcessIdNext.ToString()}");
					filter.Add($" EXISTS({qryAsset.BuildQuery()})");
				}
				if (SysId.IsValid(prm.AssetCatIdExclude))
				{
					qryAsset.Filters.Add($"{colAsset_AssetCategoryId}={prm.AssetCatIdExclude.ToString()}");
					filter.Add($" NOT EXISTS({qryAsset.BuildQuery()})");
				}
			}
			//---------------------------------------------------------------
			// Status.
			if (prm.StatusCat != SbmVehicle.StatusCat.Any)
			{
				String colStatus = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Status, aliasVehicle);
				if (prm.StatusCat == SbmVehicle.StatusCat.ActiveOnly)
					filter.Add($"{colStatus}='{StatusCurrent}'");
				else if (prm.StatusCat == SbmVehicle.StatusCat.NotDeleted)
					filter.Add($"{colStatus}!='{SacsSystem.GetStatusCode(SaStatus.Deleted)}'");
				else if (prm.StatusCat == SbmVehicle.StatusCat.DeletedOnly)
					filter.Add($"{colStatus}='{SacsSystem.GetStatusCode(SaStatus.Deleted)}'");
			}

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

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

		//-------------------------------------------------------------------
		// Vehicle count.
		private long GetVehicleCount(String filter)
		{
			ClearErrorState();
			return Database.GetRowCount($"{SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicle)} As {aliasVehicle}", filter);
		}
		public override long GetVehicleCount(SbmVehicle.Params prm)
		{
			ClearErrorState();
			return GetVehicleCount(GetVehicleQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Vehicle list.
		public override List<SbmVehicle> GetVehicleList(SbmVehicle.Params prm)
		{
			ClearErrorState();
			List<SbmVehicle> vehicles = new List<SbmVehicle>();
			DbQuery qry = new DbQuery(Database.DbmsType);
			qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicle), aliasVehicle);
			SaVehicle_Db dbVehicle = new SaVehicle_Db(DbInfo);
			qry.Columns.AddRange(dbVehicle.ExistingColumnNames);
			qry.Filters.AddRange(GetVehicleQueryFilter(prm));
			qry.OrderBy.AddRange(GetVehicleSortColumns(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())
						{
							dbVehicle = new SaVehicle_Db(DbInfo);
							dbVehicle.PopulateFrom(dbDataReader);
							vehicles.Add(CreateVehicle(dbVehicle));
						}
					}
				}
				catch (Exception exc)
				{
					SetErrorState(ErrorMessage.DatabaseQueryException);
					SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
				}
			}
			return vehicles;
		}

		//-------------------------------------------------------------------
		// Vehicle query execution.
		public override DbResultSet ExecuteVehicleQuery(List<ColumnDfn> columns, SbmVehicle.Params prm)
		{
			ClearErrorState();
			//---------------------------------------------------------------------
			// Construct build database query.
			DbQuery query = new DbQuery(Database.DbmsType);
			query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicle), aliasVehicle);

			// Vehicle Properties - add columns as defined in query list.
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicle));
			query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_RegNumber, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.RegNumberPrev))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_RegNumberPrev, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.Vin))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_VIN, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.CapCode))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_CapCode, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.KeyNumber))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_KeyNumber, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.KeyLocation))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_KeyLocation, aliasVehicle));

			//---------------------------------------------------------------
			// Vehicle Category.
			bool hasVehicleClassCols = false;
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_MakeCode);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_MakeDesc);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_Model);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_Derivative);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_DescBrief);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_Type);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_TypeDesc);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_CategoryCode);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_CategoryDesc);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_FuelTypeDesc);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_OdometerUnitsDesc);
			if (!hasVehicleClassCols) hasVehicleClassCols = columns.HasId(SbmVehicle.Column.VehicleClass_Notes);
			if (hasVehicleClassCols)
			{
				DbQueryJoin joinVehCat = new DbQueryJoin(DbJoinType.LeftOuter);
				joinVehCat.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleClass), aliasVehicle_VehicleClass);
				joinVehCat.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleClass_Id, aliasVehicle_VehicleClass)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_VehicleClassId, aliasVehicle)}");
				query.Joins.Add(joinVehCat);
				// Add the Vehicle Category columns:
				List<SbmDbDfn.ColumnIdx> dbColumns = new List<SbmDbDfn.ColumnIdx>();
				dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_MakeCode);
				dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_Model);
				if (columns.HasId(SbmVehicle.Column.VehicleClass_Derivative)) dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_Derivative);
				if (columns.HasId(SbmVehicle.Column.VehicleClass_DescBrief)) dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_DescBrief);
				dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_VehicleType);
				dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_VehicleCategoryCode);
				if (columns.HasId(SbmVehicle.Column.VehicleClass_FuelTypeDesc)) dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_FuelType);
				if (columns.HasId(SbmVehicle.Column.VehicleClass_OdometerUnitsDesc)) dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_OdometerUnits);
				if (columns.HasId(SbmVehicle.Column.VehicleClass_Notes)) dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_Notes);
				dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicleClass_Flags);
				foreach (SbmDbDfn.ColumnIdx dbColumn in dbColumns)
					query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasVehicle_VehicleClass), prefixVehicle_VehicleClass + SbmDbDfn.GetColumnName(dbColumn, false));
			}

			//---------------------------------------------------------------
			// Event count.
			if (Database.TableExists(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleEvent)))
			{
				bool countVehicles = columns.HasId(SbmVehicle.Column.EventCount);
				if (countVehicles)
				{
					// Build sub query to directly return the number of associated Events:
					String aliasVehicle_VehicleEvent = "aVehVehEvt";
					DbQuery qryEvent = new DbQuery(Database.DbmsType);
					qryEvent.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleEvent), aliasVehicle_VehicleEvent);
					qryEvent.Columns.Add($"Count({SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleEvent_Id, aliasVehicle_VehicleEvent)})");
					qryEvent.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleEvent_VehicleId, aliasVehicle_VehicleEvent)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicle)}");
					query.Columns.Add($"({qryEvent.BuildQuery()})", dataNameVehEventCount);
				}
			}
			//---------------------------------------------------------------
			// Feature count.
			bool bCountFeatures = columns.HasId(SbmVehicle.Column.FeatureCount);
			if (bCountFeatures)
			{
				if (Database.TableExists(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature)))
				{
					// Build sub query to directly return the number of associated Features:
					String aliasVehicle_VehicleFeature = "aVehVehFtr";
					DbQuery qryFeature = new DbQuery(Database.DbmsType);
					qryFeature.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature), aliasVehicle_VehicleFeature);
					qryFeature.Columns.Add($"Count({SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, aliasVehicle_VehicleFeature)})");
					qryFeature.Filters.Add($"{SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, aliasVehicle_VehicleFeature)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicle)}");
					query.Columns.Add($"({qryFeature.BuildQuery()})", dataNameVehFeatureCount);
				}
			}

			//---------------------------------------------------------------
			// HpiCheck count.
			bool bCountHpiChecks = columns.HasId(SbmVehicle.Column.HpiCheckCount);
			if (bCountHpiChecks)
			{
				SaItemDataConsole itemDataConsole = Internals.ItemDataConsole;
				if (itemDataConsole != null && itemDataConsole.DatabaseIsValid)
				{
					// Build sub query to directly return the number of associated HpiChecks.
					String aliasVehicle_ItemData = "aVehItmDat";
					DbQuery qryItemData = new DbQuery(Database.DbmsType);
					qryItemData.Tables.Add(SaItemDataDbDfn.GetTableName(SaItemDataDbDfn.TableIdx.SaItemData), aliasVehicle_ItemData);
					qryItemData.Columns.Add($"Count({SaItemDataDbDfn.GetColumnNameQual(SaItemDataDbDfn.ColumnIdx.SaItemData_Id, aliasVehicle_ItemData)})");
					qryItemData.Filters.Add($"{SaItemDataDbDfn.GetColumnNameQual(SaItemDataDbDfn.ColumnIdx.SaItemData_ItemType, aliasVehicle_ItemData)}={(int)Sbm.ItemType.Vehicle}");
					qryItemData.Filters.Add($"{SaItemDataDbDfn.GetColumnNameQual(SaItemDataDbDfn.ColumnIdx.SaItemData_ItemId, aliasVehicle_ItemData)}={SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicle)}");
					List<TypeCodeDesc> itemDataTypes = new List<TypeCodeDesc>();
					qryItemData.Filters.Add($"{SaItemDataDbDfn.GetColumnNameQual(SaItemDataDbDfn.ColumnIdx.SaItemData_DataType, aliasVehicle_ItemData)}='{itemDataTypes.GetCodeForType(Sbm.ItemDataType.Vehicle_HpiResponse)}'");
					query.Columns.Add($"({qryItemData.BuildQuery()})", dataNameHpiCheckCount);
				}
			}
			// Common Properties
			if (columns.HasId(SbmVehicle.Column.Notes))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Notes, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.Flag))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Flags, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.Status) || columns.HasId(SbmVehicle.Column.Status_Desc) || columns.HasId(SbmVehicle.Column.Status_Ind))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Status, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.CreateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_CreateOn, aliasVehicle));
			if (columns.HasId(SbmVehicle.Column.UpdateOn_Date))
				query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_UpdateOn, aliasVehicle));

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

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

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