public static DataSet GetCommissionRules(
string commrulename, int commRuleTypeId, int modelId, int accountId, int instrumentId, int buySell,
SecCategories secCategoryId, int exchangeId, DateTime startdate, DateTime enddate,
int commcalcId, int orderactiontype, int additionalCalcId, Boolean applytoallaccounts)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
//"Key, CommRuleName, CommCalculation.Name"
return CommRuleMapper.GetCommissionRules(session, commrulename, commRuleTypeId,
modelId, accountId, instrumentId, buySell, secCategoryId, exchangeId,
startdate, enddate, commcalcId, orderactiontype, additionalCalcId,
applytoallaccounts)
.Select(c => new
{
c.Key,
c.CommRuleName,
CommCalculation_Name = c.CommCalculation != null ? c.CommCalculation.Name : "",
c.StartDate,
c.EndDate,
c.DisplayRule,
IsAccountActive = c.Account != null ? c.Account.Status == AccountStati.Active : true
})
.ToDataSet();
}
}
public DerivativeMaster(string name, SecCategories secCategory, IExchange exchange)
: this()
{
this.Name = name;
this.SecCategory = secCategory;
this.Exchange = exchange;
}
public static DataSet GetAggregatedOrders(string isin, string instrumentName, SecCategories secCategoryId, int currencyNominalId)
{
//"Key, ParentOrder, ChildOrders.Count, TradedInstrument.DisplayName, DisplayTradedInstrumentIsin, Side, Value, Value.DisplayString,
//"DisplayIsSizeBased, CreationDate, OrderID");
//Route.Name
using (IDalSession session = NHSessionFactory.CreateSession())
{
return OrderMapper.GetOrders<IAggregatedOrder>(session, OrderReturnClass.SecurityOrder, OrderAggregationLevel.AssetManager, ApprovalState.UnApproved,
SecurityInfoOptions.TradingAcctOnly, ParentalState.Null, new OrderStatusFilter(OrderStati.New),
isin, instrumentName, secCategoryId, currencyNominalId, null)
.Select(c => new
{
c.Key,
c.ParentOrder,
ChildOrders_Count = c.ChildOrders.Count,
TradedInstrument_DisplayName = c.RequestedInstrument.DisplayName,
c.DisplayTradedInstrumentIsin,
c.Side,
c.Value,
Value_DisplayString = c.Value.DisplayString,
c.DisplayIsSizeBased,
c.CreationDate,
c.OrderID
})
.ToDataSet();
}
}
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 DataSet GetOrders(int orderType, string accountNumber, string accountName, string isin, string instrumentName, SecCategories secCategoryID, int activeFlag, string orderID, DateTime DateFrom, DateTime DateTo)
{
IDalSession session = NHSessionFactory.CreateSession();
IList<IOrder> orders;
int id;
if (orderID != string.Empty && int.TryParse(orderID, out id))
{
int[] ids = new int[1] { id };
orders = OrderMapper.GetOrders(session, ids, true);
}
else
{
orders = OrderMapper.GetOrders<IOrder>(session,
(OrderReturnClass)orderType,
OrderAggregationLevel.All,
ApprovalState.All,
SecurityInfoOptions.NoFilter,
ParentalState.All,
null, null, null, 0, accountNumber, accountName,
(ActiveClosedState)activeFlag, isin, instrumentName, secCategoryID,0, DateFrom, DateTo);
}
//"Account.Number, Account.ShortName, Account.AccountOwner.CompanyName, RequestedInstrument.DisplayName, DisplayTradedInstrumentIsin, Side, Value, Value.DisplayString, FilledValue, " +
//"CommissionInfo, Status, DisplayStatus, TopParentDisplayStatus, CreationDate, OrderID");
DataSet ds = orders
.Select(c => new
{
Account_Number = c.Account.Number,
Account_ShortName = c.Account.ShortName,
Account_AccountOwner_CompanyName = c.Account.AccountOwner.CompanyName,
RequestedInstrument_DisplayName = c.RequestedInstrument.DisplayName,
c.DisplayTradedInstrumentIsin,
c.Side,
c.Value,
Value_DisplayString = c.Value.DisplayString,
c.FilledValue,
c.CommissionInfo,
Status = c.TopParentOrder != null ? c.TopParentOrder.Status : c.Status,
DisplayStatus = c.TopParentDisplayStatus != "" ? c.TopParentDisplayStatus : c.DisplayStatus,
c.CreationDate,
c.OrderID
})
.ToDataSet();
session.Close();
HttpContext.Current.Session["RefreshedTimeOrderBook"] = DateTime.Now;
return ds;
}
/// <summary>
/// Retrieves a list of all <b>CommRule</b> objects in the system.
/// </summary>
/// <param name="session">An instance of the Data Access Library (see class <see cref="B4F.TotalGiro.DAL.NHSession">NHSession</see>).</param>
/// <param name="account">The number of the account property.</param>
/// <returns>A list of all <b>CommRule</b> objects in the system.</returns>
public static IList<ICommRule> GetCommissionRules(IDalSession session,
string commRuleName, int commRuleTypeId, int modelId, int accountId, int instrumentId, int buySell,
SecCategories secCategoryId, int exchangeId, DateTime startDate, DateTime endDate,
int commCalcId, int orderActionType, int additionalCalcId, Boolean applytoAllAccounts)
{
Hashtable parameters = new Hashtable();
IManagementCompany company = LoginMapper.GetCurrentManagmentCompany(session);
if (!company.IsStichting)
parameters.Add("companyId", company.Key);
if (!string.IsNullOrEmpty(commRuleName))
parameters.Add("comruleName", Util.PrepareNamedParameterWithWildcard(commRuleName, MatchModes.Anywhere));
if (commRuleTypeId != 0 && commRuleTypeId != int.MinValue)
parameters.Add("commRuleTypeId", commRuleTypeId);
if (accountId != 0 && accountId != int.MinValue)
parameters.Add("accountId", accountId);
if (modelId != 0 && modelId != int.MinValue)
parameters.Add("modelId", modelId);
if (secCategoryId != 0 && (int)secCategoryId != int.MinValue)
parameters.Add("secCategoryId", secCategoryId);
if (instrumentId != 0 && instrumentId != int.MinValue)
parameters.Add("instrumentId", instrumentId);
if (buySell != 0 && buySell != int.MinValue)
parameters.Add("buySell", buySell);
if (exchangeId != 0 && exchangeId != int.MinValue)
parameters.Add("exchangeId", exchangeId);
if (commCalcId != 0 && commCalcId != int.MinValue)
parameters.Add("commCalcId", commCalcId);
if (additionalCalcId != 0 && additionalCalcId != int.MinValue)
parameters.Add("additionalCalcId", additionalCalcId);
if (Util.IsNotNullDate(startDate))
parameters.Add("startDate", startDate);
if (Util.IsNotNullDate(endDate))
parameters.Add("endDate", endDate);
if (orderActionType != 0 && orderActionType != int.MinValue)
parameters.Add("orderActionTypeId", orderActionType);
if (applytoAllAccounts)
parameters.Add("applytoAllAccounts", true);
return session.GetTypedListByNamedQuery<ICommRule>(
"B4F.TotalGiro.Fees.CommRules.GetCommissionRules",
parameters);
}
public static IList<IInstrumentsHistoryConversion> GetInstrumentConversions(
IDalSession session, string isin, string instrumentName,
SecCategories secCategoryId, int currencyNominalId)
{
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 (secCategoryId != SecCategories.Undefined)
parameters.Add("secCategoryId", secCategoryId);
if (currencyNominalId > 0)
parameters.Add("currencyNominalId", currencyNominalId);
return session.GetTypedListByNamedQuery<IInstrumentsHistoryConversion>(
"B4F.TotalGiro.Instruments.History.GetInstrumentConversions",
parameters);
}
public static DataSet GetRoutedOrders(string isin, string instrumentName, SecCategories secCategoryId, int currencyNominalId)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
IExchange fundsettle = getExchange(session);
if (fundsettle == null)
throw new ApplicationException("Could not find exchange FundSettle.");
IRoute route = RouteMapper.GetRouteByExchange(session, fundsettle);
if (route == null)
throw new ApplicationException("Could not find exchange FundSettle.");
//"Key, TradedInstrument.DisplayName, DisplayTradedInstrumentIsin, Side, PlacedValue, PlacedValue.DisplayString, OpenValue,
//"OpenValue.DisplayString, DisplayIsSizeBased, Status, DisplayStatus, Route, CreationDate, OrderID, IsFsSendable");
return OrderMapper.GetOrders<IStgOrder>(session, OrderReturnClass.SecurityOrder, OrderAggregationLevel.Stichting, ApprovalState.Approved,
SecurityInfoOptions.TradingAcctOnly, ParentalState.Null, new OrderStatusFilter(OrderStatusFilterOptions.IncludeClosedStatiToday),
isin, instrumentName, secCategoryId, currencyNominalId, route.Key)
.Select(c => new
{
c.Key,
TradedInstrument_DisplayName = c.RequestedInstrument.DisplayName,
c.DisplayTradedInstrumentIsin,
c.Side,
c.PlacedValue,
PlacedValue_DisplayString = c.PlacedValue.DisplayString,
c.OpenValue,
OpenValue_DisplayString = c.OpenValue.DisplayString,
c.DisplayIsSizeBased,
c.Status,
c.DisplayStatus,
c.Route,
c.CreationDate,
c.OrderID,
IsFsSendable =
c.IsSecurity ? ((ISecurityOrder)c).IsFsSendable : false
})
.ToDataSet();
}
}
/// <summary>
/// Get Category by ID
/// </summary>
/// <param name="session">Data access object</param>
/// <param name="SecCategoryID">Identifier</param>
/// <returns>Category</returns>
public static SecCategory GetSecCategory(IDalSession session, SecCategories SecCategoryID)
{
return (SecCategory)session.GetObjectInstance(typeof(SecCategory), (int)SecCategoryID);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
elbErrorMessage.Text = "";
if (!IsPostBack)
{
Utility.DisablePageCaching();
Utility.AlertSaveMessage();
if (SecurityManager.IsCurrentUserInRole("Data Mtce: Instrument Edit"))
bntSave.Enabled = true;
SecCategory = (SecCategories)QueryStringModule.GetValueFromQueryString(Request.RawUrl, "SecCategory");
if (SecCategory != SecCategories.Undefined)
{
((EG)this.Master).setHeaderText = "Create New " + SecCategory.ToString() + " Derivative Master";
setDefault();
}
if (Session["DerivativeMasterID"] != null)
{
DerivativeMasterID = (int)Session["DerivativeMasterID"];
Session["DerivativeMasterID"] = null;
loadRecord(DerivativeMasterID);
((EG)this.Master).setHeaderText = "Edit Derivative Master";
}
}
}
catch (Exception ex)
{
elbErrorMessage.Text = Utility.GetCompleteExceptionMessage(ex) + "<br />";
}
}
public static DataSet GetDerivativeMasters(
SecCategoryFilterOptions secCategoryFilter, string isin, string instrumentName,
SecCategories secCategoryId, int exchangeId, int currencyNominalId)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
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);
IList<IDerivativeMaster> list = session.GetTypedListByNamedQuery<IDerivativeMaster>(
"B4F.TotalGiro.Instruments.Instrument.DerivativeMasters",
parameters);
return list.Select(l => new
{
l.Key,
UnderlyingName = l.Underlying.Name,
UnderlyingIsin = l.Underlying.Isin,
l.Name,
l.SecCategory,
ExchangeName = l.Exchange.ExchangeName,
NominalCurrency = l.CurrencyNominal.DisplayName,
Symbol = l.DerivativeSymbol
}).ToDataSet();
};
}
public static DataSet GetTradeableInstrumentsDDL(string isin, string instrumentName,
SecCategories secCategoryId, int exchangeId, int currencyNominalId)
{
return GetTradeableInstrumentsDDL(isin, instrumentName, secCategoryId, exchangeId, currencyNominalId, ActivityReturnFilter.All);
}
public static DataSet GetTradeableInstruments(string isin, string instrumentName,
SecCategories secCategoryId, int exchangeId, int currencyNominalId)
{
string hqlWhere = "or I.Key in (select C.Instrument.Key from CommRule C where C.AssetManager.Key = :managementCompanyID and C.Instrument is not null)";
string propertyList = "Key, DisplayIsinWithName";
DataSet ds = InstrumentFinderAdapter.GetTradeableInstruments(
SecCategoryFilterOptions.All, isin, instrumentName, secCategoryId,
exchangeId, currencyNominalId, ActivityReturnFilter.All, true, hqlWhere, propertyList);
Utility.AddEmptyFirstRow(ds.Tables[0]);
return ds;
}
public static DataSet GetSecurities(SecCategories secCategoryId)
{
DataSet ds = null;
if ((int)secCategoryId != int.MinValue && secCategoryId != SecCategories.Undefined)
{
IDalSession session = NHSessionFactory.CreateSession();
ds = InstrumentMapper.GetInstruments(session, secCategoryId)
.Select(c => new
{
c.Key,
c.DisplayName
}).OrderBy(o => o.DisplayName)
.ToDataSet();
Utility.AddEmptyFirstRow(ds.Tables[0]);
session.Close();
}
return ds;
}
public static DataSet GetUnAggregatedChildOrders(string isin, string instrumentName, SecCategories secCategoryId, int currencyNominalId)
{
//"Key, Account.Number, Account.ShortName, DisplayTradedInstrumentIsin, TradedInstrument.DisplayName, Side, Value, Value.DisplayString,
//"Commission, Commission.DisplayString, DisplayIsSizeBased, CreationDate");
using (IDalSession session = NHSessionFactory.CreateSession())
{
return OrderMapper.GetOrders<ISecurityOrder>(session, OrderReturnClass.SecurityOrder, OrderAggregationLevel.None, ApprovalState.Approved,
SecurityInfoOptions.ManagedsAcctsOnly, ParentalState.Null, new OrderStatusFilter(OrderStati.New),
isin, instrumentName, secCategoryId, currencyNominalId, null)
.Select(c => new
{
c.Key,
Account_Key = c.Account.Key,
Account_Number = c.Account.Number,
Account_ShortName = c.Account.ShortName,
c.DisplayTradedInstrumentIsin,
TradedInstrument_DisplayName = c.TradedInstrument.DisplayName,
c.Side,
c.Value,
Value_DisplayString = c.Value.DisplayString,
c.Commission,
Commission_DisplayString = (c.Commission != null ? c.Commission.DisplayString : ""),
c.DisplayIsSizeBased,
c.CreationDate
})
.ToDataSet();
}
}
/// <summary>
/// Get instrumenst by category
/// </summary>
/// <param name="session">Data access object</param>
/// <param name="secCategory">Category</param>
/// <returns>Collection of instruments</returns>
public static IList<IInstrument> GetInstruments(IDalSession session, SecCategories secCategoryId)
{
List<ICriterion> expressions = new List<ICriterion>();
expressions.Add(Expression.Eq("SecCategory.key", (int)secCategoryId));
return session.GetTypedList<Instrument, IInstrument>(expressions);
}
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;
}
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;
}
public static DataSet GetRoutedOrders(string isin, string instrumentName, SecCategories secCategoryId, int currencyNominalId)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
IRoute manDesk = RouteMapper.GetRouteByType(session, RouteTypes.ManualDesk);
if (manDesk == null)
throw new ApplicationException("Could not find the manual desk route.");
//"Key, TradedInstrument.DisplayName, DisplayTradedInstrumentIsin, Side, PlacedValue, PlacedValue.DisplayString, OpenValue,
//OpenValue.DisplayString, PlacedValue.NumberOfDecimals, DisplayIsSizeBased, Status, DisplayStatus, Route, CreationDate,
//IsUnApproveable, OrderID");
return OrderMapper.GetOrders<IStgOrder>(session, OrderReturnClass.SecurityOrder, OrderAggregationLevel.Stichting, ApprovalState.Approved,
SecurityInfoOptions.TradingAcctOnly, ParentalState.Null, new OrderStatusFilter(OrderStatusFilterOptions.IncludeClosedStatiToday),
isin, instrumentName, secCategoryId, currencyNominalId, manDesk.Key)
.Select(c => new
{
c.Key,
TradedInstrument_DisplayName = c.RequestedInstrument.DisplayName,
c.DisplayTradedInstrumentIsin,
c.Side,
c.PlacedValue,
PlacedValue_DisplayString = c.PlacedValue.DisplayString,
c.OpenValue,
OpenValue_DisplayString = c.OpenValue.DisplayString,
PlacedValue_NumberOfDecimals = c.PlacedValue.NumberOfDecimals,
c.DisplayIsSizeBased,
c.Status,
c.DisplayStatus,
c.Route,
c.CreationDate,
c.IsUnApproveable,
c.OrderID
})
.ToDataSet();
}
}
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 GetUnMappedInstruments(int assetManagerId, string isin, string instrumentName, SecCategories secCategoryId, int currencyNominalId)
{
DataSet ds = null;
IDalSession session = NHSessionFactory.CreateSession();
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 (secCategoryId > 0)
parameters.Add("secCategoryId", secCategoryId);
if (currencyNominalId > 0)
parameters.Add("currencyNominalId", currencyNominalId);
if (assetManagerId == 0)
{
IManagementCompany comp = LoginMapper.GetCurrentManagmentCompany(session);
if (comp == null || comp.IsStichting)
throw new ApplicationException("Not good");
else
assetManagerId = comp.Key;
}
parameters.Add("managementCompanyID", assetManagerId);
List<ITradeableInstrument> instruments = session.GetTypedListByNamedQuery<ITradeableInstrument>(
"B4F.TotalGiro.Instruments.Instrument.InstrumentsNotMappedByAssetManager",
parameters);
ds = DataSetBuilder.CreateDataSetFromBusinessObjectList(
instruments,
"Key, DisplayName, DisplayIsin, SecCategory.Name, HomeExchange.ExchangeName, CurrencyNominal.Name, InActiveDate");
session.Close();
return ds;
}
