public ActionResult CreateStatsExample(long typeId, [DataSourceRequest] DataSourceRequest request, StatsExampleModel model)
{
if(model != null && this.ModelState.IsValid)
{
try
{
var guid = Guid.NewGuid().ToString("N");
using(var ctx = new DataModelContext())
{
var newExample = new StatsExample
{
Timestamp = DateTime.Now,
Name = model.Name,
IdLink = guid,
StatsTypeId = typeId
};
ctx.StatsExamples.Add(newExample);
//
ctx.SaveChanges();
}
} catch(Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
this.ModelState.AddModelError("save_error", ex.Message);
}
}
return this.Json(new[] {model}.ToDataSourceResult(request, this.ModelState));
}
public ActionResult CreateStatsType([DataSourceRequest] DataSourceRequest request, StatsTypeModel model)
{
if(model != null && this.ModelState.IsValid)
{
try
{
using(var ctx = new DataModelContext())
{
ctx.StatsTypes.Add(new StatsType
{
Name = model.Name,
TypeId = model.TypeConfig.Id
});
//
ctx.SaveChanges();
}
} catch(Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
this.ModelState.AddModelError("save_error", ex.Message);
}
}
this.ViewData["TransactionTypes"] = GetAllTypesConfig();
//
return this.Json(new[] {model}.ToDataSourceResult(request, this.ModelState));
}
public ActionResult DeleteStatsExample([DataSourceRequest] DataSourceRequest request, StatsExampleModel model)
{
try
{
if(model != null)
{
using(var ctx = new DataModelContext())
{
var example = ctx.StatsExamples.Include("StatsType").Include("Orders").Single(e => e.Id == model.Id);
example.Deleted = true;
var lastOrder = example.Orders.OrderBy(o => o.Index).LastOrDefault();
if(lastOrder != null && !lastOrder.ClosePrice.HasValue)
{
using(var client = new OrderServiceClient())
{
var response = client.GetPrice(new GetPriceDataContractRequest {SymbolId = example.StatsType.TypeId});
if(!string.IsNullOrEmpty(response.Error))
{
LogManager.GetCurrentClassLogger().Error(response.Error);
}
var price = response.Price;
if(price.HasValue)
{
var typeConfig = ((TransactionTypesConfigSection)ConfigurationManager.GetSection("TransactionTypesConfig")).Types.Cast<TypeElementConfig>().ToList().Single(tc => tc.Id == example.StatsType.TypeId);
lastOrder.ClosePrice = lastOrder.OrderType == OrderTypes.Buy ?
Math.Round(price.Value - Settings.Default.Spread * typeConfig.SpreadTickValue, HomeController.GetDecimalDigits(typeConfig.SpreadTickValue))
: Math.Round(price.Value + Settings.Default.Spread * typeConfig.SpreadTickValue, HomeController.GetDecimalDigits(typeConfig.SpreadTickValue));
lastOrder.Pips = Convert.ToInt32(Math.Round((lastOrder.OrderType == OrderTypes.Buy ? (lastOrder.ClosePrice.Value - lastOrder.OpenPrice) : (lastOrder.OpenPrice - lastOrder.ClosePrice.Value)) / typeConfig.SpreadTickValue, 0));
// Log
var log = OrderLog.CreateLog(lastOrder, OrderLogTypes.Close);
ctx.OrderLogs.Add(log);
}
}
}
//
ctx.SaveChanges();
}
}
} catch(Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
}
//
return this.Json(new[] {model}.ToDataSourceResult(request, this.ModelState));
}
public ActionResult UpdateStatsExample([DataSourceRequest] DataSourceRequest request, StatsExampleModel model)
{
if(model != null && this.ModelState.IsValid)
{
try
{
using(var ctx = new DataModelContext())
{
var example = ctx.StatsExamples.Find(model.Id);
example.Name = model.Name;
ctx.SaveChanges();
}
} catch(Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
this.ModelState.AddModelError("save_error", ex.Message);
}
}
//
return this.Json(new[] {model}.ToDataSourceResult(request, this.ModelState));
}
public static SetOrderResponse ChangeOrder(long exampleId, int index, double? takeProfit, double? stopLoss)
{
using(var ctx = new DataModelContext())
{
var example = ctx.StatsExamples.Include("StatsType").Include("Orders").Single(e => e.Id == exampleId);
// Check if example is not valid
if(!example.IsValid)
{
return new SetOrderResponse {Error = SetOrderErrors.Other};
}
//
var order = example.Orders.SingleOrDefault(o => o.Index == index);
if(order == null)
return new SetOrderResponse {Error = SetOrderErrors.Other};
//
var price = PricesProvider.GetPrice(example.StatsType.TypeId);
if(!price.HasValue)
return new SetOrderResponse {Error = SetOrderErrors.PriceError};
//
if(order.TakeProfit == takeProfit && order.StopLoss == stopLoss)
{
LogManager.GetCurrentClassLogger().Debug("Nothing to change in order [{0}]", order.Id);
//
return new SetOrderResponse {Order = order};
}
//
var buyPrice = PricesProvider.GetBuyPrice(price.Value, example.StatsType.TypeId);
var sellPrice = PricesProvider.GetSellPrice(price.Value, example.StatsType.TypeId);
//
lock(_openOrders)
{
var error = SetOrderErrors.None;
// Check take-profit
if(order.TakeProfit != takeProfit)
{
if(!takeProfit.HasValue)
{
order.TakeProfit = null;
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.SetTakeProfit);
ctx.OrderLogs.Add(log);
} else if(order.OrderType == OrderTypes.Buy && takeProfit.Value <= sellPrice)
error |= SetOrderErrors.WrongTakeProfitValue;
else if(order.OrderType == OrderTypes.Sell && takeProfit.Value >= buyPrice)
error |= SetOrderErrors.WrongTakeProfitValue;
else
{
order.TakeProfit = takeProfit;
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.SetTakeProfit);
ctx.OrderLogs.Add(log);
}
}
// Check stop-loss
if(order.StopLoss != stopLoss)
{
if(!stopLoss.HasValue)
{
order.StopLoss = null;
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.SetStopLoss);
ctx.OrderLogs.Add(log);
} else if(order.OrderType == OrderTypes.Buy && stopLoss.Value >= sellPrice)
error |= SetOrderErrors.WrongStopLossValue;
else if(order.OrderType == OrderTypes.Sell && stopLoss.Value <= buyPrice)
error |= SetOrderErrors.WrongStopLossValue;
else
{
order.StopLoss = stopLoss;
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.SetStopLoss);
ctx.OrderLogs.Add(log);
}
}
//
if(error == SetOrderErrors.None)
{
ctx.SaveChanges();
_openOrders.Single(o => o.Order.StatsExampleId == exampleId && o.Order.Index == index).Order = order;
//
LogManager.GetCurrentClassLogger().Debug("Order changed [{0}]", order.Id);
//
return new SetOrderResponse {Order = order};
}
LogManager.GetCurrentClassLogger().Debug("Order [{0}] was not changed. Error: {1}", order.Id, error);
//
return new SetOrderResponse {Error = error};
}
}
}
private static void PricesProvider_PriceChanged(object sender, PriceChangedEventArgs e)
{
lock(_openOrders)
{
var orders = _openOrders.Where(o => o.SymbolId == e.SymbolId).ToList();
var closedOrders = new List<OpenOrder>();
foreach(var openOrder in orders)
{
// Check if example is not valid
if(!openOrder.Order.StatsExample.IsValid)
{
closedOrders.Add(openOrder);
//
continue;
}
//
if(openOrder.Order.OrderType == OrderTypes.Buy)
{
// Take profit
if(openOrder.Order.TakeProfit.HasValue && openOrder.Order.TakeProfit.Value <= e.SellPrice)
{
// Auto-close order
using(var ctx = new DataModelContext())
{
var order = ctx.Orders.Find(openOrder.Order.Id);
// Check if order was closed already
if(order.ClosePrice.HasValue)
{
LogManager.GetCurrentClassLogger().Warn("Take-profit for order [{0}] but order was closed already.", order.Id);
continue;
}
//
order.ClosePrice = e.SellPrice;
order.Pips = PricesProvider.CalculatePips(e.SymbolId, order.OpenPrice, order.ClosePrice.Value);
// logs
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.TakeProfitInvoke));
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.Close));
//
ctx.SaveChanges();
closedOrders.Add(openOrder);
//
LogManager.GetCurrentClassLogger().Debug("Take-profit for order [{0}]", order.Id);
}
// Stop loss
} else if(openOrder.Order.StopLoss.HasValue && openOrder.Order.StopLoss.Value >= e.SellPrice)
{
// Auto-close order
using(var ctx = new DataModelContext())
{
var order = ctx.Orders.Find(openOrder.Order.Id);
// Check if order was closed already
if(order.ClosePrice.HasValue)
{
LogManager.GetCurrentClassLogger().Warn("Stop-loss for order [{0}] but order was closed already.", order.Id);
continue;
}
//
order.ClosePrice = e.SellPrice;
order.Pips = PricesProvider.CalculatePips(e.SymbolId, order.OpenPrice, order.ClosePrice.Value);
// log
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.StopLossInvoke));
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.Close));
//
ctx.SaveChanges();
closedOrders.Add(openOrder);
//
LogManager.GetCurrentClassLogger().Debug("Stop-loss for order [{0}]", order.Id);
}
}
} else
{
// Take profit
if(openOrder.Order.TakeProfit.HasValue && openOrder.Order.TakeProfit.Value >= e.BuyPrice)
{
// Auto-close order
using(var ctx = new DataModelContext())
{
var order = ctx.Orders.Find(openOrder.Order.Id);
// Check if order was closed already
if(order.ClosePrice.HasValue)
{
LogManager.GetCurrentClassLogger().Warn("Take-profit for order [{0}] but order was closed already.", order.Id);
continue;
}
//
order.ClosePrice = e.BuyPrice;
order.Pips = PricesProvider.CalculatePips(e.SymbolId, order.ClosePrice.Value, order.OpenPrice);
// log
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.TakeProfitInvoke));
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.Close));
//
ctx.SaveChanges();
closedOrders.Add(openOrder);
//
LogManager.GetCurrentClassLogger().Debug("Take-profit for order [{0}]", order.Id);
}
// Stop loss
} else if(openOrder.Order.StopLoss.HasValue && openOrder.Order.StopLoss.Value <= e.BuyPrice)
{
// Auto-close order
using(var ctx = new DataModelContext())
{
var order = ctx.Orders.Find(openOrder.Order.Id);
// Check if order was closed already
if(order.ClosePrice.HasValue)
{
LogManager.GetCurrentClassLogger().Warn("Stop-loss for order [{0}] but order was closed already.", order.Id);
continue;
}
//
order.ClosePrice = e.BuyPrice;
order.Pips = PricesProvider.CalculatePips(e.SymbolId, order.ClosePrice.Value, order.OpenPrice);
// log
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.StopLossInvoke));
ctx.OrderLogs.Add(OrderLog.CreateLog(order, OrderLogTypes.Close));
//
ctx.SaveChanges();
closedOrders.Add(openOrder);
//
LogManager.GetCurrentClassLogger().Debug("Stop-loss for order [{0}]", order.Id);
}
}
}
}
// Remove closed orders
_openOrders.RemoveAll(closedOrders.Contains);
}
}
public static SetOrderResponse CreateOrder(long exampleId, OrderTypes orderType, double? takeProfit, double? stopLoss)
{
using(var ctx = new DataModelContext())
{
var example = ctx.StatsExamples.Include("StatsType").Include("Orders").Single(e => e.Id == exampleId);
// Check if example is not valid
if(!example.IsValid)
{
return new SetOrderResponse {Error = SetOrderErrors.Other};
}
//
var index = example.Orders.Count;
if(index >= ctx.GetTransactionsCount())
return new SetOrderResponse {Error = SetOrderErrors.Other};
//
var price = PricesProvider.GetPrice(example.StatsType.TypeId);
if(!price.HasValue)
return new SetOrderResponse {Error = SetOrderErrors.PriceError};
//
var buyPrice = PricesProvider.GetBuyPrice(price.Value, example.StatsType.TypeId);
var sellPrice = PricesProvider.GetSellPrice(price.Value, example.StatsType.TypeId);
if(orderType == OrderTypes.Buy)
{
var error = SetOrderErrors.None;
// Check take profit value
if(takeProfit.HasValue && takeProfit.Value <= sellPrice)
error |= SetOrderErrors.WrongTakeProfitValue;
// Check Stop loss value
if(stopLoss.HasValue && stopLoss.Value >= sellPrice)
error |= SetOrderErrors.WrongStopLossValue;
//
if(error != SetOrderErrors.None)
return new SetOrderResponse {Error = error};
// Create order
var order = new Order
{
OpenPrice = buyPrice,
Index = index,
OrderType = orderType,
StatsExampleId = exampleId,
TakeProfit = takeProfit,
StopLoss = stopLoss
};
ctx.Orders.Add(order);
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.Open);
ctx.OrderLogs.Add(log);
//
ctx.SaveChanges();
//
lock(_openOrders)
{
_openOrders.Add(new OpenOrder
{
SymbolId = example.StatsType.TypeId,
Order = order
});
}
//
LogManager.GetCurrentClassLogger().Debug("Order created [0]", order.Id);
//
return new SetOrderResponse {Order = order, Error = SetOrderErrors.None};
} else
{
var error = SetOrderErrors.None;
// Check take profit value
if(takeProfit.HasValue && takeProfit.Value >= buyPrice)
error |= SetOrderErrors.WrongTakeProfitValue;
// Check Stop loss value
if(stopLoss.HasValue && stopLoss.Value <= buyPrice)
error |= SetOrderErrors.WrongStopLossValue;
//
if(error != SetOrderErrors.None)
return new SetOrderResponse {Error = error};
// Create order
var order = new Order
{
OpenPrice = sellPrice,
Index = index,
OrderType = orderType,
StatsExampleId = exampleId,
TakeProfit = takeProfit,
StopLoss = stopLoss
};
ctx.Orders.Add(order);
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.Open);
ctx.OrderLogs.Add(log);
//
ctx.SaveChanges();
//
lock(_openOrders)
{
_openOrders.Add(new OpenOrder
{
SymbolId = example.StatsType.TypeId,
Order = order
});
}
//
LogManager.GetCurrentClassLogger().Debug("Order created [0]", order.Id);
//
return new SetOrderResponse {Order = order, Error = SetOrderErrors.None};
}
}
}
public static SetOrderResponse CloseOrder(long exampleId, int index)
{
using(var ctx = new DataModelContext())
{
var example = ctx.StatsExamples.Include("StatsType").Include("Orders").Single(e => e.Id == exampleId);
// Check if example is not valid
if(!example.IsValid)
{
return new SetOrderResponse {Error = SetOrderErrors.Other};
}
//
var order = example.Orders.SingleOrDefault(o => o.Index == index);
if(order == null)
return new SetOrderResponse {Error = SetOrderErrors.Other};
// Check if order was closed already
if(order.ClosePrice.HasValue)
{
LogManager.GetCurrentClassLogger().Warn("Close order process for order [{0}] but order was closed already.", order.Id);
return new SetOrderResponse {Error = SetOrderErrors.Other};
}
//
var price = PricesProvider.GetPrice(example.StatsType.TypeId);
if(!price.HasValue)
return new SetOrderResponse {Error = SetOrderErrors.PriceError};
//
lock(_openOrders)
{
if(order.OrderType == OrderTypes.Buy)
{
var sellPrice = PricesProvider.GetSellPrice(price.Value, example.StatsType.TypeId);
order.ClosePrice = sellPrice;
order.Pips = PricesProvider.CalculatePips(example.StatsType.TypeId, order.OpenPrice, sellPrice);
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.Close);
ctx.OrderLogs.Add(log);
} else
{
var buyPrice = PricesProvider.GetBuyPrice(price.Value, example.StatsType.TypeId);
order.ClosePrice = buyPrice;
order.Pips = PricesProvider.CalculatePips(example.StatsType.TypeId, buyPrice, order.OpenPrice);
// log
var log = OrderLog.CreateLog(order, OrderLogTypes.Close);
ctx.OrderLogs.Add(log);
}
//
ctx.SaveChanges();
_openOrders.Remove(_openOrders.Single(o => o.Order.Id == order.Id));
//
LogManager.GetCurrentClassLogger().Debug("Order closed [{0}]", order.Id);
//
return new SetOrderResponse {Order = order};
}
}
}