andy/Saxonite
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
master
Saxonite/Workspace/SaxoniteStandardDbas/Dbas/Mgr/SaxItemDataMgr_Dbas-ItemSport.cs
T
andy 9f22b522df v1.3.0 Restructure Saxonite workspace and upgrade to .NET 10 (#1) 
Move Saxonite’s projects into a dedicated `Workspace` folder and align the solution with .NET 10 and the current Common workspace. Update encryption integration, test project structure and coverage, and repository guidance and upgrade notes.

- Relocate application and library projects while retaining Git rename history.
- Split tests into Admin, Online, and Shared projects; add representative behavioral and serialization tests.
- Update Common integration, application version, and repository documentation.

Application version: 1.3.0

Reviewed-on: #1
Co-authored-by: andy <andy@sarand.com>
2026-10-16 18:24:16 +01:00

554 lines
24 KiB
C#
Raw Permalink Blame History

using Sarand.Net.Standard.Dbas.Data;
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 Saxonite.Base.App;
using Saxonite.Net.Standard.Dbas.Bus;
using Saxonite.Net.Standard.Dbas.Internal;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Text;
using Saxonite.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Utils;
using Saxonite.Net.Standard.Dbas.Internal.Core;
namespace Saxonite.Net.Standard.Dbas.Mgr
{
//=======================================================================
partial class SaxItemDataMgr_Dbas
{
//*******************************************************************
// Item Data Mgr - Item Sport
//*******************************************************************
// Utilities.
private List<StringPair> GetLogProperties(SaxItemProcess itemSport)
{
return new List<StringPair>()
{
new StringPair("Id",SysId.ToString(itemSport.Id)),
new StringPair("ItemId", (Sax.DataItemType)itemSport.ItemId.Type + ": " + itemSport.ItemId.Id),
new StringPair("Sport",SysId.ToString(itemSport.SportId)),
new StringPair("Status",itemSport.StatusCode)
};
}
//-------------------------------------------------------------------
// Create item.
public override SaxItemProcess CreateItemSport()
{
ClearErrorState();
return new SaxItemSport_Dbas(CoreDatabase, null, null, null, 0);
}
private SaxItemSport_Dbas CreateItemSport(ItemSport_Db dbItemSport)
{
ClearErrorState();
ItemId itemId = new ItemId(dbItemSport._ItemType, new SysId(dbItemSport._ItemId));
SaxItemSport_Dbas itemSport = new SaxItemSport_Dbas(CoreDatabase, new SysId(dbItemSport._Id), itemId, new SysId(dbItemSport._SportId), (ushort)dbItemSport._Flags);
PopulateFrom(dbItemSport, itemSport);
return itemSport;
}
//-------------------------------------------------------------------
// Get item.
public override SaxItemProcess GetItemSport(SaxItemProcess.Params prm)
{
ClearErrorState();
return GetItemSport(GetItemSportQueryFilter(prm).Concat(" And ", "(", ")"));
}
private SaxItemProcess GetItemSport(String filter)
{
ClearErrorState();
long count = GetItemSportCount(filter);
if (count == 0) return null;
if (count != 1)
{
SetErrorState("Multiple items found");
return null;
}
SaxItemProcess itemSport = null;
// Query data.
using (var dbConnection = CoreDatabase.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
ItemSport_Db dbItemSport = new ItemSport_Db(CoreDbInfo);
dbItemSport.PopulateFrom(dbCommand, aliasItemSport, filter);
itemSport = CreateItemSport(dbItemSport);
}
catch (Exception exc)
{
SetErrorState("Database query exception");
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
}
}
return itemSport;
}
//-------------------------------------------------------------------
// Validate item.
public override bool IsValidItemSportData(SaxItemProcess.Data data, SaxItemProcess.ErrField errField)
{
ClearErrorState();
if (!base.IsValidItemSportData(data, errField)) return false;
return true;
}
//-------------------------------------------------------------------
// Insert item.
public override bool InsertItemSport(SaxItemProcess itemSport, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!IsValidItemSport(itemSport)) return false;
if (SysId.IsValid(itemSport.Id)) return SetErrorState(ErrorMessage.ValidItemId);
using (var dbConnection = CoreDatabase.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
ItemSport_Db dbItemSport = new ItemSport_Db(CoreDbInfo);
PopulateTo(dbItemSport, itemSport, dbUpdateInfo);
if (ItemSport_Db.FieldsNonId.Contains("Id"))
{
// Generate next Id.
dbItemSport._Id = CoreDatabase.GetNextIdFromTable("ItemSport");
}
dbItemSport.ExecuteInsertCommand(dbCommand);
itemSport.Id = new SysId(dbItemSport._Id);
itemSport.Changed = false;
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted.{GetLogProperties(itemSport).Concat(": ").Concat("", "\n\t")}");
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return !HasErrorState();
}
//-------------------------------------------------------------------
// Update item.
public override bool UpdateItemSport(SaxItemProcess itemSport, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!IsValidItemSport(itemSport)) return false;
if (!SysId.IsValid(itemSport.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
if (!itemSport.Changed)
{
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed.{GetLogProperties(itemSport).Concat(": ").Concat("", "\n\t")}");
return true;
}
using (var dbConnection = CoreDatabase.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
// Retrieve item.
dbConnection.Open();
ItemSport_Db dbItemSport = new ItemSport_Db(CoreDbInfo);
dbItemSport.PopulateFrom(dbCommand, aliasItemSport, "Id=" + SysId.ToString(itemSport.Id));
// ToDo SaxUpdateLogItemMonitor_ItemSport updateLogMonitor = new SaxUpdateLogItemMonitor_ItemSport(SessionContext, CreateItemSport(dbItemSport), dbUpdateInfo);
// Update item.
PopulateTo(dbItemSport, itemSport, dbUpdateInfo);
dbItemSport.ExecuteUpdateCommand(dbCommand);
itemSport.Changed = false;
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Updated.{GetLogProperties(itemSport).Concat(": ").Concat("", "\n\t")}");
// Record updates.
// ToDo updateLogMonitor.RecordUpdatedValues(itemSport);
// ToDo updateLogMonitor.LogUpdates();
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return !HasErrorState();
}
//-------------------------------------------------------------------
// Delete item.
public override bool ItemSportCanBeDeleted(SaxItemProcess itemSport)
{
ClearErrorState();
if (!base.ItemSportCanBeDeleted(itemSport)) return false;
return true;
}
public override bool DeleteItemSport(SaxItemProcess itemSport, DbUpdateInfo dbUpdateInfo)
{
ClearErrorState();
if (!ItemSportCanBeDeleted(itemSport)) return false;
// Item Sports are logically deleted by changing the status.
itemSport.Status = SaStatus.Deleted;
return UpdateItemSport(itemSport, dbUpdateInfo);
/*
* Physical deletion.
using (var dbConnection = CoreDatabase.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
// Retrieve item.
dbConnection.Open();
ItemSport_Db dbItemSport = new ItemSport_Db(CoreDbInfo);
dbItemSport.PopulateFrom(dbCommand, aliasItemSport, "Id=" + itemSport.Id.ToString());
// Delete item.
dbCommand.CommandType = System.Data.CommandType.Text;
dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport) + " WHERE Id=" + SysId.ToString(itemSport.Id) + ";";
dbCommand.ExecuteNonQuery();
itemSport.Changed = false;
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. " + GetLogProperties(itemSport).Concat(": ").Concat("", "\n\t"));
}
catch (Exception exc) { SetErrorState(exc.Message); }
}
return !HasErrorState();
*/
}
//-------------------------------------------------------------------
// Copy data properties to and from database.
private void PopulateTo(ItemSport_Db dbItemSport, SaxItemProcess itemSport, DbUpdateInfo dbUpdateInfo)
{
dbItemSport._Id = SysId.ToInt(itemSport.Id);
dbItemSport._ItemType = itemSport.ItemId.Type;
dbItemSport._ItemId = SysId.ToInt(itemSport.ItemId.Id);
dbItemSport._SportId = SysId.ToInt(itemSport.SportId);
dbItemSport._ItemSportData = itemSport.ItemSportData;
// Common.
dbItemSport._Notes = itemSport.Notes;
dbItemSport._Status = SacsSystem.GetStatusCode(itemSport.Status);
dbItemSport._Flags = (short)itemSport.Flags;
if (!SysId.IsValid(itemSport.Id))
{
dbItemSport._CreateOn = DateTime.Now;
dbItemSport._CreateBy = dbUpdateInfo.UserId.ToInt();
dbItemSport._CreateHost = dbUpdateInfo.Host;
}
dbItemSport._UpdateOn = DateTime.Now;
dbItemSport._UpdateBy = dbUpdateInfo.UserId.ToInt();
dbItemSport._UpdateHost = dbUpdateInfo.Host;
}
private void PopulateFrom(ItemSport_Db dbItemSport, SaxItemProcess itemSport)
{
//itemSport.Id = new SysId(dbItemSport._Id);
//itemSport.ItemId = new ItemId(dbItemSport._ItemType, new SysId(dbItemSport._ItemId);
//itemSport.SportId = new SysId(dbItemSport._SportId);
itemSport.ItemSportData = dbItemSport._ItemSportData;
// Common.
itemSport.Notes = dbItemSport._Notes;
itemSport.Status = SacsSystem.GetStatusForCode(dbItemSport._Status);
itemSport.SetCreateStamp(dbItemSport._CreateOn, new SysId(dbItemSport._CreateBy), dbItemSport._CreateHost);
itemSport.SetUpdateStamp(dbItemSport._UpdateOn, new SysId(dbItemSport._UpdateBy), dbItemSport._UpdateHost);
itemSport.AcceptChanges();
}
//-------------------------------------------------------------------
// Item column definitions.
private static readonly String aliasItemSport = "ItmSpt";
private static readonly String aliasItemSport_Sport = "ItmSpt_Spt";
private static readonly String prefixItemSport_Sport = "ItmSpt_Spt_";
private void SetItemSportColDfn
(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
String alias = "", String prefix = "")
{
if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.ItemSport)
alias = aliasItemSport;
col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
}
public override ColumnDfn GetItemSportColumnDfn(SaxItemProcess.Column columnId, string caption = "", int width = 0)
{
ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
switch (columnId)
{
//-----------------------------------------------------------
case SaxItemProcess.Column.Pos:
SetItemSportColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
columnDfn.ReadOnly = true;
columnDfn.Resizable = false;
break;
case SaxItemProcess.Column.Id:
SetItemSportColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_Id, ColumnAlignment.Right, DataValue.DataType.Long);
columnDfn.ReadOnly = true;
break;
case SaxItemProcess.Column.ItemType:
SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center, DataValue.DataType.Long);
columnDfn.ReadOnly = true;
break;
case SaxItemProcess.Column.ItemType_Code:
SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center);
columnDfn.ReadOnly = true;
break;
case SaxItemProcess.Column.ItemType_Desc:
SetItemSportColDfn(columnDfn, "Item type", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, ColumnAlignment.Center);
columnDfn.ReadOnly = true;
break;
case SaxItemProcess.Column.ItemId:
SetItemSportColDfn(columnDfn, "Item Id", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_ItemId, ColumnAlignment.Right, DataValue.DataType.Long);
columnDfn.ReadOnly = true;
break;
case SaxItemProcess.Column.SportId:
SetItemSportColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, ColumnAlignment.Right, DataValue.DataType.Long);
columnDfn.ReadOnly = true;
break;
//-----------------------------------------------------------
// Sport properties.
case SaxItemProcess.Column.Sport_Name:
SetItemSportColDfn(columnDfn, "Sport", 120, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasItemSport_Sport, prefixItemSport_Sport);
columnDfn.ReadOnly = true;
break;
//-----------------------------------------------------------
// Derived properties.
//-----------------------------------------------------------
// Common properties.
case SaxItemProcess.Column.Notes:
SetItemSportColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.ItemSport_Notes);
break;
case SaxItemProcess.Column.Flags:
SetItemSportColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.ItemSport_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
break;
case SaxItemProcess.Column.Status:
SetItemSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_Status, ColumnAlignment.Center);
break;
case SaxItemProcess.Column.Status_Desc:
SetItemSportColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.ItemSport_Status, ColumnAlignment.Center);
break;
case SaxItemProcess.Column.Status_Ind:
SetItemSportColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
break;
case SaxItemProcess.Column.CreateOn_Date:
SetItemSportColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
columnDfn.ReadOnly = true;
break;
case SaxItemProcess.Column.UpdateOn_Date:
SetItemSportColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.ItemSport_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;
}
//-------------------------------------------------------------------
// Item query filter.
public override List<string> GetItemSportQueryFilter(SaxItemProcess.Params prm)
{
List<String> filter = new List<String>();
// Item Ids.
String idsIncluded = prm.IdsIncluded.Concat(",");
if (!idsIncluded.IsEmpty())
filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport) + " IN (" + idsIncluded + ")");
String idsExcluded = prm.IdsExcluded.Concat(",");
if (!idsExcluded.IsEmpty())
filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport) + " NOT IN (" + idsExcluded + ")");
// Item Ids.
if (!prm.ItemIdsIncluded.IsEmpty())
{
List<String> itemIdFilters = new List<string>();
foreach (ItemId itemId in prm.ItemIdsIncluded)
{
if (!ItemId.IsValid(itemId)) continue;
String itemIdFilter =
SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, aliasItemSport) + "=" + itemId.Type +
" AND " + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemId, aliasItemSport) + "=" + SysId.ToInt(itemId.Id);
itemIdFilters.Add(itemIdFilter);
}
if (!itemIdFilters.IsEmpty())
filter.Add(itemIdFilters.Concat(" OR ", "(", ")"));
}
// Sport Ids.
String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
if (!sportIdsIncluded.IsEmpty())
filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, aliasItemSport) + " IN (" + sportIdsIncluded + ")");
// Notes.
if (!StringUtil.IsEmpty(prm.NotesPartial))
filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Notes, aliasItemSport) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");
// Status.
if (prm.StatusCat != SaxItemProcess.StatusCat.Any)
filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Status, aliasItemSport) + GetItemSportStatusCatFilterCondition(prm.StatusCat));
if (filter.Count < 1) filter.Add("1=1");
return filter;
}
internal static String GetItemSportStatusCatFilterCondition(SaxItemProcess.StatusCat statusCat)
{
if (statusCat == SaxItemProcess.StatusCat.ActiveOnly)
return "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'";
if (statusCat == SaxItemProcess.StatusCat.InactiveOnly)
return "='" + SacsSystem.GetStatusCode(SaStatus.Inactive) + "'";
if (statusCat == SaxItemProcess.StatusCat.NotDeleted)
return "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'";
if (statusCat == SaxItemProcess.StatusCat.DeletedOnly)
return "='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'";
return "";
}
// Item sort columns.
public List<String> GetItemSportSortColumns(SaxItemProcess.Params prm)
{
// Sort sequence:
List<String> sortColumnNames = new List<String>();
foreach (var columnDfn in prm.SortColumns)
{
// Need to ensure correct alias used for ItemSport columns in case of conflict.
String sortCol = String.Empty;
if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.ItemSport)
{
sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasItemSport);
}
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(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport) + " ASC");
}
return sortColumnNames;
}
//-------------------------------------------------------------------
// Item count.
private long GetItemSportCount(String filter)
{
ClearErrorState();
return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport) + " As " + aliasItemSport, filter);
}
public override long GetItemSportCount(SaxItemProcess.Params prm)
{
ClearErrorState();
return GetItemSportCount(GetItemSportQueryFilter(prm).Concat(" AND ", "(", ")"));
}
//-------------------------------------------------------------------
// Item list.
public override List<SaxItemProcess> GetItemSportList(SaxItemProcess.Params prm)
{
ClearErrorState();
List<SaxItemProcess> itemSports = new List<SaxItemProcess>();
DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport), aliasItemSport);
ItemSport_Db dbItemSport = new ItemSport_Db(CoreDbInfo);
qry.Columns.AddRange(dbItemSport.ExistingColumnNames);
qry.Filters.AddRange(GetItemSportQueryFilter(prm));
qry.OrderBy.AddRange(GetItemSportSortColumns(prm));
// Query data.
using (var dbConnection = CoreDatabase.CreateConnection())
using (var dbCommand = dbConnection.CreateCommand())
{
try
{
dbConnection.Open();
dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
{
while (dbDataReader.Read())
{
dbItemSport = new ItemSport_Db(CoreDbInfo);
dbItemSport.PopulateFrom(dbDataReader);
itemSports.Add(CreateItemSport(dbItemSport));
}
}
}
catch (Exception exc)
{
SetErrorState("Database query exception");
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
}
}
return itemSports;
}
//-------------------------------------------------------------------
// Item query execution.
public override DbResultSet ExecuteItemSportQuery(List<ColumnDfn> columns, SaxItemProcess.Params prm)
{
ClearErrorState();
//---------------------------------------------------------------------
// Construct query.
DbQuery query = new DbQuery(CoreDatabase.DbmsType);
query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemSport), aliasItemSport);
// Add columns as defined in query list.
if (columns.HasId(SaxItemProcess.Column.Id))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Id, aliasItemSport));
if (columns.HasId(SaxItemProcess.Column.ItemType) || columns.HasId(SaxItemProcess.Column.ItemType_Code) || columns.HasId(SaxItemProcess.Column.ItemType_Desc))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemType, aliasItemSport));
if (columns.HasId(SaxItemProcess.Column.ItemId))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_ItemId, aliasItemSport));
bool hasSportCols = (columns.HasId(SaxItemProcess.Column.Sport_Name));
if (columns.HasId(SaxItemProcess.Column.SportId) || hasSportCols)
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, aliasItemSport));
// Common properties.
if (columns.HasId(SaxItemProcess.Column.Notes))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Notes, aliasItemSport));
if (columns.HasId(SaxItemProcess.Column.Flags))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Flags, aliasItemSport));
if (columns.HasId(SaxItemProcess.Column.Status) || columns.HasId(SaxItemProcess.Column.Status_Desc) || columns.HasId(SaxItemProcess.Column.Status_Ind))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_Status, aliasItemSport));
if (columns.HasId(SaxItemProcess.Column.CreateOn_Date))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_CreateOn, aliasItemSport));
if (columns.HasId(SaxItemProcess.Column.UpdateOn_Date))
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_UpdateOn, aliasItemSport));
//---------------------------------------------------------------------
// Sport.
if (hasSportCols)
{
DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasItemSport_Sport);
joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasItemSport_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemSport_SportId, aliasItemSport));
query.Joins.Add(joinSport);
List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
foreach (var col in cols)
query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasItemSport_Sport), prefixItemSport_Sport + SaxDbDfn_Core.GetColumnName(col, false));
}
//---------------------------------------------------------------------
// Populate filter.
query.Filters.AddRange(GetItemSportQueryFilter(prm));
if (prm.IdsIncluded.Count != 1)
{
// Configure sort sequence.
foreach (String sortColumn in GetItemSportSortColumns(prm))
query.OrderBy.Add(sortColumn);
}
//---------------------------------------------------------------------
//return new DbResultSet_DataTableReader(db, query.BuildQuery(prm.ResultsPaging));
return DbResultSet_DataReader.ExecuteQuery(CoreDatabase, query.BuildQuery(prm.ResultsPaging));
}
//-------------------------------------------------------------------
}
//=======================================================================
}
Reference in New Issue View Git Blame Copy Permalink