public static DataSet GetTradeableInstruments(
SecCategoryFilterOptions secCategoryFilter, string isin, string instrumentName,
SecCategories secCategoryId, int exchangeId, int currencyNominalId,
ActivityReturnFilter activityFilter, string propertyList)
{
return GetTradeableInstruments(
secCategoryFilter, isin, instrumentName, secCategoryId,
exchangeId, currencyNominalId, activityFilter, true, null, propertyList);
}
public static List<IInternalEmployeeLogin> GetEmployees(IDalSession session, ActivityReturnFilter activityFilter)
{
List<ICriterion> expressions = new List<ICriterion>();
if (activityFilter != ActivityReturnFilter.All)
expressions.Add(Expression.Eq("IsActive", activityFilter == ActivityReturnFilter.Active));
return session.GetTypedList<InternalEmployeeLogin, IInternalEmployeeLogin>(expressions);
}
/// <summary>
/// Get lifecycle by ID
/// </summary>
/// <param name="session">Data access object</param>
/// <param name="assetManagerId">Identifier</param>
/// <param name="activityFilter">Identifier</param>
/// <returns>List of Lifecycle objects</returns>
public static IList<ILifecycle> GetLifecycles(IDalSession session, int assetManagerId, ActivityReturnFilter activityFilter)
{
Hashtable parameters = new Hashtable();
if (assetManagerId != 0)
parameters.Add("managementCompanyID", assetManagerId);
if (activityFilter != ActivityReturnFilter.All)
parameters.Add("isActive", (activityFilter == ActivityReturnFilter.Active ? true : false));
return session.GetTypedListByNamedQuery<ILifecycle>(
"B4F.TotalGiro.Instruments.Lifecycles",
parameters);
}
/// <summary>
/// Get all system models
/// </summary>
/// <param name="session">Data access object</param>
/// <param name="includePublic">Include Public Models</param>
/// <param name="activityFilter">Active Filter</param>
/// <returns>Collection of models</returns>
public static List<IPortfolioModel> GetModels(IDalSession session, bool includePublic, ActivityReturnFilter activityFilter)
{
List<ICriterion> expressions = new List<ICriterion>();
List<Order> orderings = new List<Order>();
orderings.Add(Order.Asc("ModelName"));
addAssetManagerCriterion(expressions, getForcedAssetManagerId(session, null), includePublic);
if (activityFilter != ActivityReturnFilter.All)
expressions.Add(Expression.Eq("IsActive", (activityFilter == ActivityReturnFilter.Active ? true : false)));
return session.GetTypedList<PortfolioModel, IPortfolioModel>(expressions, orderings, null, null);
}
public static IList<IWithdrawalRule> GetWithdrawalRules(IDalSession session, int accountID, ActivityReturnFilter activityFilter)
{
List<ICriterion> expressions = new List<ICriterion>();
IAccountTypeCustomer acc = (IAccountTypeCustomer)AccountMapper.GetAccount(session, accountID);
if (acc != null)
{
expressions.Add(Expression.Eq("Account.Key", acc.Key));
if (activityFilter != ActivityReturnFilter.All)
expressions.Add(Expression.Eq("IsActive", (activityFilter == ActivityReturnFilter.Active ? true : false)));
return session.GetTypedList<WithdrawalRule, IWithdrawalRule>(expressions);
}
else
return null;
}
public static List<IRemisier> GetRemisiers(IDalSession session, IAssetManager assetManager, string remisierName,
ActivityReturnFilter activityFilter)
{
bool loggedInAsStichting = LoginMapper.IsLoggedInAsStichting(session);
if (assetManager == null && !loggedInAsStichting)
assetManager = (IAssetManager)LoginMapper.GetCurrentManagmentCompany(session);
if (assetManager != null || loggedInAsStichting)
{
int assetManagerId = assetManager != null ? assetManager.Key : 0;
return GetRemisiers(session, assetManagerId, remisierName, activityFilter);
}
else
return null;
}
public static DataSet GetFilteredInstruments(
InstrumentCurrentPricesAdapter.DataSourceChoices secCatChoice, string isin,
string instrumentName, int currencyNominalId, ActivityReturnFilter activityFilter)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
DataSet ds = null;
switch (secCatChoice)
{
case InstrumentCurrentPricesAdapter.DataSourceChoices.InstrumentsTradeable:
ds = InstrumentMapper.GetTradeableInstruments(
session, SecCategoryFilterOptions.Securities,
isin, instrumentName, 0, 0, currencyNominalId, false, activityFilter, "")
.Select(c => new
{
c.Key,
Description = c.DisplayIsinWithName
})
.ToDataSet();
break;
case InstrumentCurrentPricesAdapter.DataSourceChoices.Currencies:
ds = InstrumentMapper.GetCurrenciesByName(
session, isin, instrumentName, activityFilter)
.Where(x => !x.IsBase)
.Select(c => new
{
c.Key,
Description = c.Symbol + " - " + c.Name
})
.ToDataSet();
break;
case InstrumentCurrentPricesAdapter.DataSourceChoices.BenchMarks:
ds = InstrumentMapper.GetBenchMarks(
session, isin, instrumentName, currencyNominalId, activityFilter)
.Select(c => new
{
c.Key,
Description = c.DisplayIsinWithName
})
.ToDataSet();
break;
}
Utility.AddEmptyFirstRow(ds.Tables[0]);
return ds;
}
}
public static List<IRemisierEmployee> GetRemisierEmployees(IDalSession session, int remisierId, ActivityReturnFilter activityFilter)
{
IQueryable<RemisierEmployee> remisierEmployees = session.Session.Linq<RemisierEmployee>()
.Where(re => re.Remisier.IsActive);
if (remisierId != 0)
remisierEmployees = remisierEmployees.Where(re => re.Remisier.Key == remisierId);
if (activityFilter == ActivityReturnFilter.Active)
remisierEmployees = remisierEmployees.Where(re => re.IsActive);
else if (activityFilter == ActivityReturnFilter.InActive)
remisierEmployees = remisierEmployees.Where(re => !re.IsActive);
return remisierEmployees.OrderBy(re => re.Employee.LastName)
.Cast<IRemisierEmployee>()
.ToList();
}
public static IList<IBenchMark> GetBenchMarks(
IDalSession session, string isin, string instrumentName,
int currencyNominalId, ActivityReturnFilter activityFilter)
{
Hashtable parameters = new Hashtable();
if (!string.IsNullOrEmpty(isin))
parameters.Add("isin", Util.PrepareNamedParameterWithWildcard(isin, MatchModes.Anywhere));
if (!string.IsNullOrEmpty(instrumentName))
parameters.Add("instrumentName", Util.PrepareNamedParameterWithWildcard(instrumentName, MatchModes.Anywhere));
if (currencyNominalId > 0)
parameters.Add("currencyNominalId", currencyNominalId);
if (activityFilter != ActivityReturnFilter.All)
parameters.Add("isActive", activityFilter == ActivityReturnFilter.Active);
return session.GetTypedListByNamedQuery<IBenchMark>(
"B4F.TotalGiro.Instruments.Instrument.GetBenchmarks",
parameters);
}
public static DataSet GetHistoricalBenchMarks(DateTime date,
string isin, string instrumentName, int currencyNominalId,
ActivityReturnFilter activityFilter)
{
IDalSession session = NHSessionFactory.CreateSession();
IList<IBenchMark> instruments = InstrumentMapper.GetBenchMarks(
session, isin, instrumentName, currencyNominalId, activityFilter);
DataSet historicalPriceDs = HistoricalPriceMapper.GetHistoricalPrices(session, date)
.Select(c => new
{
Price_Key =
c.Price.Instrument.Key,
Price_Amount =
c.Price.Amount.Quantity
})
.ToDataSet();
int i = 0;
InstrumentPriceRowView[] instrumentPriceRowViews = new InstrumentPriceRowView[instruments.Count];
foreach (IBenchMark instrument in instruments)
{
DataRow[] historicalPriceRows = historicalPriceDs.Tables[0].Select(string.Format("Price_Key = {0}", instrument.Key));
decimal priceQuantity = (historicalPriceRows.Length > 0 ? (decimal)historicalPriceRows[0]["Price_Amount"] : 0m);
instrumentPriceRowViews[i++] = new InstrumentPriceRowView(instrument, priceQuantity);
}
DataSet ds = instrumentPriceRowViews
.Select(c => new
{
c.InstrumentId,
c.Isin,
c.InstrumentName,
c.Currency,
c.PriceQuantity,
c.DecimalPlaces
})
.ToDataSet();
session.Close();
return ds;
}
public static DataSet GetHistoricalCurrencyRates(DateTime date,
string currencyName, string instrumentName, ActivityReturnFilter activityFilter)
{
IDalSession session = NHSessionFactory.CreateSession();
IList<ICurrency> currencies = InstrumentMapper.GetCurrenciesByName(
session, currencyName, instrumentName, activityFilter)
.Where(x => !x.IsBase)
.ToList();
DataSet historicalRateDs = HistoricalExRateMapper.GetHistoricalExRates(session, date)
.Select(c => new
{
Currency_Key =
c.Currency.Key,
c.Rate
})
.ToDataSet();
int i = 0;
CurrencyRateRowView[] currencyRateRowViews = new CurrencyRateRowView[currencies.Count];
foreach (Currency currency in currencies)
{
DataRow[] historicalRateRows = historicalRateDs.Tables[0].Select(string.Format("Currency_Key = {0}", currency.Key));
decimal rate = (historicalRateRows.Length > 0 ? (decimal)historicalRateRows[0]["Rate"] : 0m);
currencyRateRowViews[i++] = new CurrencyRateRowView(currency, rate);
}
DataSet ds = currencyRateRowViews
.Select(c => new
{
c.InstrumentId,
c.Symbol,
c.CountryName,
c.AltSymbol,
c.Rate
})
.ToDataSet();
session.Close();
return ds;
}
/// <summary>
/// Get all system models, sorted alphabetically
/// </summary>
/// <param name="session">Data access object</param>
/// <param name="assetManager">The assetManager that owns the model</param>
/// <param name="includePublic">Include Public Models</param>
/// <param name="activityFilter">Active Filter</param>
/// <returns>Collection of models</returns>
public static List<IPortfolioModel> GetModelsSorted(IDalSession session, IAssetManager assetManager, bool includePublic, bool includeSubModels, ActivityReturnFilter activityFilter)
{
return GetModelsSorted(session, assetManager, includePublic, includeSubModels, activityFilter, null);
}
public static IList<ITradeableInstrument> GetTradeableInstruments(IDalSession session,
SecCategoryFilterOptions secCategoryFilter,
string isin, string instrumentName, SecCategories secCategoryId,
int exchangeId, int currencyNominalId, bool assetManagerMappedOnly,
ActivityReturnFilter activityFilter, string hqlWhere)
{
Hashtable parameters = new Hashtable();
if (secCategoryFilter != SecCategoryFilterOptions.All)
parameters.Add("secCategoryType", (int)secCategoryFilter);
if (!string.IsNullOrEmpty(isin))
parameters.Add("isin", Util.PrepareNamedParameterWithWildcard(isin, MatchModes.Anywhere));
if (!string.IsNullOrEmpty(instrumentName))
parameters.Add("instrumentName", Util.PrepareNamedParameterWithWildcard(instrumentName, MatchModes.Anywhere));
if (secCategoryId != SecCategories.Undefined)
parameters.Add("secCategoryId", secCategoryId);
if (exchangeId > 0)
parameters.Add("exchangeId", exchangeId);
if (currencyNominalId > 0)
parameters.Add("currencyNominalId", currencyNominalId);
if (activityFilter != ActivityReturnFilter.All)
parameters.Add("isActive", activityFilter == ActivityReturnFilter.Active);
if (assetManagerMappedOnly)
{
IManagementCompany comp = LoginMapper.GetCurrentManagmentCompany(session);
if (comp != null && !comp.IsStichting)
parameters.Add("managementCompanyID", comp.Key);
}
IList<ITradeableInstrument> list = session.GetTypedListByNamedQuery<ITradeableInstrument>(
"B4F.TotalGiro.Instruments.Instrument.GetTradeableInstruments",
hqlWhere, parameters);
if (secCategoryFilter != SecCategoryFilterOptions.CorporateAction)
list = list.Where(x => x.SecCategory.SecCategoryType != SecCategoryTypes.CorporateAction).ToList();
return list;
}
/// <summary>
/// Get currency by name
/// </summary>
/// <param name="session">data access object</param>
/// <param name="currencyName">Name</param>
/// <param name="instrumentName">Name</param>
/// <returns>Currency</returns>
public static IList<ICurrency> GetCurrenciesByName(
IDalSession session, string currencyName,
string instrumentName, ActivityReturnFilter activityFilter)
{
List<ICriterion> expressions = new List<ICriterion>();
expressions.Add(Expression.Like("Symbol", currencyName, MatchMode.Start));
if (!string.IsNullOrEmpty(instrumentName))
expressions.Add(Expression.Like("Name", instrumentName, MatchMode.Start));
if (activityFilter != ActivityReturnFilter.All)
expressions.Add(Expression.Eq("IsActive", activityFilter == ActivityReturnFilter.Active));
return session.GetTypedList<Currency, ICurrency>(expressions);
}
/// <summary>
/// This method does NOT filter by the current asset manager.
/// </summary>
public static List<IRemisier> GetRemisiers(IDalSession session, int assetManagerId, string remisierName,
ActivityReturnFilter activityFilter)
{
Hashtable parameters = new Hashtable();
if (assetManagerId != 0)
parameters.Add("assetManagerId", assetManagerId);
if (!string.IsNullOrEmpty(remisierName))
parameters.Add("remisierName", Util.PrepareNamedParameterWithWildcard(remisierName));
if (activityFilter != ActivityReturnFilter.All)
parameters.Add("deleted", activityFilter != ActivityReturnFilter.Active);
return session.GetTypedListByNamedQuery<IRemisier>(
"B4F.TotalGiro.Stichting.Remisier.Remisiers",
parameters);
}
public static DataSet GetLifecycles(int assetManagerId, ActivityReturnFilter activityFilter)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
if (activityFilter != ActivityReturnFilter.Active)
activityFilter = ActivityReturnFilter.All;
DataSet ds = LifecycleMapper.GetLifecycles(session, assetManagerId, activityFilter)
.Select(c => new
{
c.Key,
c.Name
})
.ToDataSet();
Utility.AddEmptyFirstRow(ds);
return ds;
}
}
public static DataSet GetInstructions(int assetManagerId, int modelPortfolioId, string accountNumber, string accountName,
DateTime dateFrom, DateTime dateTo, ActivityReturnFilter activeStatus, WithdrawalInstructionsTypeReturnEnum returnType,
int maximumRows, int pageIndex, string sortColumn)
{
const string propertyList =
"Key, Account.Key, Account.Number, Account.ShortName, Status, DisplayStatus, Message, Warning, WithdrawalDate, LatestPossibleFreeUpCashDate, Amount.Quantity, Amount.DisplayString, DisplayRegularity, HasOrders, MoneyTransferOrder.Key, IsEditable, IsActive, CreationDate, DoNotChargeCommission, IsCancellable";
string bareSortColumn = sortColumn.Split(' ')[0];
bool ascending = !(sortColumn.Split(' ').Length == 2 && sortColumn.Split(' ')[1] == "DESC");
IDalSession session = NHSessionFactory.CreateSession();
DataSet ds = null;
IList allInstructions;
if (isHqlSortingNeeded(bareSortColumn))
{
allInstructions = GetInstructionsList(session,
assetManagerId, modelPortfolioId, accountNumber, accountName, dateFrom, dateTo, activeStatus, returnType, null, bareSortColumn, ascending, true);
ds = DataSetBuilder.CreateDataSetFromHibernateList(allInstructions, "Key, IsActive");
}
else
{
allInstructions = GetInstructionsList(session,
assetManagerId, modelPortfolioId, accountNumber, accountName, dateFrom, dateTo, activeStatus, returnType, null, bareSortColumn, ascending, false);
ds = DataSetBuilder.CreateDataSetFromBusinessObjectList(allInstructions, "Key, " + bareSortColumn.Replace('_', '.'));
Util.SortDataTable(ds.Tables[0], sortColumn);
session.Close();
session = NHSessionFactory.CreateSession();
}
int[] instructionIds = Util.GetPageKeys(ds.Tables[0], maximumRows, pageIndex, "Key");
IList pageInstructions = GetInstructionsList(session, 0, 0, null, null, DateTime.MinValue, DateTime.MinValue, ActivityReturnFilter.All, WithdrawalInstructionsTypeReturnEnum.All, instructionIds, bareSortColumn, ascending, false);
DataSetBuilder.MergeDataTableWithBusinessObjectList(ds.Tables[0], pageInstructions, "Key", propertyList);
session.Close();
return ds;
}
public static DataSet GetFilteredInstruments(
string isin, string instrumentName, int currencyNominalId,
int secCategoryId, ActivityReturnFilter activityFilter)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
DataSet ds = InstrumentMapper.GetTradeableInstruments(
session, SecCategoryFilterOptions.Securities,
isin, instrumentName, (SecCategories)secCategoryId, 0,
currencyNominalId, false, activityFilter, "")
.Select(c => new
{
c.Key,
Description = c.DisplayIsinWithName
})
.ToDataSet();
Utility.AddEmptyFirstRow(ds.Tables[0]);
return ds;
}
}
public static DataSet GetModelPortfolios(int assetManagerId, ActivityReturnFilter activityFilter)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
DataSet ds = null;
IAssetManager assetManager = null;
if (activityFilter != ActivityReturnFilter.Active)
activityFilter = ActivityReturnFilter.All;
if (assetManagerId > 0)
assetManager = (IAssetManager)ManagementCompanyMapper.GetAssetManager(session, assetManagerId);
IList<IPortfolioModel> list = ModelMapper.GetModelsSorted(session, assetManager, true, false, activityFilter);
if (list != null)
{
ds = list
.Select(c => new
{
c.Key,
c.ModelName
})
.ToDataSet();
Utility.AddEmptyFirstRow(ds);
}
return ds;
}
}
public static IList GetInstructionsList(IDalSession session, int assetManagerId, int modelPortfolioId, string accountNumber, string accountName,
DateTime dateFrom, DateTime dateTo, ActivityReturnFilter activeStatus, WithdrawalInstructionsTypeReturnEnum returnType,
int[] instructionIds, string sortColumn, bool ascending, bool keysOnly)
{
string where = "";
if (assetManagerId > 0)
where += string.Format(" and A.AccountOwner = {0} ", assetManagerId);
if (modelPortfolioId > 0)
where += string.Format(" and M.Key = {0}", modelPortfolioId);
if (accountNumber != null && accountNumber.Length > 0)
where += string.Format(" and A.Number LIKE '%{0}%'", accountNumber);
if (accountName != null && accountName.Length > 0)
where += string.Format(" and A.ShortName LIKE '%{0}%'", accountName);
if (dateFrom != DateTime.MinValue || dateTo != DateTime.MinValue)
{
if (dateFrom != DateTime.MinValue && dateTo != DateTime.MinValue)
where += string.Format(" and I.WithdrawalDate between '{0}' and '{1}'", dateFrom.ToString("yyyy-MM-dd"), dateTo.ToString("yyyy-MM-dd"));
if (dateFrom != DateTime.MinValue)
where += string.Format(" and I.WithdrawalDate >= '{0}'", dateFrom.ToString("yyyy-MM-dd"));
if (dateTo != DateTime.MinValue)
where += string.Format(" and I.WithdrawalDate <= '{0}'", dateTo.ToString("yyyy-MM-dd"));
}
if (activeStatus == ActivityReturnFilter.Active)
where += string.Format(" and (I.IsActive = 1 or (I.IsActive = 0 and I.CloseDate >= '{0}'))", DateTime.Today.ToString("yyyy-MM-dd"));
else if (activeStatus == ActivityReturnFilter.InActive)
where += " and (I.IsActive = 0)";
if (returnType != WithdrawalInstructionsTypeReturnEnum.All)
where += string.Format(" and I.IsPeriodic = {0}", (returnType == WithdrawalInstructionsTypeReturnEnum.Periodic ? 1 : 0));
if (instructionIds != null)
where += string.Format(" and I.Key IN ({0})",
(instructionIds.Length == 0 ? "0" : string.Join(", ", Array.ConvertAll<int, string>(instructionIds, id => id.ToString()))));
string orderBy = "order by A.Key", contactsJoin = "";
if (keysOnly && sortColumn != "")
{
string ascendingStr = (ascending ? "ASC" : "DESC");
sortColumn = sortColumn.ToUpper();
string sortProperty = "";
switch (sortColumn)
{
case "KEY":
sortProperty = "A.Key";
break;
case "ACCOUNT_NUMBER":
sortProperty = "A.Number";
break;
case "ACCOUNT_SHORTNAME":
sortProperty = "CN.Name";
contactsJoin = @"left join A.bagOfAccountHolders AH
left join AH.Contact C
left join C.CurrentNAW CN";
where += " and AH.IsPrimaryAccountHolder = true";
break;
case "STATUS":
sortProperty = "I.Status";
break;
case "DONOTCHARGECOMMISSION":
sortProperty = "I.DoNotChargeCommission";
break;
case "MESSAGE":
sortProperty = "I.Message";
break;
case "WITHDRAWALDATE":
sortProperty = "I.WithdrawalDate";
break;
case "EXECUTIONDATE":
sortProperty = "I.ExecutionDate";
break;
case "CREATIONDATE":
sortProperty = "I.CreationDate";
break;
case "AMOUNT_QUANTITY":
sortProperty = "I.Amount.Quantity";
break;
case "ISACTIVE":
sortProperty = "I.IsActive";
break;
case "REGULARITY":
sortProperty = "R.Regularity";
break;
}
if (sortProperty != "")
orderBy = string.Format("order by {0} {1}", sortProperty, ascendingStr);
}
string hql = string.Format(@"{0}from CashWithdrawalInstruction I
left join {1} I.Account A
left join {1} A.ModelPortfolio M
left join {1} I.Rule R {2}
where (I.ExecutionDate <= '{3}') {4} {5}",
(keysOnly ? "select I.Key, I.IsActive " : ""),
(keysOnly ? "" : "fetch"),
contactsJoin, DateTime.Today.ToString("yyyy-MM-dd"), where, orderBy);
return session.GetListByHQL(hql, null);
}
/// <summary>
/// Get all system models, sorted alphabetically
/// </summary>
/// <param name="session">Data access object</param>
/// <param name="assetManager">The assetManager that owns the model</param>
/// <param name="includePublic">Include Public Models</param>
/// <param name="activityFilter">Active Filter</param>
/// <param name="modelName">Model Name Filter</param>
/// <returns>Collection of models</returns>
public static List<IPortfolioModel> GetModelsSorted(IDalSession session, IAssetManager assetManager, bool includePublic, bool includeSubModels,
ActivityReturnFilter activityFilter, string modelName)
{
if (assetManager != null || !LoginMapper.IsLoggedInAsStichting(session))
return GetModelsSorted(session, getForcedAssetManagerId(session, assetManager), includePublic, includeSubModels, activityFilter, modelName);
else
return null;
}
public static DataSet GetTradeableInstrumentsDDL(
SecCategoryFilterOptions secCategoryFilter, string isin, string instrumentName,
SecCategories secCategoryId, int exchangeId, int currencyNominalId,
ActivityReturnFilter activityFilter)
{
DataSet ds = InstrumentFinderAdapter.GetTradeableInstruments(
secCategoryFilter, isin, instrumentName,
secCategoryId, exchangeId, currencyNominalId,
activityFilter, true, null, "Key, Isin, DisplayIsinWithName");
Utility.AddEmptyFirstRow(ds.Tables[0]);
return ds;
}
/// <summary>
/// This method does NOT filter by the current asset manager.
/// </summary>
public static List<IPortfolioModel> GetModelsSorted(IDalSession session, int assetManagerId, bool includePublic, bool includeSubModels,
ActivityReturnFilter activityFilter, string modelName)
{
List<ICriterion> expressions = new List<ICriterion>();
List<Order> orderings = new List<Order>();
addAssetManagerCriterion(expressions, assetManagerId, includePublic);
if (!includeSubModels)
expressions.Add(Expression.Or(Expression.Eq("IsSubModel", false), Expression.IsNull("IsSubModel")));
if (activityFilter != ActivityReturnFilter.All)
expressions.Add(Expression.Eq("IsActive", (activityFilter == ActivityReturnFilter.Active ? true : false)));
if (!string.IsNullOrEmpty(modelName))
expressions.Add(Expression.Like("ModelName", modelName, MatchMode.Anywhere));
orderings.Add(Order.Asc("ModelName"));
return session.GetTypedList<PortfolioModel, IPortfolioModel>(expressions, orderings, null, null);
}
public static DataSet GetTradeableInstruments(
SecCategoryFilterOptions secCategoryFilter, string isin, string instrumentName,
SecCategories secCategoryId, int exchangeId, int currencyNominalId,
ActivityReturnFilter activityFilter, bool assetManagerMappedOnly,
string hqlWhere, string propertyList)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
return InstrumentMapper.GetTradeableInstruments(
session, secCategoryFilter, isin, instrumentName,
secCategoryId, exchangeId, currencyNominalId,
assetManagerMappedOnly, activityFilter, hqlWhere)
.ToDataSet(propertyList);
}
}
public static DataSet GetMappedInstruments(int assetManagerId, ActivityReturnFilter activityFilter)
{
DataSet ds = null;
IAssetManager am = null;
IDalSession session = NHSessionFactory.CreateSession();
if (assetManagerId == 0)
am = (IAssetManager)LoginMapper.GetCurrentManagmentCompany(session);
else
am = ManagementCompanyMapper.GetAssetManager(session, assetManagerId);
if (am != null && am.AssetManagerInstruments != null && am.AssetManagerInstruments.Count > 0)
{
IList<IAssetManagerInstrument> list = am.AssetManagerInstruments.ToList();
if (activityFilter != ActivityReturnFilter.All)
list = list.Where(u => u.IsActive == (activityFilter == ActivityReturnFilter.Active)).ToList();
ds = DataSetBuilder.CreateDataSetFromBusinessObjectList(
list.ToList(),
@"Key, Instrument.DisplayName, Instrument.DisplayIsin, AssetClass.Key, AssetClass.AssetName,
RegionClass.Key, RegionClass.RegionName, InstrumentsCategories.Key, InstrumentsCategories.InstrumentsCategoryName,
SectorClass.Key, SectorClass.SectorName, MaxWithdrawalAmountPercentage, IsActive");
}
session.Close();
return ds;
}
