625 lines
29 KiB
C#
625 lines
29 KiB
C#
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
|
|
{
|
|
//=======================================================================
|
|
// Asset manager - Vehicle Features.
|
|
//=======================================================================
|
|
partial class SbmAssetMgr_Dbas
|
|
{
|
|
//-------------------------------------------------------------------
|
|
// Utilities.
|
|
private List<StringPair> GetLogProperties(SbmVehicleFeature vehicleFeature)
|
|
{
|
|
return new List<StringPair>()
|
|
{
|
|
new StringPair("Id",SysId.ToString(vehicleFeature.Id)),
|
|
new StringPair("CategoryCode",vehicleFeature.CategoryCode),
|
|
new StringPair("Status",vehicleFeature.StatusCode)
|
|
};
|
|
}
|
|
public override bool StoreVehicleFeature(SbmVehicleFeature.Data vehicleFeatureData, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (Database == null) return SetErrorState(ErrorMessage.DatabaseNotAvailable);
|
|
if (!Database.TableExists(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature))) return SetErrorState("vehicle features not supported");
|
|
if (vehicleFeatureData == null) SetErrorState("vehicle feature data not supplied");
|
|
|
|
// Check whether the Vehicle Feature exists.
|
|
SbmVehicleFeature.Params prm = new SbmVehicleFeature.Params
|
|
{
|
|
VehicleId = vehicleFeatureData.VehicleId,
|
|
VehicleFeatureSource = vehicleFeatureData.VehicleFeatureSource,
|
|
VehicleFeatureType = vehicleFeatureData.VehicleFeatureType,
|
|
CategoryCode = vehicleFeatureData.CategoryCode,
|
|
FeatureCode = vehicleFeatureData.FeatureCode,
|
|
};
|
|
SbmVehicleFeature vehicleFeature = GetVehicleFeature(prm);
|
|
if (vehicleFeature != null)
|
|
{
|
|
// Update existing feature.
|
|
vehicleFeature.SetData(vehicleFeatureData);
|
|
if (vehicleFeature.Changed)
|
|
{
|
|
if (UpdateVehicleFeature(vehicleFeature, dbUpdateInfo))
|
|
{
|
|
vehicleFeature.AcceptChanges();
|
|
// Unable to process vehicle feature events - features do not have a system Id: pCon > sessionConsole?
|
|
//if (pCon) pCon->OnItemEvent(eSapItemEvent_Update,eSapItemTypeVehicleFeature,vehicleFeature.Id());
|
|
return true;
|
|
}
|
|
return SetErrorState("database update failed");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Add new feature.
|
|
SbmVehicleFeature.SbmVehicleFeature_Id vehicleFeatureId = new SbmVehicleFeature.SbmVehicleFeature_Id()
|
|
{
|
|
VehicleId = vehicleFeatureData.VehicleId,
|
|
VehicleFeatureSource = vehicleFeatureData.VehicleFeatureSource,
|
|
VehicleFeatureType = vehicleFeatureData.VehicleFeatureType,
|
|
CategoryCode = vehicleFeatureData.CategoryCode,
|
|
FeatureCode = vehicleFeatureData.FeatureCode,
|
|
};
|
|
vehicleFeature = CreateVehicleFeature(vehicleFeatureId);
|
|
vehicleFeature.SetData(vehicleFeatureData);
|
|
if (InsertVehicleFeature(vehicleFeature, dbUpdateInfo))
|
|
{
|
|
vehicleFeature.AcceptChanges();
|
|
// Unable to process vehicle feature events - features do not have a system Id: pCon > sessionConsole?
|
|
//if (pCon) pCon->OnItemEvent(eSapItemEvent_Create,eSapItemTypeVehicleFeature,vehicleFeature.Id());
|
|
return true;
|
|
}
|
|
return SetErrorState("database update failed");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// VehicleFeature exist.
|
|
public override bool VehicleFeatureExistsByVF_Id(SbmVehicleFeature.SbmVehicleFeature_Id id)
|
|
{
|
|
ClearErrorState();
|
|
if (!SysId.IsValid(id.VehicleId) || (int)id.VehicleFeatureSource < 1 || (int)id.VehicleFeatureType < 1) return SetErrorState("Incomplete feature Id specified");
|
|
if (!Database.TableExists(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature)))
|
|
{
|
|
SbmVehicleFeature.Params prm = new SbmVehicleFeature.Params
|
|
{
|
|
VehicleId = id.VehicleId,
|
|
VehicleFeatureSource = id.VehicleFeatureSource,
|
|
VehicleFeatureType = id.VehicleFeatureType,
|
|
CategoryCode = id.CategoryCode,
|
|
FeatureCode = id.FeatureCode,
|
|
StatusCat = SbmVehicleFeature.StatusCat.Any
|
|
};
|
|
return GetVehicleFeatureCount(prm) == 1;
|
|
}
|
|
else SetErrorState("vehicle features not supported");
|
|
return false;
|
|
}
|
|
|
|
public override bool VehicleFeaturesExist(SbmVehicleFeature.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
String tableVehicleFeature = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature);
|
|
if (!Database.TableExists(tableVehicleFeature))
|
|
{
|
|
if (Database != null)
|
|
{
|
|
String filter = GetVehicleFeatureQueryFilter(prm).Concat(" AND ", "(", ")");
|
|
String colVehicleFeature_VehicleId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId);
|
|
return Database.GetRowCount(tableVehicleFeature, /*colVehicleFeature_VehicleId, 0,*/ filter) > 0;
|
|
}
|
|
}
|
|
else SetErrorState("vehicle features not supported");
|
|
return false;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Get VehicleFeature.
|
|
public override SbmVehicleFeature GetVehicleFeature(SbmVehicleFeature.Params prm)
|
|
{
|
|
return GetVehicleFeature(GetVehicleFeatureQueryFilter(prm).Concat(" AND ", "(", ")"));
|
|
}
|
|
private SbmVehicleFeature GetVehicleFeature(String filter)
|
|
{
|
|
ClearErrorState();
|
|
long count = GetVehicleFeatureCount(filter);
|
|
if (count == 0) return null;
|
|
if (count != 1)
|
|
{
|
|
SetErrorState(ErrorMessage.MultipleItemsFound);
|
|
return null;
|
|
}
|
|
SbmVehicleFeature vehicleFeature = null;
|
|
// Query data.
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
SaVehicleFeature_Db dbVehicleFeature = new SaVehicleFeature_Db(DbInfo);
|
|
dbVehicleFeature.PopulateFrom(dbCommand, aliasVehicleFeature, filter);
|
|
vehicleFeature = CreateVehicleFeature(dbVehicleFeature);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
SetErrorState(ErrorMessage.DatabaseQueryException);
|
|
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
|
|
}
|
|
}
|
|
return vehicleFeature;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// Create VehicleFeature.
|
|
public override SbmVehicleFeature CreateVehicleFeature(SbmVehicleFeature.SbmVehicleFeature_Id vehicleFeatureId)
|
|
{
|
|
ClearErrorState();
|
|
SbmVehicleFeature vehicleFeature = null;
|
|
if (vehicleFeatureId != null)
|
|
vehicleFeature = new SbmVehicleFeature_Dbas(vehicleFeatureId.VehicleId, vehicleFeatureId.VehicleFeatureSource, vehicleFeatureId.VehicleFeatureType, 0);
|
|
else SetErrorState("Asset type not identified");
|
|
return vehicleFeature;
|
|
}
|
|
private SbmVehicleFeature_Dbas CreateVehicleFeature(SaVehicleFeature_Db dbVehicleFeature)
|
|
{
|
|
ClearErrorState();
|
|
SbmVehicleFeature_Dbas vehicleFeature = new SbmVehicleFeature_Dbas(new SysId(dbVehicleFeature._VehicleId), (Sbm.VehicleFeatureSource)dbVehicleFeature._Source, (Sbm.VehicleFeatureType)dbVehicleFeature._Type, (ushort)dbVehicleFeature._Flags);
|
|
PopulateFrom(dbVehicleFeature, vehicleFeature);
|
|
return vehicleFeature;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Validate VehicleFeature.
|
|
public override bool IsValidVehicleFeatureData(SbmVehicleFeature.Data data, SbmVehicleFeature.ErrField errField)
|
|
{
|
|
ClearErrorState();
|
|
if (!base.IsValidVehicleFeatureData(data, errField)) return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// Insert VehicleFeature.
|
|
public override bool InsertVehicleFeature(SbmVehicleFeature vehicleFeature, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!IsValidVehicleFeature(vehicleFeature)) return false;
|
|
if (SysId.IsValid(vehicleFeature.Id)) return SetErrorState(ErrorMessage.ValidItemId);
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
SaVehicleFeature_Db dbVehicleFeature = new SaVehicleFeature_Db(DbInfo);
|
|
PopulateTo(dbVehicleFeature, vehicleFeature, dbUpdateInfo);
|
|
dbVehicleFeature.ExecuteInsertCommand(dbCommand);
|
|
vehicleFeature.Changed = false;
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted. " + GetLogProperties(vehicleFeature).Concat(": ").Concat("", "\n\t"));
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Update VehicleFeature.
|
|
public override bool UpdateVehicleFeature(SbmVehicleFeature vehicleFeature, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!IsValidVehicleFeature(vehicleFeature)) return false;
|
|
if (!SysId.IsValid(vehicleFeature.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
|
|
if (!vehicleFeature.Changed)
|
|
{
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed. " + GetLogProperties(vehicleFeature).Concat(": ").Concat("", "\n\t"));
|
|
return true;
|
|
}
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
// Retrieve VehicleFeature.
|
|
dbConnection.Open();
|
|
SaVehicleFeature_Db dbVehicleFeature = new SaVehicleFeature_Db(DbInfo);
|
|
dbVehicleFeature.PopulateFrom(dbCommand, aliasVehicleFeature, "Id=" + SysId.ToString(vehicleFeature.Id));
|
|
SbmUpdateLogItemMonitor_VehicleFeature updateLogMonitor = new SbmUpdateLogItemMonitor_VehicleFeature(Internals, CreateVehicleFeature(dbVehicleFeature));
|
|
|
|
// Update properties.
|
|
PopulateTo(dbVehicleFeature, vehicleFeature, dbUpdateInfo);
|
|
dbVehicleFeature.ExecuteUpdateCommand(dbCommand);
|
|
vehicleFeature.Changed = false;
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Updated. " + GetLogProperties(vehicleFeature).Concat(": ").Concat("", "\n\t"));
|
|
|
|
// Record updates.
|
|
updateLogMonitor.RecordUpdatedValues(vehicleFeature);
|
|
updateLogMonitor.LogUpdates();
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Delete VehicleFeature.
|
|
public override bool VehicleFeatureCanBeDeleted(SbmVehicleFeature vehicleFeature)
|
|
{
|
|
ClearErrorState();
|
|
if (!base.VehicleFeatureCanBeDeleted(vehicleFeature)) return false;
|
|
return true;
|
|
}
|
|
public override bool DeleteVehicleFeature(SbmVehicleFeature vehicleFeature, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!VehicleFeatureCanBeDeleted(vehicleFeature)) return false;
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
// Retrieve prm.
|
|
dbConnection.Open();
|
|
SaVehicleFeature_Db dbVehicleFeature = new SaVehicleFeature_Db(DbInfo);
|
|
dbVehicleFeature.PopulateFrom(dbCommand, aliasVehicleFeature, "Id=" + vehicleFeature.Id.ToString());
|
|
// Delete prm.
|
|
dbCommand.CommandType = System.Data.CommandType.Text;
|
|
dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature) + " WHERE Id=" + SysId.ToString(vehicleFeature.Id) + ";";
|
|
dbCommand.ExecuteNonQuery();
|
|
vehicleFeature.Changed = false;
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. " + GetLogProperties(vehicleFeature).Concat(": ").Concat("", "\n\t"));
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Copy data properties to and from database.
|
|
private void PopulateTo(SaVehicleFeature_Db dbVehicleFeature, SbmVehicleFeature vehicleFeature, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
dbVehicleFeature._VehicleId = vehicleFeature.Id.ToInt();
|
|
dbVehicleFeature._VehicleId = vehicleFeature.VehicleId.ToInt();
|
|
dbVehicleFeature._Source = (short)vehicleFeature.VehicleFeatureSource;
|
|
dbVehicleFeature._Type = (short)vehicleFeature.VehicleFeatureType;
|
|
dbVehicleFeature._CategoryCode = vehicleFeature.CategoryCode;
|
|
dbVehicleFeature._FeatureCode = vehicleFeature.FeatureCode;
|
|
// Common properties.
|
|
dbVehicleFeature._Notes = vehicleFeature.Notes;
|
|
dbVehicleFeature._Status = SacsSystem.GetStatusCode(vehicleFeature.Status);
|
|
dbVehicleFeature._Flags = (short)vehicleFeature.Flags;
|
|
if (!SysId.IsValid(vehicleFeature.Id))
|
|
{
|
|
dbVehicleFeature._CreateOn = DateTime.UtcNow;
|
|
dbVehicleFeature._CreateBy = dbUpdateInfo.UserId.ToInt();
|
|
dbVehicleFeature._CreateHost = dbUpdateInfo.Host;
|
|
}
|
|
dbVehicleFeature._UpdateOn = DateTime.UtcNow;
|
|
dbVehicleFeature._UpdateBy = dbUpdateInfo.UserId.ToInt();
|
|
dbVehicleFeature._UpdateHost = dbUpdateInfo.Host;
|
|
}
|
|
private void PopulateFrom(SaVehicleFeature_Db dbVehicleFeature, SbmVehicleFeature vehicleFeature)
|
|
{
|
|
//vehicleFeature.Id = new SysId(dbVehicleFeature._VehicleId);
|
|
vehicleFeature.VehicleId = new SysId(dbVehicleFeature._VehicleId);
|
|
vehicleFeature.VehicleFeatureSource = (Sbm.VehicleFeatureSource)dbVehicleFeature._Source;
|
|
vehicleFeature.VehicleFeatureType = (Sbm.VehicleFeatureType)dbVehicleFeature._Type;
|
|
vehicleFeature.CategoryCode = dbVehicleFeature._CategoryCode;
|
|
vehicleFeature.FeatureCode = dbVehicleFeature._FeatureCode;
|
|
// Common properties.
|
|
vehicleFeature.Notes = dbVehicleFeature._Notes;
|
|
vehicleFeature.Status = SacsSystem.GetStatusForCode(dbVehicleFeature._Status);
|
|
vehicleFeature.SetCreateStamp(dbVehicleFeature._CreateOn ?? default(DateTime), new SysId(dbVehicleFeature._CreateBy ?? 0), dbVehicleFeature._CreateHost);
|
|
vehicleFeature.SetUpdateStamp(dbVehicleFeature._UpdateOn ?? default(DateTime), new SysId(dbVehicleFeature._UpdateBy ?? 0), dbVehicleFeature._UpdateHost);
|
|
vehicleFeature.AcceptChanges();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Column definitions.
|
|
private static readonly String aliasVehicleFeature = "aVehFtr";
|
|
private static readonly String aliasVehicleFeature_Vehicle = "VehFtr_Veh";
|
|
private static readonly String prefixVehicleFeature_Vehicle = aliasVehicleFeature_Vehicle + "_";
|
|
|
|
// Column definition population.
|
|
private void SetVehicleFeatureColDfn
|
|
(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.SaVehicleFeature)
|
|
alias = aliasVehicleFeature;
|
|
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 GetVehicleFeatureColumnDfn(SbmVehicleFeature.Column columnId, string caption = "", int width = 0)
|
|
{
|
|
ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
|
|
switch (columnId)
|
|
{
|
|
// VehicleFeature Properties.
|
|
case SbmVehicleFeature.Column.Pos:
|
|
SetVehicleFeatureColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
|
|
columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
|
|
columnDfn.ReadOnly = true;
|
|
columnDfn.Resizable = false;
|
|
break;
|
|
case SbmVehicleFeature.Column.VehicleId:
|
|
SetVehicleFeatureColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, ColumnAlignment.Right, DataValue.DataType.Long);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmVehicleFeature.Column.Vehicle_RegNumber:
|
|
SetVehicleFeatureColDfn(columnDfn, "Reg", 70, SbmDbDfn.ColumnIdx.SaVehicle_RegNumber, ColumnAlignment.Center, DataValue.DataType.String, aliasVehicleFeature_Vehicle, prefixVehicleFeature_Vehicle);
|
|
break;
|
|
case SbmVehicleFeature.Column.FeatureSourceDesc:
|
|
SetVehicleFeatureColDfn(columnDfn, "Source", 70, SbmDbDfn.ColumnIdx.SaVehicleFeature_Source, ColumnAlignment.Center);
|
|
break;
|
|
case SbmVehicleFeature.Column.FeatureTypeDesc:
|
|
SetVehicleFeatureColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.SaVehicleFeature_Type, ColumnAlignment.Center);
|
|
break;
|
|
case SbmVehicleFeature.Column.Category:
|
|
SetVehicleFeatureColDfn(columnDfn, "Category", 140, SbmDbDfn.ColumnIdx.SaVehicleFeature_CategoryCode);
|
|
break;
|
|
case SbmVehicleFeature.Column.CategoryCode:
|
|
SetVehicleFeatureColDfn(columnDfn, "Category code", 80, SbmDbDfn.ColumnIdx.SaVehicleFeature_CategoryCode);
|
|
break;
|
|
case SbmVehicleFeature.Column.CategoryDesc:
|
|
SetVehicleFeatureColDfn(columnDfn, "Category", 120, SbmDbDfn.ColumnIdx.SaVehicleFeature_CategoryDesc);
|
|
break;
|
|
case SbmVehicleFeature.Column.Feature:
|
|
SetVehicleFeatureColDfn(columnDfn, "Feature", 180, SbmDbDfn.ColumnIdx.SaVehicleFeature_FeatureCode);
|
|
break;
|
|
case SbmVehicleFeature.Column.FeatureCode:
|
|
SetVehicleFeatureColDfn(columnDfn, "Feature code", 80, SbmDbDfn.ColumnIdx.SaVehicleFeature_FeatureCode);
|
|
break;
|
|
case SbmVehicleFeature.Column.FeatureDesc:
|
|
SetVehicleFeatureColDfn(columnDfn, "Feature", 140, SbmDbDfn.ColumnIdx.SaVehicleFeature_FeatureDesc);
|
|
break;
|
|
// Common properties.
|
|
case SbmVehicleFeature.Column.Notes:
|
|
SetVehicleFeatureColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.SaVehicleFeature_Notes);
|
|
break;
|
|
case SbmVehicleFeature.Column.Flag:
|
|
SetVehicleFeatureColDfn(columnDfn, "Flags", 40, SbmDbDfn.ColumnIdx.SaVehicleFeature_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
|
|
break;
|
|
case SbmVehicleFeature.Column.Status:
|
|
SetVehicleFeatureColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaVehicleFeature_Status, ColumnAlignment.Center);
|
|
break;
|
|
case SbmVehicleFeature.Column.Status_Desc:
|
|
SetVehicleFeatureColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaVehicleFeature_Status);
|
|
break;
|
|
case SbmVehicleFeature.Column.Status_Ind:
|
|
SetVehicleFeatureColDfn(columnDfn, "Status", 50, SbmDbDfn.ColumnIdx.SaVehicleFeature_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
|
|
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
|
|
break;
|
|
case SbmVehicleFeature.Column.CreateOn_Date:
|
|
SetVehicleFeatureColDfn(columnDfn, "Created", 65, SbmDbDfn.ColumnIdx.SaVehicleFeature_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
|
|
columnDfn.DateFormat = "d-MMM-yy";
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmVehicleFeature.Column.UpdateOn_Date:
|
|
SetVehicleFeatureColDfn(columnDfn, "Updated", 65, SbmDbDfn.ColumnIdx.SaVehicleFeature_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
|
|
columnDfn.DateFormat = "d-MMM-yy";
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
}
|
|
if (!String.IsNullOrEmpty(caption))
|
|
columnDfn.Caption = caption;
|
|
if (width > 0)
|
|
columnDfn.Width = width;
|
|
return columnDfn;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// VehicleFeature query filter.
|
|
public override List<string> GetVehicleFeatureQueryFilter(SbmVehicleFeature.Params prm)
|
|
{
|
|
List<String> filter = new List<String>();
|
|
|
|
// Id.
|
|
String includedIds = prm.IdsIncluded.Concat(",");
|
|
String colVehicleFeature_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, aliasVehicleFeature);
|
|
if (!StringUtil.IsEmpty(includedIds))
|
|
filter.Add(colVehicleFeature_Id + " IN (" + includedIds + ")");
|
|
String excludedIds = prm.IdsExcluded.Concat(",");
|
|
if (!StringUtil.IsEmpty(excludedIds))
|
|
filter.Add(colVehicleFeature_Id + " NOT IN (" + excludedIds + ")");
|
|
// Vehicle.
|
|
String colVehicleFeature_VehicleId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, aliasVehicleFeature);
|
|
if (SysId.IsValid(prm.VehicleId))
|
|
filter.Add(colVehicleFeature_VehicleId + "=" + prm.VehicleId.ToString());
|
|
// Feature Source.
|
|
String colVehicleFeature_Source = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Source, aliasVehicleFeature);
|
|
if (prm.VehicleFeatureSource > 0 || prm.FullFeatureId)
|
|
filter.Add(colVehicleFeature_Source + "=" + prm.VehicleFeatureSource.ToString());
|
|
// Feature type.
|
|
String colVehicleFeature_Type = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Type, aliasVehicleFeature);
|
|
if (prm.VehicleFeatureType > 0 || prm.FullFeatureId)
|
|
filter.Add(colVehicleFeature_Type + "=" + ((int)prm.VehicleFeatureType).ToString());
|
|
// Category code.
|
|
String colVehicleFeature_CategoryCode = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_CategoryCode, aliasVehicleFeature);
|
|
if (!StringUtil.IsEmpty(prm.CategoryCode) || prm.FullFeatureId)
|
|
filter.Add(colVehicleFeature_CategoryCode + "='" + DbQuery.FormatForCondition(prm.CategoryCode) + "'");
|
|
// Feature code.
|
|
String colVehicleFeature_FeatureCode = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_FeatureCode, aliasVehicleFeature);
|
|
if (!StringUtil.IsEmpty(prm.FeatureCode) || prm.FullFeatureId)
|
|
filter.Add(colVehicleFeature_FeatureCode + "='" + DbQuery.FormatForCondition(prm.FeatureCode) + "'");
|
|
|
|
if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
|
|
return filter;
|
|
}
|
|
|
|
// VehicleFeature sort columns.
|
|
public List<String> GetVehicleFeatureSortColumns(SbmVehicleFeature.Params prm)
|
|
{
|
|
// Sort sequence:
|
|
List<String> sortColumnCodes = new List<String>();
|
|
foreach (var columnDfn in prm.SortColumns)
|
|
{
|
|
// Need to ensure correct alias used for VehicleFeature columns in case of conflict.
|
|
String sortCol = String.Empty;
|
|
if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.SaVehicleFeature)
|
|
{
|
|
sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasVehicleFeature);
|
|
}
|
|
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.SaVehicleFeature_Type, aliasVehicleFeature) + " ASC");
|
|
}
|
|
return sortColumnCodes;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// VehicleFeature count.
|
|
private long GetVehicleFeatureCount(String filter)
|
|
{
|
|
ClearErrorState();
|
|
return Database.GetRowCount($"{SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature)} As {aliasVehicleFeature}", filter);
|
|
}
|
|
public override long GetVehicleFeatureCount(SbmVehicleFeature.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
return GetVehicleFeatureCount(GetVehicleFeatureQueryFilter(prm).Concat(" AND ", "(", ")"));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// VehicleFeature list.
|
|
public override List<SbmVehicleFeature> GetVehicleFeatureList(SbmVehicleFeature.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
List<SbmVehicleFeature> vehicleFeatures = new List<SbmVehicleFeature>();
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature), aliasVehicleFeature);
|
|
SaVehicleFeature_Db dbVehicleFeature = new SaVehicleFeature_Db(DbInfo);
|
|
qry.Columns.AddRange(dbVehicleFeature.ExistingColumnNames);
|
|
qry.Filters.AddRange(GetVehicleFeatureQueryFilter(prm));
|
|
qry.OrderBy.AddRange(GetVehicleFeatureSortColumns(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())
|
|
{
|
|
dbVehicleFeature = new SaVehicleFeature_Db(DbInfo);
|
|
dbVehicleFeature.PopulateFrom(dbDataReader);
|
|
vehicleFeatures.Add(CreateVehicleFeature(dbVehicleFeature));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
SetErrorState(ErrorMessage.DatabaseQueryException);
|
|
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
|
|
}
|
|
}
|
|
return vehicleFeatures;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// VehicleFeature query execution.
|
|
public override DbResultSet VehicleFeatureExecuteQuery(List<ColumnDfn> columns, SbmVehicleFeature.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
//---------------------------------------------------------------------
|
|
// Construct build database query.
|
|
DbQuery query = new DbQuery(Database.DbmsType);
|
|
query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicleFeature), aliasVehicleFeature);
|
|
|
|
// VehicleFeature Properties - add columns as defined in query list.
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, aliasVehicleFeature));
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Source, aliasVehicleFeature));
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Type, aliasVehicleFeature));
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_CategoryCode, aliasVehicleFeature));
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_CategoryDesc, aliasVehicleFeature));
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_FeatureCode, aliasVehicleFeature));
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_FeatureDesc, aliasVehicleFeature));
|
|
|
|
// Common Properties.
|
|
if (columns.HasId(SbmVehicleFeature.Column.Notes))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Notes, aliasVehicleFeature));
|
|
if (columns.HasId(SbmVehicleFeature.Column.Flag))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Flags, aliasVehicleFeature));
|
|
if (columns.HasId(SbmVehicleFeature.Column.Status) || columns.HasId(SbmVehicleFeature.Column.Status_Desc) || columns.HasId(SbmVehicleFeature.Column.Status_Ind))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_Status, aliasVehicleFeature));
|
|
if (columns.HasId(SbmVehicleFeature.Column.CreateOn_Date))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_CreateOn, aliasVehicleFeature));
|
|
if (columns.HasId(SbmVehicleFeature.Column.UpdateOn_Date))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_UpdateOn, aliasVehicleFeature));
|
|
|
|
//---------------------------------------------------------------------
|
|
// Vehicle.
|
|
bool hasVehicleColumns = false;
|
|
if (!hasVehicleColumns) hasVehicleColumns = columns.HasId(SbmVehicleFeature.Column.Vehicle_RegNumber);
|
|
if (hasVehicleColumns)
|
|
{
|
|
DbQueryJoin joinVeh = new DbQueryJoin(DbJoinType.LeftOuter);
|
|
joinVeh.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.SaVehicle), aliasVehicleFeature_Vehicle);
|
|
joinVeh.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicle_Id, aliasVehicleFeature_Vehicle) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.SaVehicleFeature_VehicleId, aliasVehicleFeature));
|
|
query.Joins.Add(joinVeh);
|
|
// Add the Vehicle columns.
|
|
List<SbmDbDfn.ColumnIdx> dbColumns = new List<SbmDbDfn.ColumnIdx>();
|
|
dbColumns.Add(SbmDbDfn.ColumnIdx.SaVehicle_RegNumber);
|
|
foreach (SbmDbDfn.ColumnIdx dbColumn in dbColumns)
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasVehicleFeature_Vehicle), prefixVehicleFeature_Vehicle + SbmDbDfn.GetColumnName(dbColumn, false));
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Populate filter.
|
|
query.Filters.AddRange(GetVehicleFeatureQueryFilter(prm));
|
|
|
|
if (prm.IdsIncluded.Count != 1)
|
|
{
|
|
// Configure sort sequence.
|
|
foreach (String sortColumn in GetVehicleFeatureSortColumns(prm))
|
|
query.OrderBy.Add(sortColumn);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
//return new DbResultSet_DataTableReader(Database, query.BuildQuery());
|
|
return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery(prm.ResultsPaging));
|
|
}
|
|
//-------------------------------------------------------------------
|
|
}
|
|
//=======================================================================
|
|
}
|