1096 lines
53 KiB
C#
1096 lines
53 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.ItemDocs;
|
|
using Sarand.Net.Standard.Base.Utils;
|
|
using Sarand.Net.Standard.Dbas.Base;
|
|
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
|
|
{
|
|
//=======================================================================
|
|
// Commodity Manager - Portfolio Item.
|
|
//=======================================================================
|
|
partial class SbmCommodityMgr_Dbas
|
|
{
|
|
//-------------------------------------------------------------------
|
|
// Utilities.
|
|
private List<StringPair> GetLogProperties(SbmPortfolioItem portfolioItem)
|
|
{
|
|
return new List<StringPair>()
|
|
{
|
|
new StringPair("Id",SysId.ToString(portfolioItem.Id)),
|
|
new StringPair("Type",PortfolioItemTypes.GetDescForType(portfolioItem.Type, portfolioItem.Type.ToString())),
|
|
new StringPair("Code",portfolioItem.Code),
|
|
new StringPair("Status",portfolioItem.StatusCode)
|
|
};
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Associated data.
|
|
public override bool PortfolioItemHasChildItems(SysId portfolioItemId)
|
|
{
|
|
return GetChildPortfolioItemCount(portfolioItemId, Sbm.PortfolioItemType.Unknown) > 0;
|
|
}
|
|
public override long GetChildPortfolioItemCount(SysId portfolioItemIdParent, Sbm.PortfolioItemType portfolioItemType = Sbm.PortfolioItemType.Unknown)
|
|
{
|
|
ClearErrorState();
|
|
if (!SysId.IsValid(portfolioItemIdParent)) return 0;
|
|
String tablePortfolioItem = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem);
|
|
if (Database.TableExists(tablePortfolioItem))
|
|
{
|
|
List<String> filter = new List<String>();
|
|
filter.Add($"{SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent)}={SysId.ToLong(portfolioItemIdParent)}");
|
|
if (portfolioItemType > 0)
|
|
filter.Add($"{SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type)}={(int)portfolioItemType}");
|
|
return Database.GetRowCount(tablePortfolioItem, filter.Concat(" AND ", "(", ")"));
|
|
}
|
|
return 0;
|
|
}
|
|
public override bool IsPortfolioItemReferencedByOtherItems(SysId portfolioItemId)
|
|
{
|
|
ClearErrorState();
|
|
if (!SysId.IsValid(portfolioItemId)) return false;
|
|
String tablePortfolioItem = SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem);
|
|
if (Database.TableExists(tablePortfolioItem))
|
|
{
|
|
List<String> filter = new List<String>();
|
|
filter.Add($"{SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdRef)}={SysId.ToLong(portfolioItemId)}");
|
|
return Database.GetRowCount(tablePortfolioItem, filter.Concat(" AND ", "(", ")")) > 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Clear all descendent items.
|
|
public override bool ClearPortfolioItemChildItems(SysId portfolioItemId, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!SysId.IsValid(portfolioItemId)) return false;
|
|
SbmPortfolioItem.Params prmPortfolioItem = new SbmPortfolioItem.Params();
|
|
prmPortfolioItem.ParentItemId = portfolioItemId;
|
|
foreach (SbmPortfolioItem portfolioItem in CommodityMgr.GetPortfolioItemList(prmPortfolioItem))
|
|
{
|
|
ClearPortfolioItemChildItems(portfolioItem.Id, dbUpdateInfo);
|
|
if (!CommodityMgr.DeletePortfolioItem(portfolioItem, dbUpdateInfo))
|
|
return SetErrorState(CommodityMgr.ErrorStateMessage);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Dependent data should only be cleared when removing a portfolio item.
|
|
// Data owned by this item is deleted (eg. interface data items & document references).
|
|
// NB This method does not clear child portfolio items.
|
|
public override bool ClearPortfolioItemDependentData(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (portfolioItem == null || !SysId.IsValid(portfolioItem.Id)) return false;
|
|
if (!DataItemMgr.ClearDataItem(portfolioItem.GetItemId(), dbUpdateInfo))
|
|
return SetErrorState(DataItemMgr.ErrorStateMessage);
|
|
if (!ItemDocConsole.ClearItemDocs(portfolioItem.GetItemId(), SaItemDocConsole.Category.Unknown, dbUpdateInfo))
|
|
return SetErrorState(ItemDocConsole.ErrorStateMessage);
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Item types.
|
|
public override List<Sbm.PortfolioItemType> GetPortfolioItemTypesInUse()
|
|
{
|
|
List<Sbm.PortfolioItemType> types = new List<Sbm.PortfolioItemType>();
|
|
// Construct the query.
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(TableName_PortfolioItem);
|
|
qry.Columns.Add("DISTINCT " + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Type));
|
|
qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_AffIdOwner) + "=" + AffiliateId_Owner.ToString());
|
|
using (DbResultSet dbResultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.ToString()))
|
|
{
|
|
if (dbResultSet != null && dbResultSet.NextRecord())
|
|
{
|
|
NamedValue.Map values = dbResultSet.GetRecordValues();
|
|
types.Add((Sbm.PortfolioItemType)values.GetValue(SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type)).AsLong());
|
|
}
|
|
}
|
|
return types;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Sequence by parent.
|
|
public override ushort GetMinSeqForParent(SysId idParent, Sbm.PortfolioItemType eType)
|
|
{
|
|
ClearErrorState();
|
|
String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
|
|
String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
|
|
List<String> filters = new List<string>();
|
|
filters.Add(colType + "=" + ((int)eType).ToString());
|
|
filters.Add(colItemIdParent + "=" + idParent.ToString());
|
|
return (ushort)Database.GetRowValue(TableName_PortfolioItem, "Min(" + colSeq + ")", filters.Concat(" AND ", "(", ")")).AsLong();
|
|
}
|
|
public override ushort GetMaxSeqForParent(SysId idParent, Sbm.PortfolioItemType eType)
|
|
{
|
|
ClearErrorState();
|
|
String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
|
|
String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
|
|
List<String> filters = new List<string>();
|
|
filters.Add(colType + "=" + ((int)eType).ToString());
|
|
filters.Add(colItemIdParent + "=" + idParent.ToString());
|
|
return (ushort)Database.GetRowValue(TableName_PortfolioItem, "Max(" + colSeq + ")", filters.Concat(" AND ", "(", ")")).AsLong();
|
|
}
|
|
// Category item Ids for parent.
|
|
public override List<SysId> GetCategoryItemIds(SysId idParentItem)
|
|
{
|
|
List<SysId> itemIds = new List<SysId>();
|
|
String colId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
|
|
String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
|
|
String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
|
|
// Identify item above this one in the list.
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(TableName_PortfolioItem);
|
|
qry.Columns.Add(colId);
|
|
qry.Filters.Add(colType + "=" + ((int)Sbm.PortfolioItemType.Category).ToString());
|
|
qry.Filters.Add(colItemIdParent + "=" + idParentItem.ToString());
|
|
qry.OrderBy.Add(colSeq);
|
|
using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
|
|
{
|
|
while (resultSet != null && resultSet.NextRecord())
|
|
{
|
|
NamedValue.Map values = resultSet.GetRecordValues();
|
|
itemIds.Add(new SysId((int)values.GetLong(colId)));
|
|
}
|
|
}
|
|
return itemIds;
|
|
}
|
|
// Comodity
|
|
public override List<SysId> GetCommodityItemIds(SysId idParentItem, ref List<SysId> commodityIds, bool includeSubCategories)
|
|
{
|
|
List<SysId> itemIds = new List<SysId>();
|
|
String sColId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id, false);
|
|
String sColType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type, false);
|
|
String sColItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, false);
|
|
String sColSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq, false);
|
|
String sColCmdId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, false);
|
|
|
|
// Identify item above this one in the list:
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(TableName_PortfolioItem);
|
|
qry.Columns.Add(sColId);
|
|
qry.Columns.Add(sColType);
|
|
if (commodityIds != null) qry.Columns.Add(sColCmdId);
|
|
if (!includeSubCategories) qry.Filters.Add(sColType + "=" + ((int)Sbm.PortfolioItemType.Commodity).ToString());
|
|
qry.Filters.Add(sColItemIdParent + "=" + idParentItem.ToString());
|
|
qry.OrderBy.Add(sColSeq);
|
|
using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
|
|
{
|
|
while (resultSet != null && resultSet.NextRecord())
|
|
{
|
|
NamedValue.Map values = resultSet.GetRecordValues();
|
|
SysId itemId = new SysId((int)values.GetLong(sColId));
|
|
if (values.GetLong(sColType) == (int)Sbm.PortfolioItemType.Category)
|
|
{
|
|
// Category item - search sub categories.
|
|
if (includeSubCategories)
|
|
itemIds.AddRange(GetCommodityItemIds(itemId, ref commodityIds, includeSubCategories));
|
|
}
|
|
else
|
|
{
|
|
// Commodity item.
|
|
itemIds.Add(itemId);
|
|
if (commodityIds != null)
|
|
commodityIds.Add(new SysId((int)values.GetLong(sColCmdId)));
|
|
}
|
|
}
|
|
}
|
|
return itemIds;
|
|
}
|
|
//-------------------------------------------------------------------
|
|
public override bool ResequenceChildren(SysId parentItemId)
|
|
{
|
|
ClearErrorState();
|
|
|
|
// Two separate sequences for categories and commodities.
|
|
ushort iSeq_Category = 0;
|
|
ushort iSeq_Commodity = 0;
|
|
|
|
// Parameters to retrieve children.
|
|
SbmPortfolioItem.Params prmPortfolioItem = new SbmPortfolioItem.Params();
|
|
prmPortfolioItem.ParentItemId = parentItemId;
|
|
foreach (SbmPortfolioItem portfolioItem in GetPortfolioItemList(prmPortfolioItem))
|
|
{
|
|
if (portfolioItem.Type == Sbm.PortfolioItemType.Commodity)
|
|
portfolioItem.Sequence = ++iSeq_Commodity;
|
|
else
|
|
portfolioItem.Sequence = ++iSeq_Category;
|
|
if (!UpdatePortfolioItem(portfolioItem, DbUpdateInfo))
|
|
SetErrorState(ErrorStateMessage);
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
private bool ResequenceSubsequentItems(SbmPortfolioItem portfolioItem)
|
|
{
|
|
if (!SysId.IsValid(portfolioItem.Id)) return true;
|
|
|
|
// Item properties.
|
|
Sbm.PortfolioItemType eType = portfolioItem.Type;
|
|
SysId idItemParent = portfolioItem.ItemIdParent;
|
|
SysId idItemLeave = portfolioItem.Id;
|
|
ushort itemSequence = portfolioItem.Sequence;
|
|
|
|
// Common database items.
|
|
String colId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
|
|
String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
|
|
String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
|
|
|
|
// Find out how many items exist with this sequence.
|
|
long itemsWithSameSequence = 0;
|
|
List<String> filters = new List<string>();
|
|
filters.Add(colId + "!=" + SysId.ToInt(idItemLeave));
|
|
filters.Add(colType + "=" + ((int)eType).ToString());
|
|
filters.Add(colItemIdParent + "=" + SysId.ToInt(idItemParent));
|
|
filters.Add(colSeq + "=" + itemSequence.ToString());
|
|
itemsWithSameSequence = Database.GetRowCount(TableName_PortfolioItem, filters.Concat(" AND ", "(", ")"));
|
|
// Don't need to resequence if there are no other items with this sequence:
|
|
if (itemsWithSameSequence < 1) return true;
|
|
|
|
// Identify the next sequence value other than this item.
|
|
ushort nextSequence = 0;
|
|
filters = new List<string>();
|
|
filters.Add(colId + "<>" + SysId.ToInt(idItemLeave));
|
|
filters.Add(colType + "=" + ((int)eType).ToString());
|
|
filters.Add(colItemIdParent + "=" + SysId.ToInt(idItemParent));
|
|
filters.Add(colSeq + ">=" + itemSequence.ToString());
|
|
nextSequence = (ushort)Database.GetRowValue(TableName_PortfolioItem, "Min(" + colSeq + ")", filters.Concat(" AND ", "(", ")")).AsLong();
|
|
|
|
// Check whether resequence is required:
|
|
if ((itemsWithSameSequence == 0 && nextSequence > itemSequence) || (itemsWithSameSequence > 1 && nextSequence == itemSequence))
|
|
{
|
|
// Update subsequent items' sequences to make room for the specified item.
|
|
List<StringPair> columnValues = new List<StringPair>();
|
|
if (itemsWithSameSequence == 0)
|
|
{
|
|
// No items with same sequence - item must have been deleted
|
|
// so decrement the sequence for all subsequent items.
|
|
SacsDatabase.AddValuePair(columnValues, colSeq, colSeq + "-" + (nextSequence - itemSequence).ToString(), false);
|
|
}
|
|
else
|
|
{
|
|
// Item must have been inserted into sequence so increment
|
|
// all other items with sequence or higher:
|
|
SacsDatabase.AddValuePair(columnValues, colSeq, colSeq + "+1", false);
|
|
}
|
|
Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
|
|
if (Database.HasErrorState())
|
|
return SetErrorState(Database.ErrorStateMessage);
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Create Item.
|
|
public override SbmPortfolioItem CreatePortfolioItem(Sbm.PortfolioItemType portfolioItemType)
|
|
{
|
|
return new SbmPortfolioItem_Dbas(new SysId(), AffiliateId_Owner, portfolioItemType, 0);
|
|
}
|
|
private SbmPortfolioItem_Dbas CreatePortfolioItem(PortfolioItem_Db dbPortfolioItem)
|
|
{
|
|
ClearErrorState();
|
|
SbmPortfolioItem_Dbas portfolioItem = new SbmPortfolioItem_Dbas(new SysId(dbPortfolioItem._Id), new SysId(dbPortfolioItem._AffIdOwner), (Sbm.PortfolioItemType)dbPortfolioItem._Type, (ushort)dbPortfolioItem._Flags);
|
|
PopulateFrom(dbPortfolioItem, portfolioItem);
|
|
return portfolioItem;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Get Item.
|
|
public override SbmPortfolioItem GetPortfolioItem(SbmPortfolioItem.Params prm)
|
|
{
|
|
return GetPortfolioItem(GetPortfolioItemQueryFilter(prm).Concat(" AND ", "(", ")"));
|
|
}
|
|
private SbmPortfolioItem GetPortfolioItem(String filter)
|
|
{
|
|
ClearErrorState();
|
|
long count = GetPortfolioItemCount(filter);
|
|
if (count == 0) return null;
|
|
if (count != 1)
|
|
{
|
|
SetErrorState(Msg_MultipleItemsFound);
|
|
return null;
|
|
}
|
|
SbmPortfolioItem portfolioItem = null;
|
|
// Query data.
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
|
|
dbPortfolioItem.PopulateFrom(dbCommand, aliasPortfolioItem, filter);
|
|
portfolioItem = CreatePortfolioItem(dbPortfolioItem);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
SetErrorState(Msg_DatabaseQueryException);
|
|
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
|
|
}
|
|
}
|
|
return portfolioItem;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Validate Item.
|
|
public override bool IsValidPortfolioItemData(SbmPortfolioItem.Data data, SbmPortfolioItem.ErrField errField)
|
|
{
|
|
ClearErrorState();
|
|
if (!base.IsValidPortfolioItemData(data, errField)) return false;
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Insert PortfolioItem.
|
|
public override bool InsertPortfolioItem(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!IsValidPortfolioItem(portfolioItem)) return false;
|
|
if (SysId.IsValid(portfolioItem.Id)) return SetErrorState(ErrorMessage.ValiditemId);
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
dbConnection.Open();
|
|
PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
|
|
PopulateTo(dbPortfolioItem, portfolioItem, dbUpdateInfo);
|
|
if (PortfolioItem_Db.FieldsNonId.Contains("Id"))
|
|
{
|
|
// Generate next Id.
|
|
dbPortfolioItem._Id = SysId.ToInt(Database.GetNextId("PortfolioItem", dbUpdateInfo));
|
|
}
|
|
dbPortfolioItem.ExecuteInsertCommand(dbCommand);
|
|
portfolioItem.Id = new SysId(dbPortfolioItem._Id);
|
|
portfolioItem.Changed = false;
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Inserted. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));
|
|
|
|
// Move other items for same parent down sequence.
|
|
ResequenceSubsequentItems(portfolioItem);
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Update PortfolioItem.
|
|
public override bool UpdatePortfolioItem(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!IsValidPortfolioItem(portfolioItem)) return false;
|
|
if (!SysId.IsValid(portfolioItem.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
|
|
if (!portfolioItem.Changed)
|
|
{
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Data not changed. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));
|
|
return true;
|
|
}
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
// Retrieve PortfolioItem.
|
|
dbConnection.Open();
|
|
PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
|
|
dbPortfolioItem.PopulateFrom(dbCommand, aliasPortfolioItem, "Id=" + SysId.ToString(portfolioItem.Id));
|
|
SbmUpdateLogItemMonitor_PortfolioItem updateLogMonitor = new SbmUpdateLogItemMonitor_PortfolioItem(Internals, CreatePortfolioItem(dbPortfolioItem));
|
|
|
|
// Update properties.
|
|
PopulateTo(dbPortfolioItem, portfolioItem, dbUpdateInfo);
|
|
dbPortfolioItem.ExecuteUpdateCommand(dbCommand);
|
|
portfolioItem.Changed = false;
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Updated. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));
|
|
|
|
// Record updates.
|
|
updateLogMonitor.RecordUpdatedValues(portfolioItem);
|
|
updateLogMonitor.LogUpdates();
|
|
|
|
// Move other items for same parent down sequence.
|
|
ResequenceSubsequentItems(portfolioItem);
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Verify moving item.
|
|
public override bool CanMoveItemUp(SbmPortfolioItem portfolioItem)
|
|
{
|
|
ClearErrorState();
|
|
ushort minSequence = GetMinSeqForParent(portfolioItem.ItemIdParent, portfolioItem.Type);
|
|
return !HasErrorState() && minSequence < portfolioItem.Sequence;
|
|
}
|
|
public override bool CanMoveItemDown(SbmPortfolioItem portfolioItem)
|
|
{
|
|
ClearErrorState();
|
|
ushort maxSequence = GetMaxSeqForParent(portfolioItem.ItemIdParent, portfolioItem.Type);
|
|
return !HasErrorState() && maxSequence > portfolioItem.Sequence;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Move item.
|
|
public override bool MoveItemUp(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
String colId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
|
|
String colType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
String colItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
|
|
String colSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
|
|
|
|
// Identify item above this one in the list.
|
|
SysId itemIdPrev = new SysId();
|
|
ushort sequencePrev = 0;
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(TableName_PortfolioItem);
|
|
qry.Columns.Add(colId);
|
|
qry.Columns.Add(colSeq);
|
|
qry.Filters.Add(colType + "=" + ((int)portfolioItem.Type).ToString());
|
|
qry.Filters.Add(colItemIdParent + "=" + SysId.ToInt(portfolioItem.ItemIdParent));
|
|
qry.Filters.Add(colSeq + "<" + portfolioItem.Sequence);
|
|
qry.OrderBy.Add(colSeq + " DESC");
|
|
qry.RowLimit = 2;
|
|
using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
|
|
{
|
|
// Only need to read first record.
|
|
if (resultSet != null && resultSet.NextRecord())
|
|
{
|
|
NamedValue.Map values = resultSet.GetRecordValues();
|
|
itemIdPrev = new SysId((int)values.GetLong(colId));
|
|
sequencePrev = (ushort)values.GetLong(colSeq);
|
|
}
|
|
}
|
|
|
|
// Verify the previous item.
|
|
if (SysId.IsValid(itemIdPrev) && sequencePrev > 0 && sequencePrev < portfolioItem.Sequence)
|
|
{
|
|
// Update previous item to replace the selected item's position in sequence.
|
|
List<StringPair> columnValues = new List<StringPair>();
|
|
SacsDatabase.AddValuePair(columnValues, colSeq, portfolioItem.Sequence.ToString(), false);
|
|
List<String> filters = new List<string>();
|
|
filters.Add(colId + "=" + SysId.ToInt(itemIdPrev));
|
|
if (Database.HasErrorState())
|
|
return SetErrorState(Database.ErrorStateMessage);
|
|
Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
|
|
if (Database.HasErrorState())
|
|
return SetErrorState(Database.ErrorStateMessage);
|
|
|
|
// Update the selected item with its new position in sequence.
|
|
columnValues = new List<StringPair>();
|
|
SacsDatabase.AddValuePair(columnValues, colSeq, sequencePrev.ToString(), false);
|
|
filters = new List<string>();
|
|
filters.Add(colId + "=" + SysId.ToInt(portfolioItem.Id));
|
|
Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
|
|
if (Database.HasErrorState())
|
|
return SetErrorState(Database.ErrorStateMessage);
|
|
// Update the item's sequence.
|
|
portfolioItem.Sequence = sequencePrev;
|
|
}
|
|
return OK;
|
|
}
|
|
public override bool MoveItemDown(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
String sColId = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Id);
|
|
String sColType = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
String sColItemIdParent = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent);
|
|
String sColSeq = SbmDbDfn.GetColumnName(SbmDbDfn.ColumnIdx.PortfolioItem_Seq);
|
|
|
|
// Identify item above this one in the list.
|
|
SysId itemIdNext = new SysId();
|
|
ushort sequenceNext = 0;
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(TableName_PortfolioItem);
|
|
qry.Columns.Add(sColId);
|
|
qry.Columns.Add(sColSeq);
|
|
qry.Filters.Add(sColType + "=" + ((int)portfolioItem.Type).ToString());
|
|
qry.Filters.Add(sColItemIdParent + "=" + SysId.ToInt(portfolioItem.ItemIdParent));
|
|
qry.Filters.Add(sColSeq + ">" + portfolioItem.Sequence);
|
|
qry.OrderBy.Add(sColSeq + " ASC");
|
|
qry.RowLimit = 2;
|
|
using (DbResultSet resultSet = DbResultSet_DataReader.ExecuteQuery(Database, qry.BuildQuery()))
|
|
{
|
|
// Only need to read first record.
|
|
if (resultSet != null && resultSet.NextRecord())
|
|
{
|
|
NamedValue.Map values = resultSet.GetRecordValues();
|
|
itemIdNext = new SysId((int)values.GetLong(sColId));
|
|
sequenceNext = (ushort)values.GetLong(sColSeq);
|
|
}
|
|
}
|
|
|
|
// Verify the next item.
|
|
if (SysId.IsValid(itemIdNext) && sequenceNext > 0 && sequenceNext > portfolioItem.Sequence)
|
|
{
|
|
// Update next item to replace the selected item's position in sequence:
|
|
List<StringPair> columnValues = new List<StringPair>();
|
|
SacsDatabase.AddValuePair(columnValues, sColSeq, portfolioItem.Sequence.ToString(), false);
|
|
List<String> filters = new List<string>();
|
|
filters.Add(sColId + "=" + SysId.ToInt(itemIdNext));
|
|
Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
|
|
if (Database.HasErrorState())
|
|
return SetErrorState(Database.ErrorStateMessage);
|
|
|
|
// Update the selected item with its new position in sequence:
|
|
columnValues = new List<StringPair>();
|
|
SacsDatabase.AddValuePair(columnValues, sColSeq, sequenceNext.ToString(), false);
|
|
filters = new List<string>();
|
|
filters.Add(sColId + "=" + SysId.ToInt(portfolioItem.Id));
|
|
Database.ExecuteUpdate(TableName_PortfolioItem, columnValues, filters.Concat(" AND ", "(", ")"));
|
|
if (Database.HasErrorState())
|
|
return SetErrorState(Database.ErrorStateMessage);
|
|
// Update the item's sequence.
|
|
portfolioItem.Sequence = sequenceNext;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Delete Item.
|
|
public override bool PortfolioItemCanBeDeleted(SbmPortfolioItem portfolioItem)
|
|
{
|
|
ClearErrorState();
|
|
if (!base.PortfolioItemCanBeDeleted(portfolioItem)) return false;
|
|
return true;
|
|
}
|
|
public override bool DeletePortfolioItem(SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
ClearErrorState();
|
|
if (!PortfolioItemCanBeDeleted(portfolioItem)) return false;
|
|
using (var dbConnection = Database.CreateConnection())
|
|
using (var dbCommand = dbConnection.CreateCommand())
|
|
{
|
|
try
|
|
{
|
|
// Retrieve PortfolioItem.
|
|
dbConnection.Open();
|
|
PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
|
|
dbPortfolioItem.PopulateFrom(dbCommand, aliasPortfolioItem, "Id=" + portfolioItem.Id.ToString());
|
|
// Delete PortfolioItem.
|
|
dbCommand.CommandType = System.Data.CommandType.Text;
|
|
dbCommand.CommandText = "DELETE FROM " + SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem) + " WHERE Id=" + SysId.ToString(portfolioItem.Id) + ";";
|
|
dbCommand.ExecuteNonQuery();
|
|
portfolioItem.Changed = false;
|
|
if (DebugMode) SaLogger.Debug($"{SysUtil.Fn} Deleted. " + GetLogProperties(portfolioItem).Concat(": ").Concat("", "\n\t"));
|
|
|
|
// Move other items for same parent down sequence.
|
|
ResequenceSubsequentItems(portfolioItem);
|
|
}
|
|
catch (Exception exc) { SetErrorState(exc.Message); }
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Copy data properties to and from database.
|
|
private void PopulateTo(PortfolioItem_Db dbPortfolioItem, SbmPortfolioItem portfolioItem, DbUpdateInfo dbUpdateInfo)
|
|
{
|
|
dbPortfolioItem._Id = portfolioItem.Id.ToInt();
|
|
dbPortfolioItem._AffIdOwner = SysId.ToInt(portfolioItem.AffiliateIdOwner);
|
|
dbPortfolioItem._ItemIdParent = SysId.ToInt(portfolioItem.ItemIdParent);
|
|
dbPortfolioItem._Seq = (short)portfolioItem.Sequence;
|
|
dbPortfolioItem._Type = (short)portfolioItem.Type;
|
|
dbPortfolioItem._ItemIdRef = SysId.ToInt(portfolioItem.ItemIdRef);
|
|
dbPortfolioItem._Code = portfolioItem.Code;
|
|
dbPortfolioItem._ShortCut = portfolioItem.ShortCut;
|
|
dbPortfolioItem._Caption = portfolioItem.Caption;
|
|
dbPortfolioItem._DescBrief = portfolioItem.DescBrief;
|
|
dbPortfolioItem._DescDetail = portfolioItem.DescDetail;
|
|
dbPortfolioItem._CommodityId = SysId.ToInt(portfolioItem.CommodityId);
|
|
// Common properties.
|
|
dbPortfolioItem._Notes = portfolioItem.Notes;
|
|
dbPortfolioItem._Flags = (short)portfolioItem.Flags;
|
|
dbPortfolioItem._Status = SacsSystem.GetStatusCode(portfolioItem.Status);
|
|
if (!SysId.IsValid(portfolioItem.Id))
|
|
{
|
|
dbPortfolioItem._CreateOn = DateTime.UtcNow;
|
|
dbPortfolioItem._CreateBy = dbUpdateInfo.UserId.ToInt();
|
|
dbPortfolioItem._CreateHost = dbUpdateInfo.Host;
|
|
}
|
|
dbPortfolioItem._UpdateOn = DateTime.UtcNow;
|
|
dbPortfolioItem._UpdateBy = dbUpdateInfo.UserId.ToInt();
|
|
dbPortfolioItem._UpdateHost = dbUpdateInfo.Host;
|
|
}
|
|
private void PopulateFrom(PortfolioItem_Db dbPortfolioItem, SbmPortfolioItem portfolioItem)
|
|
{
|
|
portfolioItem.Id = new SysId(dbPortfolioItem._Id);
|
|
//portfolioItem.AffiliateIdOwner = new SysId(dbPortfolioItem._AffIdOwner);
|
|
portfolioItem.ItemIdParent = new SysId(dbPortfolioItem._ItemIdParent);
|
|
portfolioItem.Sequence = (ushort)dbPortfolioItem._Seq;
|
|
//portfolioItem.Type = (Sbm.PortfolioItemType)dbPortfolioItem._Type;
|
|
portfolioItem.ItemIdRef = new SysId(dbPortfolioItem._ItemIdRef);
|
|
portfolioItem.Code = dbPortfolioItem._Code;
|
|
portfolioItem.Caption = dbPortfolioItem._Caption;
|
|
portfolioItem.DescBrief = dbPortfolioItem._DescBrief;
|
|
portfolioItem.DescDetail = dbPortfolioItem._DescDetail;
|
|
portfolioItem.CommodityId = new SysId(dbPortfolioItem._CommodityId ?? 0);
|
|
// Common properties.
|
|
portfolioItem.Notes = dbPortfolioItem._Notes;
|
|
portfolioItem.Status = SacsSystem.GetStatusForCode(dbPortfolioItem._Status);
|
|
portfolioItem.SetCreateStamp(dbPortfolioItem._CreateOn ?? default(DateTime), new SysId(dbPortfolioItem._CreateBy ?? 0), dbPortfolioItem._CreateHost);
|
|
portfolioItem.SetUpdateStamp(dbPortfolioItem._UpdateOn ?? default(DateTime), new SysId(dbPortfolioItem._UpdateBy ?? 0), dbPortfolioItem._UpdateHost);
|
|
portfolioItem.AcceptChanges();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Column definitions.
|
|
private static readonly String aliasPortfolioItem = "aPrtItm";
|
|
private static readonly String aliasPortfolioItem_Parent = "PrtItm_Prt";
|
|
private static readonly String prefixPortfolioItem_Parent = aliasPortfolioItem_Parent + "_";
|
|
private static readonly String aliasPortfolioItem_Commodity = "PrtItm_Cmd";
|
|
private static readonly String prefixPortfolioItem_Commodity = aliasPortfolioItem_Commodity + "_";
|
|
|
|
// Column definition population.
|
|
private void SetPortfolioItemColDfn
|
|
(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.PortfolioItem)
|
|
alias = aliasPortfolioItem;
|
|
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 PortfolioItem column definition.
|
|
public override ColumnDfn GetPortfolioItemColumnDfn(SbmPortfolioItem.Column columnId, string caption = "", int width = 0)
|
|
{
|
|
ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
|
|
switch (columnId)
|
|
{
|
|
case SbmPortfolioItem.Column.Pos:
|
|
SetPortfolioItemColDfn(columnDfn, "Pos", 45, SbmDbDfn.ColumnIdx.Unknown, ColumnAlignment.Right);
|
|
columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
|
|
columnDfn.ReadOnly = true;
|
|
columnDfn.Resizable = false;
|
|
break;
|
|
case SbmPortfolioItem.Column.Id:
|
|
SetPortfolioItemColDfn(columnDfn, "Id", 60, SbmDbDfn.ColumnIdx.PortfolioItem_Id, ColumnAlignment.Right, DataValue.DataType.Long);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
// Parent.
|
|
case SbmPortfolioItem.Column.ItemIdParent:
|
|
SetPortfolioItemColDfn(columnDfn, "Parent #", 80, SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, ColumnAlignment.Right, DataValue.DataType.Long);
|
|
break;
|
|
case SbmPortfolioItem.Column.Parent_Code:
|
|
SetPortfolioItemColDfn(columnDfn, "Parent code", 100, SbmDbDfn.ColumnIdx.PortfolioItem_Code, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Parent, prefixPortfolioItem_Parent);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmPortfolioItem.Column.Parent_Caption:
|
|
SetPortfolioItemColDfn(columnDfn, "Parent", 120, SbmDbDfn.ColumnIdx.PortfolioItem_Caption, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Parent, prefixPortfolioItem_Parent);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
// Commodity.
|
|
case SbmPortfolioItem.Column.CommodityId:
|
|
SetPortfolioItemColDfn(columnDfn, "Commodity #", 80, SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, ColumnAlignment.Right, DataValue.DataType.Long);
|
|
break;
|
|
case SbmPortfolioItem.Column.Commodity_Code:
|
|
SetPortfolioItemColDfn(columnDfn, "Commodity code", 100, SbmDbDfn.ColumnIdx.Commodity_Code, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmPortfolioItem.Column.Commodity_DescBrief:
|
|
SetPortfolioItemColDfn(columnDfn, "Commodity", 120, SbmDbDfn.ColumnIdx.Commodity_DescBrief, ColumnAlignment.Left, DataValue.DataType.String, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmPortfolioItem.Column.Commodity_SalesPrice:
|
|
SetPortfolioItemColDfn(columnDfn, "Commodity price", 100, SbmDbDfn.ColumnIdx.Commodity_SalesPrice, ColumnAlignment.Right, DataValue.DataType.Decimal, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmPortfolioItem.Column.Commodity_SalesPrice_Fmt:
|
|
SetPortfolioItemColDfn(columnDfn, "Commodity price", 100, SbmDbDfn.ColumnIdx.Commodity_SalesPrice, ColumnAlignment.Right, DataValue.DataType.String, aliasPortfolioItem_Commodity, prefixPortfolioItem_Commodity);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
// Portfolio Item Properties.
|
|
case SbmPortfolioItem.Column.ItemIdRef:
|
|
SetPortfolioItemColDfn(columnDfn, "Ref #", 80, SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdRef, ColumnAlignment.Right, DataValue.DataType.Long);
|
|
break;
|
|
case SbmPortfolioItem.Column.Type:
|
|
SetPortfolioItemColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Type, ColumnAlignment.Center, DataValue.DataType.Long);
|
|
break;
|
|
case SbmPortfolioItem.Column.Type_Desc:
|
|
SetPortfolioItemColDfn(columnDfn, "Type", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Type);
|
|
break;
|
|
case SbmPortfolioItem.Column.Sequence:
|
|
SetPortfolioItemColDfn(columnDfn, "Seq", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Seq, ColumnAlignment.Center, DataValue.DataType.Long);
|
|
break;
|
|
case SbmPortfolioItem.Column.Code:
|
|
SetPortfolioItemColDfn(columnDfn, "Code", 80, SbmDbDfn.ColumnIdx.PortfolioItem_Code);
|
|
break;
|
|
case SbmPortfolioItem.Column.Caption:
|
|
SetPortfolioItemColDfn(columnDfn, "Caption", 120, SbmDbDfn.ColumnIdx.PortfolioItem_Caption);
|
|
break;
|
|
case SbmPortfolioItem.Column.DescBrief:
|
|
SetPortfolioItemColDfn(columnDfn, "DescBrief", 160, SbmDbDfn.ColumnIdx.PortfolioItem_DescBrief);
|
|
break;
|
|
case SbmPortfolioItem.Column.DescDetail:
|
|
SetPortfolioItemColDfn(columnDfn, "DescDetail", 240, SbmDbDfn.ColumnIdx.PortfolioItem_DescDetail);
|
|
break;
|
|
case SbmPortfolioItem.Column.ShortCut:
|
|
SetPortfolioItemColDfn(columnDfn, "Shortcut", 80, SbmDbDfn.ColumnIdx.PortfolioItem_ShortCut);
|
|
break;
|
|
case SbmPortfolioItem.Column.Publish_Y:
|
|
SetPortfolioItemColDfn(columnDfn, "Publish", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Flags, ColumnAlignment.Center);
|
|
break;
|
|
case SbmPortfolioItem.Column.Publish_Tick:
|
|
SetPortfolioItemColDfn(columnDfn, "Publish", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Flags, ColumnAlignment.Center, DataValue.DataType.Bool);
|
|
columnDfn.BoolFormat = ColumnBoolFormat.Tick;
|
|
break;
|
|
// Common properties.
|
|
case SbmPortfolioItem.Column.Notes:
|
|
SetPortfolioItemColDfn(columnDfn, "Notes", 200, SbmDbDfn.ColumnIdx.PortfolioItem_Notes);
|
|
break;
|
|
case SbmPortfolioItem.Column.Status:
|
|
SetPortfolioItemColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Status, ColumnAlignment.Center);
|
|
break;
|
|
case SbmPortfolioItem.Column.Status_Desc:
|
|
SetPortfolioItemColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Status, ColumnAlignment.Center);
|
|
break;
|
|
case SbmPortfolioItem.Column.Status_Ind:
|
|
SetPortfolioItemColDfn(columnDfn, "Status", 70, SbmDbDfn.ColumnIdx.PortfolioItem_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
|
|
columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
|
|
break;
|
|
case SbmPortfolioItem.Column.CreateOn_Date:
|
|
SetPortfolioItemColDfn(columnDfn, "Created", 80, SbmDbDfn.ColumnIdx.PortfolioItem_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
|
|
columnDfn.ReadOnly = true;
|
|
break;
|
|
case SbmPortfolioItem.Column.UpdateOn_Date:
|
|
SetPortfolioItemColDfn(columnDfn, "Updated", 80, SbmDbDfn.ColumnIdx.PortfolioItem_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> GetPortfolioItemQueryFilter(SbmPortfolioItem.Params prm)
|
|
{
|
|
List<String> filter = new List<String>();
|
|
|
|
// Portfolio Item Id.
|
|
String colPortfolioItem_Id = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, aliasPortfolioItem);
|
|
String includedIds = prm.IdsIncluded.Concat(",");
|
|
if (!StringUtil.IsEmpty(includedIds))
|
|
filter.Add(colPortfolioItem_Id + " IN (" + includedIds + ")");
|
|
String excludedIds = prm.IdsExcluded.Concat(",");
|
|
if (!StringUtil.IsEmpty(excludedIds))
|
|
filter.Add(colPortfolioItem_Id + " NOT IN (" + excludedIds + ")");
|
|
|
|
//---------------------------------------------------------------
|
|
// Parent.
|
|
String colPortfolioItem_ItemIdParent = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, aliasPortfolioItem);
|
|
if (SysId.IsValid(prm.ParentItemId))
|
|
filter.Add(colPortfolioItem_ItemIdParent + "=" + prm.AncestorItemId.ToString());
|
|
// Ancestor.
|
|
if (SysId.IsValid(prm.AncestorItemId))
|
|
{
|
|
String sPrtItm1 = "PrtItm1";
|
|
String sPrtItm2 = "PrtItm2";
|
|
String sPrtItm3 = "PrtItm3";
|
|
String sPrtItm4 = "PrtItm4";
|
|
// Query immediate parent:
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm1);
|
|
qry.Columns.Add("1");
|
|
// Parent #2:
|
|
DbQueryJoin join1 = new DbQueryJoin(DbJoinType.LeftOuter);
|
|
join1.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm2);
|
|
join1.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm2) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm1));
|
|
qry.Joins.Add(join1);
|
|
// Parent #3:
|
|
DbQueryJoin join2 = new DbQueryJoin(DbJoinType.LeftOuter);
|
|
join2.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm3);
|
|
join2.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm3) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm2));
|
|
qry.Joins.Add(join2);
|
|
// Parent #4:
|
|
DbQueryJoin join3 = new DbQueryJoin(DbJoinType.LeftOuter);
|
|
join3.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), sPrtItm4);
|
|
join3.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm4) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm3));
|
|
qry.Joins.Add(join3);
|
|
// Filter to ensure that at least one of the parents matches the specified ancestor:
|
|
qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm1) + "=" + colPortfolioItem_ItemIdParent);
|
|
List<String> filter1 = new List<string>();
|
|
filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm1) + "=" + SysId.ToString(prm.AncestorItemId));
|
|
filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm2) + "=" + SysId.ToString(prm.AncestorItemId));
|
|
filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm3) + "=" + SysId.ToString(prm.AncestorItemId));
|
|
filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, sPrtItm4) + "=" + SysId.ToString(prm.AncestorItemId));
|
|
filter1.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, sPrtItm4) + "=" + SysId.ToString(prm.AncestorItemId));
|
|
qry.Filters.Add(filter1.Concat(" OR ", "(", ")"));
|
|
filter.Add("EXISTS (" + qry.BuildQuery() + ")");
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Commodity Id.
|
|
String colPortfolioItem_CommodityId = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, aliasPortfolioItem);
|
|
String includedCommodityIds = prm.CommodityIdsIncluded.Concat(",");
|
|
if (!StringUtil.IsEmpty(includedCommodityIds))
|
|
filter.Add(colPortfolioItem_CommodityId + " IN (" + includedCommodityIds + ")");
|
|
String excludedCommodityIds = prm.CommodityIdsExcluded.Concat(",");
|
|
if (!StringUtil.IsEmpty(excludedCommodityIds))
|
|
filter.Add(colPortfolioItem_CommodityId + " NOT IN (" + excludedCommodityIds + ")");
|
|
|
|
// Commodity code.
|
|
if (!StringUtil.IsEmpty(prm.CommodityCodeFull) || !StringUtil.IsEmpty(prm.CommodityCodePartial))
|
|
{
|
|
String sCmdAlias = "Cmd1";
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Commodity), sCmdAlias);
|
|
qry.Columns.Add("1");
|
|
qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Id, sCmdAlias) + "=" + colPortfolioItem_CommodityId);
|
|
if (!StringUtil.IsEmpty(prm.CommodityCodeFull))
|
|
qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Code, sCmdAlias) + "='" + DbQuery.FormatForCondition(prm.CommodityCodeFull) + "'");
|
|
else if (!StringUtil.IsEmpty(prm.CommodityCodePartial))
|
|
qry.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Code, sCmdAlias) + " LIKE '%" + DbQuery.FormatForLike(prm.CommodityCodePartial) + "%'");
|
|
filter.Add("EXISTS (" + qry.BuildQuery() + ")");
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Type.
|
|
String colPortfolioItem_Type = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Type, aliasPortfolioItem);
|
|
if ((int)prm.PortfolioItemType > 0)
|
|
filter.Add(colPortfolioItem_Type + "=" + ((int)prm.PortfolioItemType).ToString());
|
|
|
|
//---------------------------------------------------------------
|
|
// Sequence.
|
|
String colPortfolioItem_Seq = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Seq, aliasPortfolioItem);
|
|
if (prm.Sequence > 0)
|
|
filter.Add(colPortfolioItem_Seq + "=" + prm.Sequence);
|
|
|
|
//---------------------------------------------------------------
|
|
// Full & Partial Code.
|
|
String colPortfolioItem_Code = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Code, aliasPortfolioItem);
|
|
if (!StringUtil.IsEmpty(prm.CodeFull))
|
|
filter.Add(colPortfolioItem_Code + "='" + DbQuery.FormatForCondition(prm.CodeFull) + "'");
|
|
if (!StringUtil.IsEmpty(prm.CodePartial))
|
|
filter.Add(colPortfolioItem_Code + " LIKE '%" + DbQuery.FormatForLike(prm.CodePartial) + "%'");
|
|
|
|
//---------------------------------------------------------------
|
|
// Shortcut.
|
|
String colPortfolioItem_ShortCut = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ShortCut, aliasPortfolioItem);
|
|
if (!StringUtil.IsEmpty(prm.ShortCut))
|
|
filter.Add(colPortfolioItem_ShortCut + " = '" + DbQuery.FormatForCondition(prm.ShortCut) + "'");
|
|
|
|
// Status.
|
|
String colPortfolioItem_Status = SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Status, aliasPortfolioItem);
|
|
if (prm.StatusCat == SbmPortfolioItem.StatusCat.NotDeleted)
|
|
filter.Add(colPortfolioItem_Status + " NOT IN ('" + StatusDeleted + "')");
|
|
|
|
//--------------------------------------------------------------- -
|
|
if (filter.Count < 1 && prm.IncludeDefaultFilter) filter.Add("1=1");
|
|
return filter;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Item sort columns.
|
|
public List<String> GetPortfolioItemSortColumns(SbmPortfolioItem.Params prm)
|
|
{
|
|
// Sort sequence.
|
|
List<String> sortColumnNames = new List<String>();
|
|
foreach (var columnDfn in prm.SortColumns)
|
|
{
|
|
// Need to ensure correct alias used for PortfolioItem columns in case of conflict.
|
|
String sortCol = String.Empty;
|
|
if (SbmDbDfn.GetTableForColumn((SbmDbDfn.ColumnIdx)columnDfn.DbColumn) == SbmDbDfn.TableIdx.PortfolioItem)
|
|
{
|
|
sortCol = SbmDbDfn.GetColumnNameQual((SbmDbDfn.ColumnIdx)columnDfn.DbColumn, aliasPortfolioItem);
|
|
}
|
|
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(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_AffIdOwner, aliasPortfolioItem) + " ASC");
|
|
}
|
|
return sortColumnNames;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Item count.
|
|
private long GetPortfolioItemCount(String filter)
|
|
{
|
|
ClearErrorState();
|
|
return Database.GetRowCount(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem) + " As " + aliasPortfolioItem, filter);
|
|
}
|
|
public override long GetPortfolioItemCount(SbmPortfolioItem.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
return GetPortfolioItemCount(GetPortfolioItemQueryFilter(prm).Concat(" AND ", "(", ")"));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Item list.
|
|
public override List<SbmPortfolioItem> GetPortfolioItemList(SbmPortfolioItem.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
List<SbmPortfolioItem> portfolioItems = new List<SbmPortfolioItem>();
|
|
DbQuery qry = new DbQuery(Database.DbmsType);
|
|
qry.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), aliasPortfolioItem);
|
|
PortfolioItem_Db dbPortfolioItem = new PortfolioItem_Db(DbInfo);
|
|
qry.Columns.AddRange(dbPortfolioItem.ExistingColumnNames);
|
|
qry.Filters.AddRange(GetPortfolioItemQueryFilter(prm));
|
|
qry.OrderBy.AddRange(GetPortfolioItemSortColumns(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())
|
|
{
|
|
dbPortfolioItem = new PortfolioItem_Db(DbInfo);
|
|
dbPortfolioItem.PopulateFrom(dbDataReader);
|
|
portfolioItems.Add(CreatePortfolioItem(dbPortfolioItem));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
SetErrorState(Msg_DatabaseQueryException);
|
|
SaLogger.Warn($"{SysUtil.Fn}\n\tQuery: {dbCommand.CommandText}\n\t{ExceptionUtil.GetErrorStateMessage(exc)}");
|
|
}
|
|
}
|
|
return portfolioItems;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Item query execution.
|
|
public override DbResultSet ExecutePortfolioItemQuery(List<ColumnDfn> columns, SbmPortfolioItem.Params prm)
|
|
{
|
|
ClearErrorState();
|
|
|
|
//---------------------------------------------------------------------
|
|
// Construct query.
|
|
DbQuery query = new DbQuery(Database.DbmsType);
|
|
query.Tables.Add(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), aliasPortfolioItem);
|
|
|
|
//---------------------------------------------------------------
|
|
// PortfolioItem Properties - add columns as defined in query list.
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.ItemIdParent))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.CommodityId))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.ItemIdRef))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdRef, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.Type) || columns.HasId(SbmPortfolioItem.Column.Type_Desc))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Type, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.Sequence))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Seq, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.Code))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Code, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.Caption))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Caption, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.DescBrief))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_DescBrief, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.DescDetail))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_DescDetail, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.ShortCut))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ShortCut, aliasPortfolioItem));
|
|
// Common Properties
|
|
if (columns.HasId(SbmPortfolioItem.Column.Notes))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Notes, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.Publish_Y) || columns.HasId(SbmPortfolioItem.Column.Publish_Tick))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Flags, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.Status) || columns.HasId(SbmPortfolioItem.Column.Status_Desc) || columns.HasId(SbmPortfolioItem.Column.Status_Ind))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Status, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.CreateOn_Date))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CreateOn, aliasPortfolioItem));
|
|
if (columns.HasId(SbmPortfolioItem.Column.UpdateOn_Date))
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_UpdateOn, aliasPortfolioItem));
|
|
|
|
//---------------------------------------------------------------
|
|
// Parent item.
|
|
bool hasParentItemCols = columns.HasId(SbmPortfolioItem.Column.Parent_Code) || columns.HasId(SbmPortfolioItem.Column.Parent_Caption);
|
|
if (hasParentItemCols)
|
|
{
|
|
// Parent item join.
|
|
DbQueryJoin joinParent = new DbQueryJoin(DbJoinType.LeftOuter);
|
|
joinParent.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.PortfolioItem), aliasPortfolioItem_Parent);
|
|
joinParent.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_Id, aliasPortfolioItem_Parent) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_ItemIdParent, aliasPortfolioItem));
|
|
query.Joins.Add(joinParent);
|
|
List<SbmDbDfn.ColumnIdx> dbCols = new List<SbmDbDfn.ColumnIdx>();
|
|
dbCols.Add(SbmDbDfn.ColumnIdx.PortfolioItem_Code);
|
|
dbCols.Add(SbmDbDfn.ColumnIdx.PortfolioItem_Caption);
|
|
foreach (SbmDbDfn.ColumnIdx dbColumn in dbCols)
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasPortfolioItem_Parent), prefixPortfolioItem_Parent + SbmDbDfn.GetColumnName(dbColumn, false));
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
// Commodity.
|
|
bool hasCommodityCols =
|
|
columns.HasId(SbmPortfolioItem.Column.Commodity_Code) || columns.HasId(SbmPortfolioItem.Column.Commodity_DescBrief) ||
|
|
columns.HasId(SbmPortfolioItem.Column.Commodity_SalesPrice) || columns.HasId(SbmPortfolioItem.Column.Commodity_SalesPrice_Fmt);
|
|
if (hasCommodityCols)
|
|
{
|
|
// Commodity join.
|
|
DbQueryJoin joinCommodity = new DbQueryJoin(DbJoinType.LeftOuter);
|
|
joinCommodity.Table = new StringPair(SbmDbDfn.GetTableName(SbmDbDfn.TableIdx.Commodity), aliasPortfolioItem_Commodity);
|
|
joinCommodity.Filters.Add(SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.Commodity_Id, aliasPortfolioItem_Commodity) + "=" + SbmDbDfn.GetColumnNameQual(SbmDbDfn.ColumnIdx.PortfolioItem_CommodityId, aliasPortfolioItem));
|
|
query.Joins.Add(joinCommodity);
|
|
List<SbmDbDfn.ColumnIdx> dbCols = new List<SbmDbDfn.ColumnIdx>();
|
|
dbCols.Add(SbmDbDfn.ColumnIdx.Commodity_Code);
|
|
dbCols.Add(SbmDbDfn.ColumnIdx.Commodity_DescBrief);
|
|
dbCols.Add(SbmDbDfn.ColumnIdx.Commodity_SalesPrice);
|
|
foreach (SbmDbDfn.ColumnIdx dbColumn in dbCols)
|
|
query.Columns.Add(SbmDbDfn.GetColumnNameQual(dbColumn, aliasPortfolioItem_Commodity), prefixPortfolioItem_Commodity + SbmDbDfn.GetColumnName(dbColumn, false));
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Populate filter.
|
|
query.Filters.AddRange(GetPortfolioItemQueryFilter(prm));
|
|
|
|
if (prm.IdsIncluded.Count != 1)
|
|
{
|
|
// Configure sort sequence.
|
|
foreach (String sortColumn in GetPortfolioItemSortColumns(prm))
|
|
query.OrderBy.Add(sortColumn);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
//return new DbResultSet_DataTableReader(Database, query.BuildQuery());
|
|
return DbResultSet_DataReader.ExecuteQuery(Database, query.BuildQuery(prm.ResultsPaging));
|
|
}
|
|
//-------------------------------------------------------------------
|
|
}
|
|
//=======================================================================
|
|
}
|