public static LogOrder GetLogOrderEntity(OrderTask orderTask,OperationType operationType,string objectId)
{
LogOrder logEntity = new LogOrder();
string hostname = Dns.GetHostName();
IPHostEntry localhost = Dns.GetHostEntry(hostname);
IPAddress localaddr = localhost.AddressList[0];
logEntity.IP = localaddr.ToString();
logEntity.UserId = ConsoleClient.Instance.User.UserId;
logEntity.UserName = ConsoleClient.Instance.User.UserName;
logEntity.Event = objectId;// "ExecuteOrder";
logEntity.ExchangeCode = orderTask.ExchangeCode;
logEntity.OperationType = operationType;
logEntity.OrderId = orderTask.OrderId;
logEntity.OrderCode = orderTask.Code;
logEntity.AccountCode = orderTask.AccountCode;
logEntity.InstrumentCode = orderTask.InstrumentCode;
logEntity.IsBuy = orderTask.IsBuy == BuySell.Buy;
logEntity.IsOpen = orderTask.IsOpen == OpenClose.Open;
logEntity.Lot = orderTask.Lot.Value;
logEntity.SetPrice = orderTask.SetPrice;
logEntity.OrderType = orderTask.OrderType;
logEntity.OrderRelation = null;
logEntity.TransactionCode = orderTask.Transaction.Code;
return logEntity;
}
public async Task <ActionResult <Order> > CancelOrder(int id)
{
var order = await _context.Order.FindAsync(id);
if (order == null)
{
return(NotFound());
}
var item = _context.Item.FirstOrDefault(x => x.Sku.ToLower() == order.Sku.ToLower());
item.StockQuantity += order.Quantity;
order.Status = (int)Enumerations.OrderStatus.Canceled;
order.Quantity = 0;
var logOrder = new LogOrder()
{
Sku = order.Sku,
Modified = DateTime.Now,
OrderId = order.Id,
UserId = order.UserId,
Quantity = order.Quantity,
Status = order.Status
};
_context.LogOrder.Add(logOrder);
_context.Entry(order).State = EntityState.Modified;
_context.Entry(item).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(order);
}
public void AcceptPlace(Transaction tran,LogOrder logEntity,Action<Transaction, TransactionError> EndAcceptPlace)
{
this._ServiceProxy.BeginAcceptPlace(tran.Id,logEntity,delegate(IAsyncResult result)
{
TransactionError transactionError = this._ServiceProxy.EndAcceptPlace(result);
EndAcceptPlace(tran, transactionError);
}, null);
}
private IOrderedEnumerable <MessageContext> SortMessages(LogOrder logOrder)
{
switch (logOrder)
{
case LogOrder.ByLevel:
return(this.Log.SelectMany(p => p.Value).OrderByDescending(c => c.Level));
default:
return(this.Log.SelectMany(p => p.Value).OrderBy(c => c.Timestamp));
}
}
private string FormattedLog(LogOrder logOrder)
{
StringBuilder builder = new StringBuilder();
foreach (MessageContext context in SortMessages(logOrder))
{
builder.AppendFormat(Strings.FormattedLogMessage, context.Timestamp.ToLongTimeString(), context.Level, context.Message);
builder.AppendLine();
}
return(builder.ToString());
}
public async Task <ActionResult <Order> > PostOrder(Order order)
{
var item = _context.Item.FirstOrDefault(x => x.Sku.ToLower() == order.Sku.ToLower());
if (item == null)
{
return(new ConflictResult());
}
if (item.StockQuantity < order.Quantity)
{
return(new ConflictResult());
}
var userExists = _context.User.Any(x => x.Id == order.UserId);
if (!userExists)
{
return(new ForbidResult());
}
item.StockQuantity -= order.Quantity;
order.Modified = DateTime.Now;
order.Status = (int)Enumerations.OrderStatus.Active;
_context.Entry(item).State = EntityState.Modified;
_context.Order.Add(order);
_context.SaveChanges();
var logOrder = new LogOrder()
{
Sku = order.Sku,
Modified = DateTime.Now,
OrderId = order.Id,
UserId = order.UserId,
Quantity = order.Quantity,
Status = order.Status
};
_context.LogOrder.Add(logOrder);
_context.SaveChanges();
return(CreatedAtAction("GetOrder", new { id = order.Id }, order));
}
/// <summary>
/// public enum MsgAlertType
///{
/// 消息,
/// 错误,
/// 成功,
/// 致命错误 会记录到数据库的
/// }
/// </summary>
/// <param name="msg"></param>
/// <param name="msgOrder"></param>
/// <param name="modleName"></param>
/// <param name="funName"></param>
/// <param name="?"></param>
/// <param name="?"></param>
/// <returns></returns>
public int Write(string msg, LogOrder msgOrder = LogOrder.严重错误, string funName = "", string className = "", string modleName = "", string context = "")
{
T_Log log = new T_Log();
log.ID = Guid.NewGuid().ToString();
log.Info = msg;
log.msgOrder = (int)msgOrder;
log.FunNameSource = funName;
log.ClassNameSource = className;
log.ModleNameSource = modleName;
log.ContextInfo = context;
log.CrateDate = DateTime.Now;
if (FrameSession.Session.Instance.CurrenterUser == null)
{
log.Createor = "TTS";
}
else
{
log.Createor = FrameSession.Session.Instance.CurrenterUserName;
}
int i = CurrentClient.Write(log);
if (i < 1)
{
string path = Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.Templates), "Gold");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filePath = Path.Combine(path, DateTime.Now.ToString("yyyyMMdd") + ".txt");
using (FileStream fs = new FileStream(filePath, FileMode.Append))
{
using (StreamWriter sw = new StreamWriter(fs))
{
//开始写入
sw.Write(context + System.Environment.NewLine);
}
}
}
return(i);
}
public async Task <IActionResult> PutOrder(int id, Order order)
{
if (id != order.Id)
{
return(BadRequest());
}
_context.Entry(order).State = EntityState.Modified;
var logOrder = new LogOrder()
{
Sku = order.Sku,
Modified = DateTime.Now,
OrderId = order.Id,
UserId = order.UserId,
Quantity = order.Quantity,
Status = order.Status
};
_context.LogOrder.Add(logOrder);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <inheritdoc/>
public string OutputLog(LogOrder logOrder)
{
return(FormattedLog(logOrder));
}
public void Execute(Transaction tran, string buyPrice, string sellPrice, decimal lot, Guid orderId, LogOrder logEntity, Action<Transaction, TransactionResult> EndExecute)
{
this._ServiceProxy.BeginExecute(tran.Id, buyPrice, sellPrice, lot, orderId, logEntity, delegate(IAsyncResult result)
{
TransactionResult tranResult = this._ServiceProxy.EndExecute(result);
EndExecute(tran, tranResult);
}, null);
}
public void Cancel(Transaction tran, CancelReason cancelReason, LogOrder logEntity, Action<Transaction, TransactionError> EndCancel)
{
this._ServiceProxy.BeginCancel(tran.Id, cancelReason, logEntity, delegate(IAsyncResult result)
{
TransactionError transactionError = this._ServiceProxy.EndCancel(result);
EndCancel(tran, transactionError);
}, null);
}
