public MainWindow(bool isAdmin)
{
///http://msdn.microsoft.com/en-us/library/aa969773.aspx messagebox info
///http://msdn.microsoft.com/en-us/library/bb386876.aspx OLE DB info
///http://msdn.microsoft.com/en-us/library/bb399398.aspx more OLE DB info
///http://msdn.microsoft.com/en-us/library/aa288452%28v=vs.71%29.aspx OLE DB tutorial from MS
/// http://www.codeproject.com/Tips/362436/Data-binding-in-WPF-DataGrid-control datagrid info and binding
///
InitializeComponent();
IsAdmin = isAdmin;
if (!isAdmin)
{
admin_tab.IsEnabled = false;
agencyRating_LBL.Visibility = Visibility.Hidden;
agencyRating_TB.Visibility = Visibility.Hidden;
newAgencyProfile_BTN.IsEnabled = false;
newAgencyProfile_BTN.Visibility = Visibility.Hidden;
}
else
{
CheckBirthdays(); // Birthday Tracker Alert only for the admin
}
DatabaseMethods dbMethods = new DatabaseMethods();
LoadUsers(users_DataGrid);
}
protected void btn_Deneme2_Click(object sender, ImageClickEventArgs e)
{
decimal basID = Convert.ToDecimal((sender as ImageButton).CommandArgument);
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
db.Delete("Delete from Yorum Where YorumId = " + basID + ";");
db.CloseConnection();
//Response.Redirect("GridViewDeneme.aspx");
GetComments();
}
DataTable GetComments()
{
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataTable dt = db.GetDataTable("Select * from Yorum");
GridViewComments.DataSource = dt;
GridViewComments.DataBind();
db.CloseConnection();
return dt;
}
protected void btn_Comment_Click(object sender, ImageClickEventArgs e)
{
string yorum = txt_Comment.Text;
string user_id = Session["User_id"].ToString();
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
db.Insert("Insert into Yorum (YorumIcerik , MakaleID , User_id , Tarih ) values ('" + yorum + "'," + makale_id + "," + user_id + ",GETDATE())");
txt_Comment.Text = "";
db.CloseConnection();
Response.Redirect("Blog.aspx?id="+makale_id+"&page="+Session["Comment_Page"].ToString());
}
DataTable MakaleOzetGetir(string category_id)
{
int category_id_int = int.Parse(category_id);
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataSet ds = db.GetDataset("SELECT m.MakaleId , m.Baslik , m.Tarih , m.Ozet , Count(y.MakaleID) as Yorum_Count FROM Makale m LEFT JOIN Yorum y ON m.MakaleId = y.MakaleID WHERE m.KategoriID = " + category_id_int + " GROUP BY m.MakaleId , Baslik , m.Tarih , Ozet ORDER BY m.Tarih DESC");
rptMakaleOzet_Category.DataSource = ds.Tables[0];
rptMakaleOzet_Category.DataBind();
db.CloseConnection();
return ds.Tables[0];
}
DataTable MakaleOzetGetir(string tag_id)
{
int tag_id_int = int.Parse(tag_id);
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataSet ds = db.GetDataset("SELECT m.MakaleId , m.Baslik , m.Tarih , m.Ozet , Count(y.MakaleID) as Yorum_Count , e.EtiketAd FROM Makale m LEFT JOIN Yorum y ON m.MakaleId = y.MakaleID , Etiket e , MakaleEtiket me WHERE m.MakaleId = me.MakaleId AND me.EtiketId = e.EtiketId AND e.EtiketId = " + tag_id_int +" GROUP BY m.MakaleID , Baslik , m.Tarih , Ozet , e.EtiketAd ORDER BY m.Tarih DESC");
rptMakaleOzet_Tag.DataSource = ds.Tables[0];
rptMakaleOzet_Tag.DataBind();
db.CloseConnection();
return ds.Tables[0];
}
protected void btn_Submit_Click(object sender, ImageClickEventArgs e)
{
db = new DatabaseMethods();
int a = db.InsertWithLastId("Insert into Makale (Baslik , Tarih , Icerik , KategoriID , Ozet) values ( '" + txt_Title.Text + "' , GETDATE() , '" + txt_main.Text + "' , " + ddl_Category.SelectedItem.Value + " , '" + txt_abstract.Text + "'); SELECT SCOPE_IDENTITY() as LastInsertedId;");
foreach (ListItem item in lb_Selected.Items)
{
db.Insert("Insert into MakaleEtiket values(" + a + "," + item.Value + ")");
}
//Response.Redirect("Admin.aspx");
db.CloseConnection();
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session["Admin"] != null)
{
if (Convert.ToBoolean(Session["Admin"]))
{
if (!Page.IsPostBack)
{
if (lb_Tags.Items.Count == 0)
{
db = new DatabaseMethods();
DataSet ds = db.GetDataset("Select * From Etiket");
lb_Tags.DataSource = ds;
lb_Tags.DataTextField = "EtiketAd";
lb_Tags.DataValueField = "EtiketId";
lb_Tags.DataBind();
ds.Clear();
ds.Dispose();
ds = db.GetDataset("Select KategoriID , KategoriAd From Kategori");
ddl_Category.DataSource = ds;
ddl_Category.DataTextField = "KategoriAd";
ddl_Category.DataValueField = "KategoriID";
ddl_Category.DataBind();
ds.Clear();
ds.Dispose();
}
}
}
else
{
Response.Redirect("WebForm1.aspx");
}
}
else
{
Response.Redirect("WebForm1.aspx");
}
}
private async Task <string> GetProfileImageAsync()
{
return(await DatabaseMethods.GetProfileImage());
}
void GetContent(String id)
{
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataTable dt = db.GetDataTable("Select * from Makale Where MakaleId =" + makale_id);
rpt_Makale.DataSource = dt;
rpt_Makale.DataBind();
db.CloseConnection();
}
void GetTags(String id)
{
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataTable dt = db.GetDataTable("SELECT e.EtiketAd FROM Makale m , MakaleEtiket me , Etiket e WHERE me.MakaleId = m.MakaleId AND me.EtiketId = e.EtiketId AND m.MakaleId = " + makale_id);
dl_Tags.DataSource = dt;
dl_Tags.DataBind();
db.CloseConnection();
}
public static void PlaceNewSingleOrder(Guid clientKey, Guid requesterOrderID, int clientID, string custodyID, string securityID,
string orderSide, double price, int quantity, string orderType, DateTime placementDateTime, string timeInForce,
CurrencyItem currency, string exchangeID, DateTime orderCreatedBySysDateTime, string groupID,
string marketID, HandleInstruction handleInst, DateTime expiryDate, Dictionary <string, object> optionalParam)
{
long orderID = -1;
try
{
// Get Currency
LookupItem currencyLookup = Lookups.GetCurrencyLookupByCurrencyCode(currency.Code);
// Get Destination Type
LookupItem exchangeLookup = Lookups.GetExchangeDestinationByExchangeID(exchangeID);
// order Type
LookupItem orderTypeLookup = Lookups.GetOrderTypeLookupByCodeValue(orderType);
// Order Side
LookupItem orderSideLookup = Lookups.GetOrderSidesLookupByCodeValue(orderSide);
// Time In Force
LookupItem timeInForceLookup = Lookups.GetTimeInForceLookupByCode(timeInForce);
// Handle Instruction
string handleValue = Enum.GetName(typeof(HandleInstruction), handleInst);
LookupItem handleInstLookup = Lookups.GetHandleInstTypeLookupByCodeValue(handleValue);
bool hasAON = false;
int minQ = 0;
if (optionalParam != null)
{
if (optionalParam.ContainsKey("AON") && (bool)optionalParam["AON"])
{
hasAON = true;
}
}
if (hasAON)// MinQty must be existed if AON = true as it's already been validated before
{
minQ = (int)optionalParam["MinQty"];
}
using (System.Transactions.TransactionScope ts = new System.Transactions.TransactionScope())
{
DatabaseMethods db = new DatabaseMethods();
//orderID = db.AddNewSingleOrder(clientKey, requesterOrderID, null, null, clientID, custodyID, securityID, orderSide,
//price, price, price, quantity, orderType, placementDateTime, ORD_STATUS.PendingNew, ORD_STATUS.PendingNew, "", false, "", timeInForce);
Dictionary <string, object> data = new Dictionary <string, object>();
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.CurrencyID).ColumnName, currency.ID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.GroupID).ColumnName, groupID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.MarketID).ColumnName, marketID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ExchangeID).ColumnName, exchangeID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.RequesterOrderID).ColumnName, requesterOrderID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ClientID).ColumnName, clientID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.CustodyID).ColumnName, custodyID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.SecurityCode).ColumnName, securityID);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderSide).ColumnName, orderSide);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.CurrentPrice).ColumnName, price);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalPrice).ColumnName, price);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.PlacementDateTime).ColumnName, placementDateTime);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalQuantity).ColumnName, quantity);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.RemainingQuantity).ColumnName, 0);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ExecutedQuantity).ColumnName, 0);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.LastExecQuantity).ColumnName, 0);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.LastExecPrice).ColumnName, 0);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.AvgPrice).ColumnName, 0);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.CurrentQuantity).ColumnName, quantity);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalOrderType).ColumnName, orderType);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderType).ColumnName, orderType);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderStatus).ColumnName, ORD_STATUS.PendingNew);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalOrderStatus).ColumnName, ORD_STATUS.PendingNew);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ExecType).ColumnName, EXEC_TYP.PendingNew);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderCreatedBySysDateTime).ColumnName, orderCreatedBySysDateTime);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderRecievedDateTime).ColumnName, DateTime.Now);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ModifiedDateTime).ColumnName, DateTime.Now);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.Note).ColumnName, "awaiting for acceptance response");
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.IsPending).ColumnName, true);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.IsActive).ColumnName, false);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.IsExecuted).ColumnName, false);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.IsCompleted).ColumnName, false);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.HasSystemError).ColumnName, false);
//data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ErrorMessage).ColumnName, string.Empty);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalTimeInForce).ColumnName, timeInForce);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.TimeInForce).ColumnName, timeInForce);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalHandleInst).ColumnName, handleValue);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.HandleInst).ColumnName, handleValue);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ExpirationDate).ColumnName, expiryDate.ToShortDateString());
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ExpirationDateTime).ColumnName, expiryDate);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.AON).ColumnName, hasAON);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalAON).ColumnName, hasAON);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OriginalMinQty).ColumnName, minQ);
data.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.MinQty).ColumnName, minQ);
Dictionary <string, object> dataDetails = new Dictionary <string, object>();
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.CurrentPrice).ColumnName, price);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.CurrentQuantity).ColumnName, quantity);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RemainingQuantity).ColumnName, quantity);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecutedQuantity).ColumnName, 0);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.AvgPrice).ColumnName, 0);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecPrice).ColumnName, 0);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.LastExecQuantity).ColumnName, 0);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderType).ColumnName, orderType);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderStatus).ColumnName, ORD_STATUS.PendingNew);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecType).ColumnName, EXEC_TYP.PendingNew);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.DateTime).ColumnName, DateTime.Now);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.Note).ColumnName, "New Order");
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.HasSystemError).ColumnName, false);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ErrorMessage).ColumnName, string.Empty);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.TimeInForce).ColumnName, timeInForce);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.IsNewOrderRequest).ColumnName, true);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.IsUserRequest).ColumnName, true);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.HandleInst).ColumnName, handleValue);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.AON).ColumnName, hasAON);
dataDetails.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.MinQty).ColumnName, minQ);
//orderID = db.AddNewSingleOrder(clientKey, data, dataDetails);
string clOrderID = string.Format("{0}-{1}", orderID.ToString(), "1");
SingleOrder order = new SingleOrder();
order.Data[SingleOrderProperties.OrderID] = orderID;
order.Data[SingleOrderProperties.ClOrderID] = clOrderID;
order.Data[SingleOrderProperties.GroupID] = groupID;
order.Data[SingleOrderProperties.MarketID] = marketID;
order.Data[SingleOrderProperties.ExchangeID] = exchangeID;
order.Data[SingleOrderProperties.CurrencyID] = currency.ID;
order.Data[SingleOrderProperties.RequesterOrderID] = requesterOrderID;
order.Data[SingleOrderProperties.ClientID] = clientID;
order.Data[SingleOrderProperties.CustodyID] = custodyID;
order.Data[SingleOrderProperties.SecurityCode] = securityID;
order.Data[SingleOrderProperties.OrderSide] = orderSide;
order.Data[SingleOrderProperties.IsActive] = false;
order.Data[SingleOrderProperties.IsPending] = true;
order.Data[SingleOrderProperties.IsCompleted] = false;
order.Data[SingleOrderProperties.IsExecuted] = false;
order.Data[SingleOrderProperties.CurrentPrice] = price;
order.Data[SingleOrderProperties.OriginalPrice] = price;
order.Data[SingleOrderProperties.AvgPrice] = 0;
order.Data[SingleOrderProperties.LastExecPrice] = 0;
order.Data[SingleOrderProperties.OriginalQuantity] = quantity;
order.Data[SingleOrderProperties.RemainingQuantity] = 0;
order.Data[SingleOrderProperties.ExecutedQuantity] = 0;
order.Data[SingleOrderProperties.LastExecQuantity] = 0;
order.Data[SingleOrderProperties.CurrentQuantity] = quantity;
order.Data[SingleOrderProperties.OriginalOrderType] = orderType;
order.Data[SingleOrderProperties.OrderType] = orderType;
order.Data[SingleOrderProperties.OrderStatus] = ORD_STATUS.PendingNew;
order.Data[SingleOrderProperties.OriginalOrderStatus] = ORD_STATUS.PendingNew;
order.Data[SingleOrderProperties.ExecType] = EXEC_TYP.PendingNew;
order.Data[SingleOrderProperties.OriginalTimeInForce] = timeInForce;
order.Data[SingleOrderProperties.TimeInForce] = timeInForce;
order.Data[SingleOrderProperties.OriginalHandleInst] = handleValue;
order.Data[SingleOrderProperties.HandleInst] = handleValue;
order.Data[SingleOrderProperties.AON] = hasAON;
order.Data[SingleOrderProperties.MinQty] = minQ;
order.Data[SingleOrderProperties.OriginalAON] = hasAON;
order.Data[SingleOrderProperties.OriginalMinQty] = minQ;
order.Data[SingleOrderProperties.PlacementDateTime] = placementDateTime;
order.Data[SingleOrderProperties.OrderCreatedBySysDateTime] = orderCreatedBySysDateTime;
order.Data[SingleOrderProperties.OrderRecievedDateTime] = DateTime.Now;
order.Data[SingleOrderProperties.ModifiedDateTime] = DateTime.Now;
order.Data[SingleOrderProperties.Note] = "Awaiting For Acceptance Response";
order.Data[SingleOrderProperties.HasSystemError] = false;
// lock only shared entities as each method create its only copy of variable except shared entities
lock (m_syncObject)
{
if (!m_sessionKey_ReqOrdIDs.ContainsKey(clientKey))
{
m_sessionKey_ReqOrdIDs.Add(clientKey, new List <Guid>());
}
m_sessionKey_ReqOrdIDs[clientKey].Add((Guid)order.Data[SingleOrderProperties.RequesterOrderID]);
m_ReqOrdID_OrdID.Add((Guid)order.Data[SingleOrderProperties.RequesterOrderID], (long)order.Data[SingleOrderProperties.OrderID]);
m_orderID_ordersDetails.Add((long)order.Data[SingleOrderProperties.OrderID], order);
m_OrdID_sessionKey.Add(orderID, clientKey);
//if (!m_ReqOrdID_subIDs.ContainsKey((Guid)order.Data[SingleOrderProperties.RequesterOrderID]))
//{
// m_ReqOrdID_subIDs.Add((Guid)order.Data[SingleOrderProperties.RequesterOrderID], new List<Guid>());
//}
//m_ReqOrdID_subIDs[(Guid)order.Data[SingleOrderProperties.RequesterOrderID]].Add(clientKey);
}
FixGatewayManager.PlaceNewSingleOrder(clOrderID, clientID.ToString(), securityID, quantity, price, custodyID, orderSideLookup.FixValue.ToCharArray()[0], orderTypeLookup.FixValue.ToCharArray()[0], currencyLookup.FixValue, exchangeLookup.FixValue, timeInForceLookup.FixValue.ToCharArray()[0], groupID, handleInstLookup.FixValue.ToCharArray()[0], expiryDate, hasAON, minQ);
ts.Complete();
db = null;
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error placing order, ClientKey {0}, Req Order ID {1}, Error: {2}", clientKey, requesterOrderID, ex.Message), ConsoleColor.Red, ConsoleColor.White, false);
if (orderID > -1)
{
RemoveOrderRef(orderID);
}
try
{
// Sessions.Push(new IResponseMessage[] { new Fix_OrderRefusedByService() { ClientKey = clientKey, RefuseMessage = "System Erorr", RequesterOrderID = requesterOrderID } });
}
catch (Exception inEx)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error sending refused order to the client while placing order, ClientKey {0}, Req Order ID {1}, Error: {2}", clientKey, requesterOrderID, inEx.Message), ConsoleColor.Red, ConsoleColor.White, false);
}
}
}
public void Handle(QuickFix.Message msg)
{
long orderID = -1;
// check message type tag, if execution report then push execution report update
QuickFix.MsgType msgType = new QuickFix.MsgType();
string msgTypeString = msg.getHeader().getField(m_msgTypeTag);
if (msgTypeString == m_MsgTypeTagValueToHandle)
{
Counters.IncrementCounter(CountersConstants.OrderCancelRejectRspMsgs);
//SystemLogger.WriteOnConsole(true, string.Format("new message recieved, Type: {0}, Message: '{1}'", msgTypeString, msg.ToXML()), ConsoleColor.Cyan, ConsoleColor.Black, false);
SingleOrder order = null;
// get order id
if (msg.isSetField(11))
{
orderID = long.Parse(msg.getField(11).Split(new char[] { '-' })[0]);
try
{
order = OrdersManager.GetOrder(orderID);
}
catch (Exception ex) // order not found
{
// get borse order id
string bourseOrderID = msg.getField(37);
order = OrdersManager.GetOrder(bourseOrderID);
if (order == null)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("order BourseOrderID {0} not found !", bourseOrderID), ConsoleColor.Red, ConsoleColor.Black, true);
return;
}
}
} // then search by borse order id
else if (msg.isSetField(37))
{
string bourseOrderID = msg.getField(37);
order = OrdersManager.GetOrder(bourseOrderID);
if (order == null)
{
SystemLogger.WriteOnConsoleAsync(true, string.Format("order BourseOrderID {0} not found !", bourseOrderID), ConsoleColor.Red, ConsoleColor.Black, true);
return;
}
}
lock (order)
{
string reason = string.Empty;
if (msg.isSetField(102))
{
try
{
reason = Lookups.GetOrderCancelRejectReasonsLookup(msg.getField(102)).MessageEn + " ,";
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error getting order cancel reject reason: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, false);
}
}
if (msg.isSetField(58))
{
reason += msg.getField(58) + " ";
}
Nullable <DateTime> transactionDateTime = null;
if (msg.isSetField(60))
{
transactionDateTime = msg.getUtcTimeStamp(60);
}
LookupItem statusLookup = Lookups.GetOrderStatusLookup(msg.getField(39));
string status = statusLookup.CodeValue;
Guid requesterOrderID = (Guid)order[SingleOrderProperties.RequesterOrderID];
// find subscribed callbacks
//order[SingleOrderProperties.OrderStatus] = status;
bool isPendingCancel = false;
bool isPendingReplace = false;
string orderNote = string.Empty;
if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingCancel)
{
isPendingCancel = true;
orderNote = "Order cancel has been refused by bourse: " + reason;
}
else if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingReplace)
{
// handle diff allocation cancellation
isPendingReplace = true;
orderNote = "Order replace has been refused by bourse: " + reason;
#region Handle Mcsd Reset Allocation
try
{
if (order[SingleOrderProperties.IsMcsdAllocRequired] != null)
{
if (Convert.ToBoolean(order[SingleOrderProperties.IsMcsdAllocRequired]) == true)
{
order[SingleOrderProperties.ActionOnAllocResponse] = ActionOnAllocResponse.DoNothing;
int mcsdQty = Convert.ToInt32(order[SingleOrderProperties.McsdrAllocQty]);
// orderid = Convert.ToInt64(order[SingleOrderProperties.OrderID]);
OrdersManager.HandleRejectedOrderAllocation(orderID, mcsdQty);
}
}
}
catch (Exception exp)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.LogErrorAsync(string.Format("Error, Reset MCSD allocation of Order {0}, Error : {1}", orderID, exp.ToString()));
}
#endregion
}
else
{
orderNote = "Order cancel/replace has been refused by bourse: " + reason;
}
// create IResponseMessage
string username = OrdersManager.GetOrdSessionIfAvailable((long)order[SingleOrderProperties.OrderID]);
if (username != null)
{
try
{
if (isPendingCancel)
{
Sessions.Push(username, new IResponseMessage[] { new Fix_OrderCancelRejected()
{
Message = reason, RequesterOrderID = requesterOrderID, OrderStatus = order[SingleOrderProperties.OriginalOrderStatus].ToString()
} });
}
else if (isPendingReplace)
{
Sessions.Push(username, new IResponseMessage[] { new Fix_OrderReplaceRejected()
{
Message = reason, RequesterOrderID = requesterOrderID, OrderStatus = order[SingleOrderProperties.OriginalOrderStatus].ToString()
} });
}
else
{
Sessions.Push(username, new IResponseMessage[] { new Fix_OrderReplaceCancelReject()
{
Message = reason, RequesterOrderID = requesterOrderID, OrderStatus = order[SingleOrderProperties.OriginalOrderStatus].ToString()
} });
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("error sending order cancel reject to clients: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
// update databse
try
{
DatabaseMethods db = new DatabaseMethods();
order[SingleOrderProperties.OrderStatus] = order[SingleOrderProperties.OriginalOrderStatus];
order[SingleOrderProperties.IsPending] = false;
order[SingleOrderProperties.Note] =
order[SingleOrderProperties.Note2] = "Action Status: " + status;
order[SingleOrderProperties.ModifiedDateTime] = transactionDateTime == null ? DateTime.Now : transactionDateTime;
Dictionary <string, object> orders_Columns = new Dictionary <string, object>();
orders_Columns.Add(SingleOrderProperties.OrderStatus, order[SingleOrderProperties.OriginalOrderStatus]);
orders_Columns.Add(SingleOrderProperties.Note, order[SingleOrderProperties.Note]);
orders_Columns.Add(SingleOrderProperties.Note2, order[SingleOrderProperties.Note2]);
orders_Columns.Add(SingleOrderProperties.ActionOnAllocResponse, ActionOnAllocResponse.DoNothing);
orders_Columns.Add(SingleOrderProperties.ModifiedDateTime, transactionDateTime == null ? DateTime.Now : transactionDateTime);
orders_Columns.Add(SingleOrderProperties.IsPending, false);
Dictionary <string, object> orders_Filters = new Dictionary <string, object>();
orders_Filters.Add(SingleOrderProperties.OrderID, order[SingleOrderProperties.OrderID]);
Dictionary <string, object> ordersDetails_Columns = new Dictionary <string, object>();
ordersDetails_Columns.Add(SingleOrdDetailsProps.OrderID, order[SingleOrderProperties.OrderID]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ClOrderID, order[SingleOrderProperties.ClOrderID]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.OrigClOrdID, order[SingleOrderProperties.OrigClOrdID]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutionMsgType, msgTypeString);
ordersDetails_Columns.Add(SingleOrdDetailsProps.AvgPrice, order[SingleOrderProperties.AvgPrice]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.CurrentPrice, order[SingleOrderProperties.CurrentPrice]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecPrice, order[SingleOrderProperties.LastExecPrice]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.CurrentQuantity, order[SingleOrderProperties.CurrentQuantity]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutedQuantity, order[SingleOrderProperties.ExecutedQuantity]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.LastExecQuantity, order[SingleOrderProperties.LastExecQuantity]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.RemainingQuantity, order[SingleOrderProperties.RemainingQuantity]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecType, order[SingleOrderProperties.ExecType]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.OrderStatus, order[SingleOrderProperties.OrderStatus]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.Note, order[SingleOrderProperties.Note]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.OrderType, order[SingleOrderProperties.OrderType]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.TimeInForce, order[SingleOrderProperties.TimeInForce]);
ordersDetails_Columns.Add(SingleOrdDetailsProps.IsResponse, true);
if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingCancel)
{
ordersDetails_Columns.Add(SingleOrdDetailsProps.IsCancelResponse, true);
}
else if (order[SingleOrderProperties.OrderStatus].ToString() == ORD_STATUS.PendingReplace)
{
ordersDetails_Columns.Add(SingleOrdDetailsProps.IsModifyResponse, true);
}
else
{
ordersDetails_Columns.Add(SingleOrdDetailsProps.IsModifyResponse, true);
ordersDetails_Columns.Add(SingleOrdDetailsProps.IsCancelResponse, true);
}
ordersDetails_Columns.Add(SingleOrdDetailsProps.DateTime, DateTime.Now);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutionDate, transactionDateTime == null ? DateTime.Now : transactionDateTime);
ordersDetails_Columns.Add(SingleOrdDetailsProps.ExecutionRecievedDateTime, DateTime.Now);
db.UpdateOrderDetails(orders_Columns, orders_Filters, ordersDetails_Columns);
db = null;
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("error updating order cancel reject into the db error: {0}", ex.Message), ConsoleColor.Red, ConsoleColor.Black, true);
}
}
}
}
internal static void ModifyOrder(Guid clientKey, Guid requesterOrderID, long orderID, int quantity, double price, string orderType, string timeInForce, Dictionary <string, object> optionalParam)
{
try
{
SingleOrder order = m_orderID_ordersDetails[orderID];
string[] arr = order.Data[SingleOrderProperties.ClOrderID].ToString().Split(new char[] { '-' });
string ordID = arr[0];
int changeID = int.Parse(arr[1]);
changeID++;
//string newOrigClOrdID = order.ClOrderID;
string newClOrdID = string.Format("{0}-{1}", ordID, changeID);
bool hasAON = false;
int minQ = 0;
if (optionalParam != null)
{
if (optionalParam.ContainsKey("AON") && (bool)optionalParam["AON"])
{
hasAON = true;
}
}
if (hasAON)
{
minQ = (int)optionalParam["MinQty"];
}
using (System.Transactions.TransactionScope ts = new System.Transactions.TransactionScope())
{
DatabaseMethods db = new DatabaseMethods();
/////db.UpdateOrderDetails(order.OrderID, newClOrdID, order.OrigClOrdID, quantity, quantity - order.ExecutedQuantity, order.ExecutedQuantity, order.CurrentPrice, order.CurrentPrice, order.CurrentPrice, order.OrderType, order.OrderStatus, order.ExecType, DateTime.Now, "Modify Order Request", false, "", timeInForce == string.Empty ? order.TimeInForce : timeInForce, null);
order.Data[SingleOrderProperties.ClOrderID] = newClOrdID;
order.Data[SingleOrderProperties.IsPending] = true;
order.Data[SingleOrderProperties.Note] = "Pending Modify Request";
order.Data[SingleOrderProperties.ModifiedDateTime] = DateTime.Now;
Dictionary <string, object> orders_Columns = new Dictionary <string, object>();
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ClOrderID).ColumnName, order.Data[SingleOrderProperties.ClOrderID]);
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.IsPending).ColumnName, true);
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.Note).ColumnName, order.Data[SingleOrderProperties.Note]);
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ModifiedDateTime).ColumnName, order.Data[SingleOrderProperties.ModifiedDateTime]);
Dictionary <string, object> orders_Filters = new Dictionary <string, object>();
orders_Filters.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderID).ColumnName, order.Data[SingleOrderProperties.OrderID]);
Dictionary <string, object> ordersDetails_Columns = new Dictionary <string, object>();
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderID).ColumnName, order.Data[SingleOrderProperties.OrderID]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ClOrderID).ColumnName, order.Data[SingleOrderProperties.ClOrderID]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrigClOrdID).ColumnName, order.Data[SingleOrderProperties.OrigClOrdID]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.AvgPrice).ColumnName, order.Data[SingleOrderProperties.AvgPrice]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.CurrentPrice).ColumnName, order.Data[SingleOrderProperties.CurrentPrice]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecPrice).ColumnName, order.Data[SingleOrderProperties.LastExecPrice]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RequestedPrice).ColumnName, price);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.CurrentQuantity).ColumnName, order.Data[SingleOrderProperties.CurrentQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecutedQuantity).ColumnName, order.Data[SingleOrderProperties.ExecutedQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.LastExecQuantity).ColumnName, order.Data[SingleOrderProperties.LastExecQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RemainingQuantity).ColumnName, order.Data[SingleOrderProperties.RemainingQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RequestedQuantity).ColumnName, quantity);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.AON).ColumnName, hasAON);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RequestedMinQty).ColumnName, minQ);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecType).ColumnName, order.Data[SingleOrderProperties.ExecType]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderStatus).ColumnName, order.Data[SingleOrderProperties.OrderStatus]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.Note).ColumnName, order.Data[SingleOrderProperties.Note]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.IsModifyRequest).ColumnName, true);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.IsUserRequest).ColumnName, true);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.DateTime).ColumnName, DateTime.Now);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderType).ColumnName, order.Data[SingleOrderProperties.OrderType]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RequestedOrderType).ColumnName, orderType);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.TimeInForce).ColumnName, order.Data[SingleOrderProperties.TimeInForce]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RequestedTimeInForce).ColumnName, timeInForce);
db.UpdateOrderDetails(orders_Columns, orders_Filters, ordersDetails_Columns);
FixGatewayManager.ModifyCancelOrder(order.Data[SingleOrderProperties.ClientID].ToString(), order.Data[SingleOrderProperties.SecurityCode].ToString(), string.Format("{0}-{1}", ordID, changeID), order.Data[SingleOrderProperties.OrigClOrdID].ToString(), quantity, price, Lookups.GetTimeInForceLookupByCodeValue(timeInForce).FixValue.ToCharArray()[0], Lookups.GetOrderTypeLookupByCodeValue(orderType).FixValue.ToCharArray()[0], Lookups.GetOrderSidesLookupByCodeValue(order.Data[SingleOrderProperties.OrderSide].ToString()).FixValue.ToCharArray()[0], hasAON, minQ);
ts.Complete();
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error modify order, ClientKey {0}, Error: {1}", clientKey, ex.Message), ConsoleColor.Red, ConsoleColor.White, false);
try
{
// Sessions.Push(new IResponseMessage[] { new Fix_OrderReplaceRefusedByService() { ClientKey = clientKey, RefuseReason = "System Error", RequesterOrderID = requesterOrderID } });
}
catch (Exception inex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error sending refused order modification to the client, ClientKey {0}, Error: {1}", clientKey, inex.Message), ConsoleColor.Red, ConsoleColor.White, false);
}
}
}
internal static void CancelOrder(Guid clientKey, Guid requesterOrderID, long orderID)
{
try
{
// Order Side
SingleOrder order = m_orderID_ordersDetails[orderID];
LookupItem orderSideLookup = Lookups.GetOrderSidesLookupByCodeValue(order.Data[SingleOrderProperties.OrderSide].ToString());
lock (order)
{
string[] arr = order.Data[SingleOrderProperties.ClOrderID].ToString().Split(new char[] { '-' });
string ordID = arr[0];
int changeID = int.Parse(arr[1]);
changeID++;
//string newOrigClOrdID = order.ClOrderID;
string newClOrdID = string.Format("{0}-{1}", ordID, changeID);
using (System.Transactions.TransactionScope ts = new System.Transactions.TransactionScope())
{
DatabaseMethods db = new DatabaseMethods();
//db.UpdateOrderDetails(order.OrderID, newClOrdID, order.OrigClOrdID, order.CurrentQuantity, order.RemainingQuantity, order.ExecutedQuantity, order.CurrentPrice, order.CurrentPrice, order.CurrentPrice, order.OrderType, order.OrderStatus, order.ExecType, DateTime.Now, "Cancel Order Request", false, "", order.TimeInForce, null);
order.Data[SingleOrderProperties.ClOrderID] = newClOrdID;
order.Data[SingleOrderProperties.IsPending] = true;
order.Data[SingleOrderProperties.Note] = "Pending Cancel Request";
order.Data[SingleOrderProperties.ModifiedDateTime] = DateTime.Now;
Dictionary <string, object> orders_Columns = new Dictionary <string, object>();
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ClOrderID).ColumnName, order.Data[SingleOrderProperties.ClOrderID]);
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.IsPending).ColumnName, true);
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.Note).ColumnName, order.Data[SingleOrderProperties.Note]);
orders_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.ModifiedDateTime).ColumnName, order.Data[SingleOrderProperties.ModifiedDateTime]);
Dictionary <string, object> orders_Filters = new Dictionary <string, object>();
orders_Filters.Add(PropColMapper.GetColumnByProperty(SingleOrderProperties.TableName, SingleOrderProperties.OrderID).ColumnName, order.Data[SingleOrderProperties.OrderID]);
Dictionary <string, object> ordersDetails_Columns = new Dictionary <string, object>();
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderID).ColumnName, order.Data[SingleOrderProperties.OrderID]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ClOrderID).ColumnName, order.Data[SingleOrderProperties.ClOrderID]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrigClOrdID).ColumnName, order.Data[SingleOrderProperties.OrigClOrdID]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.AvgPrice).ColumnName, order.Data[SingleOrderProperties.AvgPrice]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.CurrentPrice).ColumnName, order.Data[SingleOrderProperties.CurrentPrice]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecPrice).ColumnName, order.Data[SingleOrderProperties.LastExecPrice]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.CurrentQuantity).ColumnName, order.Data[SingleOrderProperties.CurrentQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecutedQuantity).ColumnName, order.Data[SingleOrderProperties.ExecutedQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.LastExecQuantity).ColumnName, order.Data[SingleOrderProperties.LastExecQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.RemainingQuantity).ColumnName, order.Data[SingleOrderProperties.RemainingQuantity]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.DateTime).ColumnName, DateTime.Now);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.ExecType).ColumnName, order.Data[SingleOrderProperties.ExecType]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderStatus).ColumnName, order.Data[SingleOrderProperties.OrderStatus]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.Note).ColumnName, order.Data[SingleOrderProperties.Note]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.IsCancelRequest).ColumnName, true);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.IsUserRequest).ColumnName, true);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.OrderType).ColumnName, order.Data[SingleOrderProperties.OrderType]);
ordersDetails_Columns.Add(PropColMapper.GetColumnByProperty(SingleOrdDetailsProps.TableName, SingleOrdDetailsProps.TimeInForce).ColumnName, order.Data[SingleOrderProperties.TimeInForce]);
db.UpdateOrderDetails(orders_Columns, orders_Filters, ordersDetails_Columns);
FixGatewayManager.CancelOrder(order.Data[SingleOrderProperties.ClientID].ToString(), order.Data[SingleOrderProperties.SecurityCode].ToString(), string.Format("{0}-{1}", ordID, changeID), order.Data[SingleOrderProperties.OrigClOrdID].ToString(), orderSideLookup.FixValue.ToCharArray()[0]);
ts.Complete();
}
}
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error modify order, ClientKey {0}, Error: {1}", clientKey, ex.Message), ConsoleColor.Red, ConsoleColor.White, false);
try
{
// Sessions.Push(new IResponseMessage[] { new Fix_OrderReplaceRefusedByService() { ClientKey = clientKey, RefuseReason = "System Error", RequesterOrderID = requesterOrderID } });
}
catch (Exception inex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error sending refused order modification to the client, ClientKey {0}, Error: {1}", clientKey, inex.Message), ConsoleColor.Red, ConsoleColor.White, false);
}
}
}
public void Execute(UIApplication uiapp)
{
try
{
UIDocument uidoc = uiapp.ActiveUIDocument;
Document doc = uidoc.Document; // myListView_ALL_Fam_Master.Items.Add(doc.GetElement(uidoc.Selection.GetElementIds().First()).Name);
if (uidoc.Selection.GetElementIds().Count != 1)
{
MessageBox.Show("Please select ONE Wall.");
return;
}
Element myElementWall = doc.GetElement(uidoc.Selection.GetElementIds().First());
if (myElementWall.GetType() == typeof(FamilyInstance))
{
FamilyInstance myFamilyInstance = myElementWall as FamilyInstance;
myElementWall = myFamilyInstance.Host;
if (myElementWall == null)
{
MessageBox.Show("Family instance must be hosted to a wall.");
return;
}
}
/// TECHNIQUE 08 OF 19 (EE08_MoveElementAroundHostingSurface.cs)
///↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ MOVING ELEMENTS AROUND A HOSTING SURFACE ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
/// The people walk around the perimeter of the wall, and it will work on any surface
///
///
/// Interfaces and ENUM's:
///
///
/// Demonstrates classes:
/// Reference
/// Face
/// Transform
/// PlanarFace
/// CurveLoop
///
///
/// Key methods:
/// myElementWall.GetGeometryObjectFromReference(pickedRef) as Face
/// pickedRef.ConvertToStableRepresentation(doc).Contains("INSTANCE"))
/// (myElementWall as FamilyInstance).GetTotalTransform();
/// myFace.GetBoundingBox().Min
/// myFace.Evaluate(myUV_Min)
///
/// myXYZ_FamilyTransform.OfPoint(myXYZ_CornerOne)
/// myXYZ_FamilyTransform.OfVector(myPlanarFace.XVector);
/// myCurveLoop.GetExactLength();
///
///
/// L1.GetEndPoint(0)).Normalize().Multiply(myDouble_ThisFarAlong);
/// ElementTransformUtils.MoveElement(doc, myFamilyInstance.Id, myXYZ_MoveThisMuch);
///
/// * class is actually part of the .NET framework (not Revit API)
///
///
///
/// https://github.com/joshnewzealand/Revit-API-Playpen-CSharp
List <Element> myListOfStuffOnWall = new FilteredElementCollector(doc).OfClass(typeof(FamilyInstance)).OfCategory(BuiltInCategory.OST_GenericModel).Where(x => (((FamilyInstance)x).Host != null)).Where(x => ((FamilyInstance)x).Host.Id == myElementWall.Id).ToList();
List <Element> myListOfFurniture = new FilteredElementCollector(doc).OfClass(typeof(FamilyInstance)).OfCategory(BuiltInCategory.OST_Furniture).Where(x => (((FamilyInstance)x).Host != null)).Where(x => ((FamilyInstance)x).Host.Id == myElementWall.Id).ToList();
myListOfStuffOnWall.AddRange(myListOfFurniture);
if (myListOfStuffOnWall.Count() > 0)
{
using (Transaction tx = new Transaction(doc))
{
tx.Start("Rotate People");
foreach (FamilyInstance myFI in myListOfStuffOnWall)
{
FamilyInstance myFamilyInstance = myFI as FamilyInstance;
Reference pickedRef = myFI.HostFace;
////doc.Delete(myListElementID);
////myListElementID.Clear();
Face myFace = myElementWall.GetGeometryObjectFromReference(pickedRef) as Face;
if (myFace == null)
{
return;
}
Transform myXYZ_FamilyTransform = Transform.Identity;
if (pickedRef.ConvertToStableRepresentation(doc).Contains("INSTANCE"))
{
myXYZ_FamilyTransform = (myElementWall as FamilyInstance).GetTotalTransform();
}
Transform myTransform = Transform.Identity;
if (myFace.GetType() != typeof(PlanarFace))
{
return;
}
PlanarFace myPlanarFace = myFace as PlanarFace;
UV myUV_Min = myFace.GetBoundingBox().Min;
UV myUV_Max = myFace.GetBoundingBox().Max;
XYZ myXYZ_CornerOne = myFace.Evaluate(myUV_Min);
myTransform.Origin = myXYZ_FamilyTransform.OfPoint(myXYZ_CornerOne);
myTransform.BasisX = myXYZ_FamilyTransform.OfVector(myPlanarFace.XVector);
myTransform.BasisY = myXYZ_FamilyTransform.OfVector(myPlanarFace.YVector);
myTransform.BasisZ = myXYZ_FamilyTransform.OfVector(myPlanarFace.FaceNormal);
XYZ myXYZ_Centre = XYZ.Zero;
XYZ myXYZ_Min = new XYZ(myUV_Min.U, myUV_Min.V, 0);
XYZ myXYZ_Max = new XYZ(myUV_Max.U, myUV_Max.V, 0);
XYZ myXYZ_UV_CornerOne = (((myXYZ_Max - myXYZ_Min) * 0.1)); //; + myXYZ_Min;
XYZ myXYZ_UV_CornerTwo = (((myXYZ_Max - myXYZ_Min) * 0.9)); // + myXYZ_Min;
XYZ myXYZ_UV_Corner01 = new XYZ(myXYZ_UV_CornerOne.X, myXYZ_UV_CornerOne.Y, 0);
XYZ myXYZ_UV_Corner02 = new XYZ(myXYZ_UV_CornerTwo.X, myXYZ_UV_CornerOne.Y, 0);
XYZ myXYZ_UV_Corner03 = new XYZ(myXYZ_UV_CornerTwo.X, myXYZ_UV_CornerTwo.Y, 0);
XYZ myXYZ_UV_Corner04 = new XYZ(myXYZ_UV_CornerOne.X, myXYZ_UV_CornerTwo.Y, 0);
Line L1 = Line.CreateBound(myTransform.OfPoint(myXYZ_UV_Corner01), myTransform.OfPoint(myXYZ_UV_Corner02));
Line L2 = Line.CreateBound(myTransform.OfPoint(myXYZ_UV_Corner02), myTransform.OfPoint(myXYZ_UV_Corner03));
Line L3 = Line.CreateBound(myTransform.OfPoint(myXYZ_UV_Corner03), myTransform.OfPoint(myXYZ_UV_Corner04));
Line L4 = Line.CreateBound(myTransform.OfPoint(myXYZ_UV_Corner04), myTransform.OfPoint(myXYZ_UV_Corner01));
CurveLoop myCurveLoop = new CurveLoop();
myCurveLoop.Append(L1);
myCurveLoop.Append(L2);
myCurveLoop.Append(L3);
myCurveLoop.Append(L4);
double myDouble_ExactLength = myCurveLoop.GetExactLength();
double myDouble_ExactLength_Twenty = myDouble_ExactLength / 40;
XYZ myXYZ_Result = myTransform.OfPoint((myXYZ_Max - myXYZ_Min) / 2);
int myIntCurrentSpinnerValue = myWindow1.myIntegerUpDown_OneToTwentyCount.Value.Value;
int myInt_Positioning = (40 / myListOfStuffOnWall.Count()) * (myListOfStuffOnWall.IndexOf(myFI) + 1);
myIntCurrentSpinnerValue = (40 - myInt_Positioning) + myIntCurrentSpinnerValue;
if (myIntCurrentSpinnerValue > 40)
{
myIntCurrentSpinnerValue = myIntCurrentSpinnerValue - 40;
}
double myDouble_FutureForeach = myDouble_ExactLength_Twenty * myIntCurrentSpinnerValue;
double myDouble_ThisFarAlong;
switch (myDouble_FutureForeach)
{
case double n when n < L1.Length:
myDouble_ThisFarAlong = myDouble_FutureForeach;
myXYZ_Result = L1.GetEndPoint(0) + (L1.GetEndPoint(1) - L1.GetEndPoint(0)).Normalize().Multiply(myDouble_ThisFarAlong);
break;
case double n when n >= L1.Length& n < L1.Length + L2.Length:
myDouble_ThisFarAlong = myDouble_FutureForeach - L1.Length;
myXYZ_Result = L2.GetEndPoint(0) + (L2.GetEndPoint(1) - L2.GetEndPoint(0)).Normalize().Multiply(myDouble_ThisFarAlong);
break;
case double n when n >= L1.Length + L2.Length& n < L1.Length + L2.Length + L3.Length:
myDouble_ThisFarAlong = myDouble_FutureForeach - L1.Length - L2.Length;
myXYZ_Result = L3.GetEndPoint(0) + (L3.GetEndPoint(1) - L3.GetEndPoint(0)).Normalize().Multiply(myDouble_ThisFarAlong);
break;
case double n when n >= L1.Length + L2.Length + L3.Length:
myDouble_ThisFarAlong = myDouble_FutureForeach - L1.Length - L2.Length - L3.Length;
myXYZ_Result = L4.GetEndPoint(0) + (L4.GetEndPoint(1) - L4.GetEndPoint(0)).Normalize().Multiply(myDouble_ThisFarAlong);
break;
}
XYZ myXYZ_MoveThisMuch = myXYZ_Result - ((LocationPoint)myFamilyInstance.Location).Point;
ElementTransformUtils.MoveElement(doc, myFamilyInstance.Id, myXYZ_MoveThisMuch);
//SketchPlane mySketchPlane = SketchPlane.Create(doc, pickedRef);
//myListElementID.Add(doc.Create.NewModelCurve(L1, mySketchPlane).Id);
//myListElementID.Add(doc.Create.NewModelCurve(L2, mySketchPlane).Id);
//myListElementID.Add(doc.Create.NewModelCurve(L3, mySketchPlane).Id);
//myListElementID.Add(doc.Create.NewModelCurve(L4, mySketchPlane).Id);
}
tx.Commit();
}
if (myWindow1.myIntegerUpDown_OneToTwentyCount.Value.Value == 40)
{
myWindow1.myIntegerUpDown_OneToTwentyCount.Value = 0;
}
myWindow1.myIntegerUpDown_OneToTwentyCount.Value++;
}
}
#region catch and finally
catch (Exception ex)
{
DatabaseMethods.writeDebug("EE08_MoveElementAroundHostingSurface" + Environment.NewLine + ex.Message + Environment.NewLine + ex.InnerException, true);
}
finally
{
}
#endregion
}
private async Task <string> StoreImages(System.IO.Stream stream)
{
return(await DatabaseMethods.StoreImage(stream));
}
private DataTable GetAllRobotModels()
{
return(DatabaseMethods.GetDataFromDatabase("GetModelsBasedOnApplicationType", CommandType.StoredProcedure, GetStoredProcedureParameters()));
}
string GetCommentCount()
{
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataTable dt = db.GetDataTable("Select COUNT(y.MakaleID) as Comment_Count from Yorum y where y.MakaleID = " + makale_id);
db.CloseConnection();
return dt.Rows[0]["Comment_Count"].ToString();
}
public string myMethod_BindParameters(string path, bool IsTypeParameter)
{
UIDocument uidoc = myWindow1.commandData.Application.ActiveUIDocument;
Document doc = uidoc.Document;
string myStringSharedParameterFileName = "";
if (uidoc.Application.Application.SharedParametersFilename != null)
{
myStringSharedParameterFileName = uidoc.Application.Application.SharedParametersFilename; //Q:\Revit Revit Revit\Template 2018\PRL_Parameters.txt
}
int eL = -1;
try
{
/// TECHNIQUE 16 OF 19 (EE16_AddSharedParameters_InVariousWays.cs)
///↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ ADDING SHARED PARAMETERS IN VARIOUS WAYS ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
///
/// Interfaces and ENUM's:
///
///
/// Demonstrates classes::
/// DefinitionFile
/// CategorySet
/// DefinitionGroup
/// Definition
/// Binding
///
///
/// Key methods:
/// uidoc.Application.Application.OpenSharedParameterFile();
/// catSet.Insert(
/// myDefinitionFile.Groups.get_Item(
/// uidoc.Application.Application.Create.NewTypeBinding(
/// uidoc.Application.Application.Create.NewInstanceBinding(
/// doc.ParameterBindings.Insert(
///
/// famDoc.FamilyManager.AddParameter(
///
///
///
/// https://github.com/joshnewzealand/Revit-API-Playpen-CSharp
uidoc.Application.Application.SharedParametersFilename = path;
DefinitionFile myDefinitionFile = uidoc.Application.Application.OpenSharedParameterFile();
if (myDefinitionFile == null)
{
DatabaseMethods.writeDebug(path + Environment.NewLine + Environment.NewLine + "File does not exist OR cannot be opened.", true);
return("");
}
CategorySet catSet = uidoc.Application.Application.Create.NewCategorySet();
foreach (Category myCatttt in doc.Settings.Categories)
{
if (myCatttt.AllowsBoundParameters)
{
catSet.Insert(myCatttt);
}
}
string myStringCollectup = "";
DefinitionGroup group = myDefinitionFile.Groups.get_Item("Default");
if (!IsTypeParameter)
{
using (Transaction tx = new Transaction(doc))
{
tx.Start("Shared parameters to Project");
foreach (Definition myDefinition in group.Definitions)
{
myStringCollectup = myStringCollectup + " • " + myDefinition.Name + Environment.NewLine;
Binding binding = IsTypeParameter ? uidoc.Application.Application.Create.NewTypeBinding(catSet) as Binding : uidoc.Application.Application.Create.NewInstanceBinding(catSet) as Binding;
doc.ParameterBindings.Insert(myDefinition, binding, BuiltInParameterGroup.PG_IDENTITY_DATA);
}
tx.Commit();
}
myStringCollectup = (IsTypeParameter ? "Type" : "Instance") + " parameters added to Project (all categories):" + Environment.NewLine + myStringCollectup;
}
if (IsTypeParameter)
{
if (doc.GetElement(new ElementId(myWindow2.myIntegerUpDown.Value.Value)) != null) //i would rather this come from the spinner so we can select other entities
{
Element myElement = doc.GetElement(new ElementId(myWindow2.myIntegerUpDown.Value.Value)) as Element;
if (myElement.GetType() == typeof(FamilyInstance))
{
FamilyInstance myFamilyInstance = myElement as FamilyInstance;
Family myFamily = ((FamilySymbol)doc.GetElement(myFamilyInstance.GetTypeId())).Family;
if (myFamily.IsEditable)
{
Document famDoc = null;
famDoc = doc.EditFamily(myFamily);
bool myBool_GoForthAndAddParameters = false;
foreach (Definition myDefinition in group.Definitions)
{
myStringCollectup = myStringCollectup + " • " + myDefinition.Name + Environment.NewLine;
if (famDoc.FamilyManager.Parameters.Cast <FamilyParameter>().Where(x => x.Definition.Name == myDefinition.Name).Count() == 0)
{
myBool_GoForthAndAddParameters = true;
}
}
if (myBool_GoForthAndAddParameters)
{
using (Transaction tx = new Transaction(famDoc))
{
tx.Start("Shared parameters to Family");
foreach (ExternalDefinition eD in group.Definitions)
{
if (famDoc.FamilyManager.Parameters.Cast <FamilyParameter>().Where(x => x.Definition.Name == eD.Name).Count() == 0)
{
famDoc.FamilyManager.AddParameter(eD, BuiltInParameterGroup.PG_IDENTITY_DATA, false);
}
}
tx.Commit();
}
myFamily = famDoc.LoadFamily(doc, new FamilyOption());
}
famDoc.Close(false);
}
myStringCollectup = (IsTypeParameter ? "Type" : "Instance") + " parameters added to Family:" + Environment.NewLine + myStringCollectup;
}
else
{
using (Transaction tx = new Transaction(doc))
{
tx.Start("Shared parameters to Project");
CategorySet catSet2 = uidoc.Application.Application.Create.NewCategorySet();
catSet2.Insert(myElement.Category);
foreach (Definition myDefinition in group.Definitions)
{
myStringCollectup = myStringCollectup + " • " + myDefinition.Name + Environment.NewLine;
Binding binding = IsTypeParameter ? uidoc.Application.Application.Create.NewTypeBinding(catSet2) as Binding : uidoc.Application.Application.Create.NewInstanceBinding(catSet2) as Binding;
doc.ParameterBindings.Insert(myDefinition, binding, BuiltInParameterGroup.PG_IDENTITY_DATA);
}
tx.Commit();
}
myStringCollectup = (IsTypeParameter ? "Type" : "Instance") + " parameters added to Category: " + myElement.Category.Name + Environment.NewLine + myStringCollectup;
}
}
else
{
myStringCollectup = "Please use 'Acquire Selected' button.";
}
}
if (myStringSharedParameterFileName != "")
{
uidoc.Application.Application.SharedParametersFilename = myStringSharedParameterFileName;
}
return(myStringCollectup);
}
#region catch and finally
catch (Exception ex)
{
if (myStringSharedParameterFileName != "")
{
uidoc.Application.Application.SharedParametersFilename = myStringSharedParameterFileName;
}
_952_PRLoogleClassLibrary.DatabaseMethods.writeDebug("EE17_AddSharedParameters_InVariousWays, error line:" + eL + Environment.NewLine + ex.Message + Environment.NewLine + ex.InnerException, true);
return("");
}
finally
{
}
#endregion
}
protected void OnStartInternally(object arguments)
{
string[] args = (string[])arguments;
try
{
/*if (!IsAdministrator())
* {
* // Restart program and run as admin
* var exeName = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
* ProcessStartInfo startInfo = new ProcessStartInfo(exeName);
* startInfo.Verb = "runas";
* System.Diagnostics.Process.Start(startInfo);
* Environment.Exit(0);
* return;
* }*/
// check multiple processes
//commented by khazbak to avoid requirement to start in admin mode
/*
* if (bool.Parse(SystemConfigurations.GetAppSetting("CheckMultipleInstances")))
* {
* string currProcName = Process.GetCurrentProcess().ProcessName;
* int currProcID = Process.GetCurrentProcess().Id;
* Process[] processes = Process.GetProcessesByName(currProcName);
* if (processes.Length > 1)
* {
* foreach (Process p in processes)
* {
* if (p.Id != currProcID)
* {
* int id = p.Id;
* p.Kill();
* SystemLogger.WriteOnConsoleAsync(true, "Process has been killed ID: " + id, ConsoleColor.Gray, ConsoleColor.White, false);
* }
* }
* }
* }*/
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
SystemLogger.LogEventAsync("Starting FIX Service...");
try
{
if (bool.Parse(SystemConfigurations.GetAppSetting("ReinitializeCounters")))
{
Counters.ReInitialize();
}
else
{
Counters.Initialize();
}
}
catch (Exception ex)
{
SystemLogger.WriteOnConsoleAsync(true, "Error initializing counters, Error: " + ex.ToString(), ConsoleColor.Red, ConsoleColor.Black, true);
}
DatabaseMethods db = new DatabaseMethods();
if (!db.IsTodaySequenceReset()) // reset the counters only if the service starts for first time today
{
Counters.ResetCounters();
}
// Check queue existance
if (bool.Parse(SystemConfigurations.GetAppSetting("CheckQueueExistance")))
{
CheckAndSetPermissionsToQueues();
}
FixExchangesInfo.Initialize();
Currencies.Initialize();
StocksDefinitions.Initialize();
Lookups.Initialize();
string seqFilePath = SystemConfigurations.GetAppSetting("SequenceFilePath");
if (!db.IsTodaySequenceReset())
{
SystemLogger.LogEventAsync("Resetting FIX sequence..");
db.UpdateTodaySequenceReset();
SystemLogger.LogEventAsync("Sequence reset successfully");
//try
//{
// System.IO.File.Delete(seqFilePath);
//}
//catch (Exception ex)
//{
// Counters.IncrementCounter(CountersConstants.ExceptionMessages);
// SystemLogger.WriteOnConsoleAsync(true, "Deleting Sequence File Error: " + ex.Message, ConsoleColor.Red, ConsoleColor.Black, true);
//}
}
Router responsesRouter = new Router(typeof(ResponsesProcessor), int.Parse(SystemConfigurations.GetAppSetting("ResponsesRouterProcessorsNum")));
m_FixSessionStatusChangedDelegate = new FixSessionStatusChangedDelegate(OnFixStatusChange);
bool AllowMcsdAllocation = Convert.ToBoolean(SystemConfigurations.GetAppSetting("AllowMcsdAllocation")); // maghrabi
if (AllowMcsdAllocation) //MCSD
{
Router mcsdResponsesRouter = new Router(typeof(ResponsesProcessorMcsd), int.Parse(SystemConfigurations.GetAppSetting("McsdResponsesRouterProcessorsNum")));
McsdGatwayManager.Initialize(mcsdResponsesRouter); // maghrabi
McsdGatwayManager.LoginToMCSD(); // maghrabi
}
string fixClientSettings = Environment.CurrentDirectory + @"\" + SystemConfigurations.GetAppSetting("FixClientSettingsFile");
string fixServerSettings = Environment.CurrentDirectory + @"\" + SystemConfigurations.GetAppSetting("FixServerSettingsFile");
MarketFixClient.Initialize(fixClientSettings, responsesRouter, m_FixSessionStatusChangedDelegate);
SvcFixServer.InitializeServer(fixServerSettings);
OrdersManager.Initialize();
Sessions.Initialize();
//RepSessions.Initialize();
InitializeService();
if (_resetSequenceNumber)
{
// MarketFixClient.ResetSequence();
}
MarketFixClient.Logon();
SystemLogger.WriteOnConsoleAsync(true, "Awaiting for Fix server response ...", ConsoleColor.Yellow, ConsoleColor.Black, false);
System.Windows.Forms.Application.Run(new frmMonitor()); //maghrabi
//while (true) { Console.ReadKey(); }
//StopService();
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, "Main Error: " + ex.ToString(), ConsoleColor.Red, ConsoleColor.Black, true);
try
{
string[] cc = SystemConfigurations.GetAppSetting("SupportMailCC").Split(',');
NotificationSender.Send(true, true, false, SystemConfigurations.GetAppSetting("SupportMailFrom"), SystemConfigurations.GetAppSetting("SupportMailTo"), cc, "Fix Service Down", "Fix Service Down",
string.Format("Service startup error state on machine {0} at {1}, Error : {2}", SystemConfigurations.GetMachineIP(), DateTime.Now.ToString(), ex.ToString()), null);
}
catch (Exception inex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, "Sending Mail Error: " + inex.Message, ConsoleColor.Red, ConsoleColor.Black, false);
}
//Console.ReadKey();
}
}
DataTable GetComments(String id)
{
DatabaseMethods db = new DatabaseMethods();
db.OpenConnection();
DataTable dt = db.GetDataTable("Select y.YorumId , y.YorumIcerik , y.MakaleID , y.Tarih , y.Onay , u.Name from Yorum y , Users u where y.User_id = u.User_Id and y.MakaleId=" + makale_id);
rpt_Comment.DataSource = dt;
rpt_Comment.DataBind();
db.CloseConnection();
return dt;
}
