Sarand/Common-VS2019
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
f8c5f5458520200130e3d2cf49712e0f7dd4ded0
Common-VS2019/SacsStandardDbas/Dbas/ReferenceData/SbmReferenceDataMgr_Dbas-Region.cs
T
Andy Howard f8c5f54585 BusinessMgr 3.0.1.0
2025-02-19 11:31:45 +00:00

497 lines
20 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.ReferenceData;
using Sarand.Net.Standard.Dbas.Data;
using Sarand.Net.Standard.Dbas.ReferenceData.Internal;
using Sarand.Net.Standard.Dbas.ReferenceData.UpdateLog;
using Sarand.Net.Standard.Base.Utils;
namespace Sarand.Net.Standard.Dbas.ReferenceData
{
//=======================================================================
// Reference Data manager - Regions.
//=======================================================================
internal partial class SaReferenceDataMgr_Dbas : SaReferenceDataMgr
{
//-------------------------------------------------------------------
// Create Region.
public override SaRegion CreateRegion(SaRegionType regionType)
{
ClearErrorState();
return new SaRegion_Dbas(null, regionType, 0);
}
private SaRegion_Dbas CreateRegion(Region_Db dbRegion)
{
ClearErrorState();
SaRegion_Dbas region = new SaRegion_Dbas(new SysId(dbRegion._Id), (SaRegionType)regionTypes.GetTypeForCode(dbRegion._Type), (ushort)dbRegion._Flags);
PopulateFrom(dbRegion, region);
return region;
}
private SaRegion CreateRegion(DbDataReader dataReader)
{
Region_Db dbRegion = new Region_Db(DbInfo);
dbRegion.PopulateFrom(dataReader);
return CreateRegion(dbRegion);
}
//-------------------------------------------------------------------
// Region exists.
public override bool RegionExistsById(SysId id)
{
ClearErrorState();
if (!SysId.IsValid(id)) return false;
return GetRegionCount(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Id, aliasRegion) + "=" + SysId.ToString(id)) == 1;
}
public override bool RegionExistsByType(string code)
{
ClearErrorState();
if (StringUtil.IsEmpty(code)) return false;
return GetRegionCount(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Type, aliasRegion) + "='" + DbQuery.FormatForCondition(code) + "'") == 1;
}
//-------------------------------------------------------------------
// Get Region.
public override SaRegion GetRegion(SaRegion.Params prm)
{
return GetRegion(GetRegionQueryFilter(prm).Concat(" AND ", "(", ")"));
}
private SaRegion GetRegion(String filter)
{
ClearErrorState();
long count = GetRegionCount(filter);
if (count == 0) return null;
if (count != 1)
{
SetErrorState(ErrorMessage.MultipleItemsFound);
return null;
}
SaRegion region = null;
// Query data.
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
Region_Db dbRegion = new Region_Db(DbInfo);
dbRegion.PopulateFrom(dbCommand, aliasRegion, filter);
region = CreateRegion(dbRegion);
}
catch (Exception exc)
{
SetErrorState(ErrorMessage.DatabaseQueryException);
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
}
}
return region;
}
public override SaRegion GetRegionById(SysId id)
{
ClearErrorState();
if (!SysId.IsValid(id)) return null;
return GetRegion("Id=" + SysId.ToString(id));
}
public override SaRegion GetRegionByType(string code)
{
ClearErrorState();
if (StringUtil.IsEmpty(code)) return null;
return GetRegion("Code='" + DbQuery.FormatForCondition(code) + "'");
}
//-------------------------------------------------------------------
// Validate item.
public override bool IsValidRegionData(SaRegion.Data data, SaRegion.ErrField errField)
{
ClearErrorState();
if (!base.IsValidRegionData(data, errField)) return false;
return true;
}
//-------------------------------------------------------------------
// Insert item.
public override bool InsertRegion(SaRegion region, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!IsValidRegion(region)) return false;
if (SysId.IsValid(region.Id)) return SetErrorState(ErrorMessage.ValidItemId);
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
Region_Db dbRegion = new Region_Db(DbInfo);
PopulateTo(dbRegion, region, dbUpdateInfo);
if (Region_Db.FieldsNonId.Contains("Id"))
{
// Generate next Id.
dbRegion._Id = SysId.ToInt(Database.GetNextId("Region", dbUpdateInfo));
}
dbRegion.ExecuteInsertCommand(dbCommand);
region.Id = new SysId(dbRegion._Id);
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return OK;
}
//-------------------------------------------------------------------
// Update item.
public override bool UpdateRegion(SaRegion region, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!IsValidRegion(region)) return false;
if (!SysId.IsValid(region.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
// Retrieve item.
dbConnection.Open();
Region_Db dbRegion = new Region_Db(DbInfo);
dbRegion.PopulateFrom(dbCommand, aliasRegion, "Id=" + SysId.ToString(region.Id));
SaUpdateLogItemMonitor_Region updateLogMonitor = new SaUpdateLogItemMonitor_Region(ReferenceDataConsole, CreateRegion(dbRegion), dbUpdateInfo);
// Update item.
PopulateTo(dbRegion, region, dbUpdateInfo);
dbRegion.ExecuteUpdateCommand(dbCommand);
// Record updates.
updateLogMonitor.RecordUpdatedValues(region);
updateLogMonitor.LogUpdates();
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return OK;
}
//-------------------------------------------------------------------
// Delete item.
public override bool RegionCanBeDeleted(SaRegion region)
{
ClearErrorState();
if (!base.RegionCanBeDeleted(region)) return false;
return true;
}
public override bool DeleteRegion(SaRegion region, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!RegionCanBeDeleted(region)) return false;
using (var dbConnection = Database.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
// Retrieve item.
dbConnection.Open();
Region_Db dbRegion = new Region_Db(DbInfo);
dbRegion.PopulateFrom(dbCommand, aliasRegion, "Id=" + region.Id.ToString());
// Delete item.
dbCommand.CommandType = System.Data.CommandType.Text;
dbCommand.CommandText = "DELETE FROM " + ReferenceDataConsole.TableName_Region + " WHERE Id=" + SysId.ToString(region.Id) + ";";
dbCommand.ExecuteNonQuery();
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return OK;
}
//-------------------------------------------------------------------
// Copy data properties to and from database.
private void PopulateTo(Region_Db dbRegion, SaRegion region, DbUpdateInfo dbUpdateInfo)
{
dbRegion._Id = region.Id.ToInt();
dbRegion._Type = regionTypes.GetCodeForType(region.RegionType);
dbRegion._Name = region.Name;
dbRegion._Parent = SysId.ToInt(region.RegionIdParent);
// Common properties.
dbRegion._Notes = region.Notes;
dbRegion._Status = SacsSystem.GetStatusCode(region.Status);
dbRegion._Flags = (short)region.Flags;
if (!SysId.IsValid(region.Id))
{
dbRegion._CreateOn = DateTime.UtcNow;
dbRegion._CreateBy = dbUpdateInfo.UserId.ToInt();
dbRegion._CreateHost = dbUpdateInfo.Host;
}
dbRegion._UpdateOn = DateTime.UtcNow;
dbRegion._UpdateBy = dbUpdateInfo.UserId.ToInt();
dbRegion._UpdateHost = dbUpdateInfo.Host;
}
private void PopulateFrom(Region_Db dbRegion, SaRegion region)
{
//region.Id = new SysId(dbRegion._Id);
//region.RegionType = (SaRegionType)regionTypes.GetTypeForCode(dbRegion._Type);
region.Name = dbRegion._Name;
region.RegionIdParent = new SysId(dbRegion._Parent);
// Common properties.
region.Notes = dbRegion._Notes;
region.Status = SacsSystem.GetStatusForCode(dbRegion._Status);
region.SetCreateStamp(dbRegion._CreateOn, new SysId(dbRegion._CreateBy), dbRegion._CreateHost);
region.SetUpdateStamp(dbRegion._UpdateOn, new SysId(dbRegion._UpdateBy), dbRegion._UpdateHost);
region.AcceptChanges();
}
//-------------------------------------------------------------------
// Region column definitions.
private static readonly String aliasRegion = "aRgn";
private void SetRegionColDfn
(ColumnDfn col, String caption, int width, SaReferenceDataDbDfn.ColumnIdx dbCol,
ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
String alias = "", String prefix = "")
{
if (String.IsNullOrEmpty(alias) && SaReferenceDataDbDfn.GetTableForColumn(dbCol) == SaReferenceDataDbDfn.TableIdx.Region)
alias = aliasRegion;
col.Set(caption, width, (int)dbCol, prefix + SaReferenceDataDbDfn.GetColumnName(dbCol, false), SaReferenceDataDbDfn.GetColumnNameQual(dbCol, alias), dataType, align);
if (dataType == DataValue.DataType.String && dbCol != SaReferenceDataDbDfn.ColumnIdx.Unknown)
col.MaxLength = (int)SaReferenceDataDbDfn.GetColTextLen(dbCol);
}
//-------------------------------------------------------------------
// Getting region column definition.
public override ColumnDfn GetRegionColumnDfn(SaRegion.Column columnId, string caption = "", int width = 0)
{
ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
switch (columnId)
{
case SaRegion.Column.Pos:
SetRegionColDfn(columnDfn, "Pos", 45, SaReferenceDataDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
columnDfn.ReadOnly = true;
columnDfn.Resizable = false;
break;
case SaRegion.Column.Id:
SetRegionColDfn(columnDfn, "Id", 60, SaReferenceDataDbDfn.ColumnIdx.Region_Id, ColumnAlignment.Right, DataValue.DataType.Long);
columnDfn.ReadOnly = true;
break;
// Region Properties.
case SaRegion.Column.Type:
SetRegionColDfn(columnDfn, "Type", 100, SaReferenceDataDbDfn.ColumnIdx.Region_Type);
break;
case SaRegion.Column.Name:
SetRegionColDfn(columnDfn, "Name", 100, SaReferenceDataDbDfn.ColumnIdx.Region_Name);
break;
case SaRegion.Column.Parent:
SetRegionColDfn(columnDfn, "Parent Id", 80, SaReferenceDataDbDfn.ColumnIdx.Region_Parent, ColumnAlignment.Center, DataValue.DataType.Double);
columnDfn.NumDecimals = 3;
break;
// Derived properties.
/*
case SaRegion.Column.MovementCount:
SetRegionColDfn(columnDfn, "Movements", 80, SaReferenceDataDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
columnDfn.DataName = colRegion_MovementCount;
columnDfn.ReadOnly = true;
break;
case SaRegion.Column.PendingMovementCount:
SetRegionColDfn(columnDfn, "Pending", 80, SaReferenceDataDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
columnDfn.DataName = colRegion_MovementCount_Pending;
columnDfn.ReadOnly = true;
break;
case SaRegion.Column.OnSite_Y:
SetRegionColDfn(columnDfn, "On site", 70, SaReferenceDataDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.String);
columnDfn.DataName = colRegion_MovementCount_OnSite;
columnDfn.ReadOnly = true;
break;
case SaRegion.Column.OnSite_Tick:
SetRegionColDfn(columnDfn, "On site", 70, SaReferenceDataDbDfn.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Bool);
columnDfn.DataName = colRegion_MovementCount_OnSite;
columnDfn.BoolFormat = ColumnBoolFormat.Tick;
columnDfn.ReadOnly = true;
break;
*/
// Common properties.
case SaRegion.Column.Notes:
SetRegionColDfn(columnDfn, "Notes", 240, SaReferenceDataDbDfn.ColumnIdx.Region_Notes);
break;
case SaRegion.Column.Status:
SetRegionColDfn(columnDfn, "Status", 80, SaReferenceDataDbDfn.ColumnIdx.Region_Status, ColumnAlignment.Center);
break;
case SaRegion.Column.Status_Desc:
SetRegionColDfn(columnDfn, "Status", 90, SaReferenceDataDbDfn.ColumnIdx.Region_Status, ColumnAlignment.Center);
break;
case SaRegion.Column.Status_Ind:
SetRegionColDfn(columnDfn, "Status", 80, SaReferenceDataDbDfn.ColumnIdx.Region_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
break;
case SaRegion.Column.CreateOn_Date:
SetRegionColDfn(columnDfn, "Created", 80, SaReferenceDataDbDfn.ColumnIdx.Region_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
columnDfn.ReadOnly = true;
break;
case SaRegion.Column.UpdateOn_Date:
SetRegionColDfn(columnDfn, "Updated", 80, SaReferenceDataDbDfn.ColumnIdx.Region_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;
}
//-------------------------------------------------------------------
// Region query filter.
public override List<string> GetRegionQueryFilter(SaRegion.Params prm)
{
List<String> filter = new List<String>();
// Region Id.
String colId = SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Id, aliasRegion);
if (prm.IdsIncluded.HasValidIds())
filter.Add($"{colId} IN ({prm.IdsIncluded.Concat(",")})");
if (prm.IdsExcluded.HasValidIds())
filter.Add($"{colId} NOT IN ({prm.IdsExcluded.Concat(",")})");
// Type.
if ((int)prm.RegionType > 0)
filter.Add($"{SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Type, aliasRegion)}='{regionTypes.GetCodeForType(prm.RegionType)}'");
// Parent.
if (SysId.IsValid(prm.RegionIdParent))
filter.Add($"{SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Parent, aliasRegion)}={SysId.ToInt(prm.RegionIdParent)}");
// Status.
if (prm.StatusCat == SaRegion.StatusCat.ActiveOnly)
filter.Add($"{SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Status, aliasRegion)} In ('{SacsSystem.GetStatusCode(SaStatus.Current)}','{SacsSystem.GetStatusCode(SaStatus.Active)}')");
if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
return filter;
}
// Region sort columns.
public List<String> GetRegionSortColumns(SaRegion.Params prm)
{
// Sort sequence:
List<String> sortColumnNames = new List<String>();
foreach (var columnDfn in prm.SortColumns)
{
// Need to ensure correct alias used for Region columns in case of conflict.
String sortCol = String.Empty;
if (SaReferenceDataDbDfn.GetTableForColumn((SaReferenceDataDbDfn.ColumnIdx)columnDfn.DbColumn) == SaReferenceDataDbDfn.TableIdx.Region)
{
sortCol = SaReferenceDataDbDfn.GetColumnNameQual((SaReferenceDataDbDfn.ColumnIdx)columnDfn.DbColumn, aliasRegion);
}
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(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Type, aliasRegion) + " ASC");
}
return sortColumnNames;
}
//-------------------------------------------------------------------
// Region count.
private long GetRegionCount(String filter)
{
ClearErrorState();
return Database.GetRowCount(ReferenceDataConsole.TableName_Region + " As " + aliasRegion, filter);
}
public override long GetRegionCount(SaRegion.Params prm)
{
ClearErrorState();
return GetRegionCount(GetRegionQueryFilter(prm).Concat(" AND ", "(", ")"));
}
//-------------------------------------------------------------------
// Region list.
public override List<SaRegion> GetRegionList(SaRegion.Params prm)
{
ClearErrorState();
List<SaRegion> regions = new List<SaRegion>();
DbQuery qry = new DbQuery(Database.DbmsType);
qry.Tables.Add(ReferenceDataConsole.TableName_Region, aliasRegion);
Region_Db dbRegion = new Region_Db(DbInfo);
qry.Columns.AddRange(dbRegion.ExistingColumnNames);
qry.Filters.AddRange(GetRegionQueryFilter(prm));
qry.OrderBy.AddRange(GetRegionSortColumns(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())
regions.Add(CreateRegion(dbDataReader));
}
}
catch (Exception exc)
{
SetErrorState(ErrorMessage.DatabaseQueryException);
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
}
}
return regions;
}
//-------------------------------------------------------------------
// Region query execution.
public override DbResultSet ExecuteRegionQuery(List<ColumnDfn> columns, SaRegion.Params prm)
{
ClearErrorState();
//---------------------------------------------------------------------
// Construct query.
DbQuery query = new DbQuery(Database.DbmsType);
query.Tables.Add(ReferenceDataConsole.TableName_Region, aliasRegion);
// Region Properties - add columns as defined in query list.
if (columns.HasId(SaRegion.Column.Id))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Id, aliasRegion));
if (columns.HasId(SaRegion.Column.Type))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Type, aliasRegion));
if (columns.HasId(SaRegion.Column.Name))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Name, aliasRegion));
if (columns.HasId(SaRegion.Column.Parent))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Parent, aliasRegion));
// Common Properties
if (columns.HasId(SaRegion.Column.Notes))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Notes, aliasRegion));
if (columns.HasId(SaRegion.Column.Status) || columns.HasId(SaRegion.Column.Status_Desc) || columns.HasId(SaRegion.Column.Status_Ind))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_Status, aliasRegion));
if (columns.HasId(SaRegion.Column.CreateOn_Date))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_CreateOn, aliasRegion));
if (columns.HasId(SaRegion.Column.UpdateOn_Date))
query.Columns.Add(SaReferenceDataDbDfn.GetColumnNameQual(SaReferenceDataDbDfn.ColumnIdx.Region_UpdateOn, aliasRegion));
//---------------------------------------------------------------------
// Populate filter.
query.Filters.AddRange(GetRegionQueryFilter(prm));
if (prm.IdsIncluded.Count != 1)
{
// Configure sort sequence.
foreach (String sortColumn in GetRegionSortColumns(prm))
query.OrderBy.Add(sortColumn);
}
//---------------------------------------------------------------------
//return new DbResultSet_DataTableReader(Database, query.BuildQuery());
return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery());
}
//-------------------------------------------------------------------
}
//=======================================================================
}
Reference in New Issue View Git Blame Copy Permalink