public TradeCommand(TradeCommand cmd)
{
this.CommandId = cmd.CommandId;
this.CommandNum = cmd.CommandNum;
this.ECommandStatus = cmd.ECommandStatus;
this.CommandAmount = cmd.CommandAmount;
this.InstanceId = cmd.InstanceId;
this.InstanceCode = cmd.InstanceCode;
this.ModifiedTimes = cmd.ModifiedTimes;
this.ECommandType = cmd.ECommandType;
this.EExecuteType = cmd.EExecuteType;
this.EStockDirection = cmd.EStockDirection;
this.EFuturesDirection = cmd.EFuturesDirection;
this.EEntrustStatus = cmd.EEntrustStatus;
this.EDealStatus = cmd.EDealStatus;
this.DStartDate = cmd.DStartDate;
this.DEndDate = cmd.DEndDate;
this.SubmitPerson = cmd.SubmitPerson;
this.CreatedDate = cmd.CreatedDate;
this.ModifiedDate = cmd.ModifiedDate;
this.CancelDate = cmd.CancelDate;
this.MonitorUnitId = cmd.MonitorUnitId;
this.MonitorUnitName = cmd.MonitorUnitName;
this.TemplateId = cmd.TemplateId;
this.TemplateName = cmd.TemplateName;
this.BearContract = cmd.BearContract;
this.PortfolioId = cmd.PortfolioId;
this.PortfolioCode = cmd.PortfolioCode;
this.PortfolioName = cmd.PortfolioName;
this.AccountCode = cmd.AccountCode;
this.AccountName = cmd.AccountName;
this.Notes = cmd.Notes;
this.ModifiedCause = cmd.ModifiedCause;
this.CancelCause = cmd.CancelCause;
}
public int Create(Model.Database.TradeCommand cmdItem)
{
var dbCommand = _dbHelper.GetStoredProcCommand(SP_Create);
_dbHelper.AddInParameter(dbCommand, "@InstanceId", System.Data.DbType.Int32, cmdItem.InstanceId);
_dbHelper.AddInParameter(dbCommand, "@CommandNum", System.Data.DbType.Int32, cmdItem.CommandNum);
_dbHelper.AddInParameter(dbCommand, "@CommandType", System.Data.DbType.Int32, cmdItem.ECommandType);
_dbHelper.AddInParameter(dbCommand, "@ExecuteType", System.Data.DbType.Int32, cmdItem.EExecuteType);
_dbHelper.AddInParameter(dbCommand, "@StockDirection", System.Data.DbType.String, (int)cmdItem.EStockDirection);
_dbHelper.AddInParameter(dbCommand, "@FuturesDirection", System.Data.DbType.Int32, (int)cmdItem.EFuturesDirection);
_dbHelper.AddInParameter(dbCommand, "@EntrustStatus", System.Data.DbType.Int32, (int)cmdItem.EEntrustStatus);
_dbHelper.AddInParameter(dbCommand, "@DealStatus", System.Data.DbType.Int32, (int)cmdItem.EDealStatus);
_dbHelper.AddInParameter(dbCommand, "@SubmitPerson", System.Data.DbType.Int32, cmdItem.SubmitPerson);
_dbHelper.AddInParameter(dbCommand, "@StartDate", System.Data.DbType.DateTime, cmdItem.DStartDate);
_dbHelper.AddInParameter(dbCommand, "@EndDate", System.Data.DbType.DateTime, cmdItem.DEndDate);
_dbHelper.AddInParameter(dbCommand, "@Notes", System.Data.DbType.String, cmdItem.Notes);
_dbHelper.AddReturnParameter(dbCommand, "@return", System.Data.DbType.Int32);
int ret = _dbHelper.ExecuteNonQuery(dbCommand);
int commandId = -1;
if (ret > 0)
{
commandId = (int)dbCommand.Parameters["@return"].Value;
}
return(commandId);
}
private TradeCommandItem BuildUICommand(Model.Database.TradeCommand tradeCommand)
{
var uiCommand = new TradeCommandItem
{
CommandId = tradeCommand.CommandId,
InstanceId = tradeCommand.InstanceId,
CommandNum = tradeCommand.CommandNum,
ModifiedTimes = tradeCommand.ModifiedTimes,
ECommandType = tradeCommand.ECommandType,
EExecuteType = tradeCommand.EExecuteType,
EStockDirection = tradeCommand.EStockDirection,
EFuturesDirection = tradeCommand.EFuturesDirection,
EEntrustStatus = tradeCommand.EEntrustStatus,
EDealStatus = tradeCommand.EDealStatus,
SubmitPerson = tradeCommand.SubmitPerson,
CreatedDate = tradeCommand.CreatedDate,
ModifiedDate = tradeCommand.ModifiedDate,
DStartDate = tradeCommand.DStartDate,
DEndDate = tradeCommand.DEndDate,
MonitorUnitId = tradeCommand.MonitorUnitId,
MonitorUnitName = tradeCommand.MonitorUnitName,
InstanceCode = tradeCommand.InstanceCode,
PortfolioId = tradeCommand.PortfolioId,
PortfolioCode = tradeCommand.PortfolioCode,
PortfolioName = tradeCommand.PortfolioName,
FundCode = tradeCommand.AccountCode,
FundName = tradeCommand.AccountName,
};
return(uiCommand);
}
public int UpdateStatus(Model.Database.TradeCommand cmdItem)
{
var dbCommand = _dbHelper.GetStoredProcCommand(SP_ModifyStatus);
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, cmdItem.CommandId);
_dbHelper.AddInParameter(dbCommand, "@EntrustStatus", System.Data.DbType.Int32, (int)cmdItem.EEntrustStatus);
_dbHelper.AddInParameter(dbCommand, "@DealStatus", System.Data.DbType.Int32, (int)cmdItem.EDealStatus);
_dbHelper.AddInParameter(dbCommand, "@ModifiedDate", System.Data.DbType.DateTime, DateTime.Now);
return(_dbHelper.ExecuteNonQuery(dbCommand));
}
private CancelRedoItem Convert(EntrustSecurity p, Model.Database.TradeCommand tradeCommand)
{
CancelRedoItem cancelRedoItem = new CancelRedoItem
{
Selection = true,
CommandId = tradeCommand.CommandId,
EDirection = p.EntrustDirection,
EntrustPrice = p.EntrustPrice,
SecuCode = p.SecuCode,
SecuType = p.SecuType,
EntrustNo = p.EntrustNo,
ECommandPrice = p.PriceType,
ReportPrice = p.EntrustPrice,
EOriginPriceType = p.EntrustPriceType,
LeftAmount = p.EntrustAmount - p.TotalDealAmount,
ReportAmount = p.EntrustAmount,
DealAmount = p.TotalDealAmount,
EntrustDate = p.EntrustDate,
SubmitId = p.SubmitId,
EntrustBatchNo = p.BatchNo,
PortfolioName = tradeCommand.PortfolioName,
FundName = tradeCommand.AccountName,
};
cancelRedoItem.EntrustAmount = cancelRedoItem.LeftAmount;
if (cancelRedoItem.SecuType == Model.SecurityInfo.SecurityType.Stock && cancelRedoItem.EDirection == EntrustDirection.BuySpot)
{
if (cancelRedoItem.LeftAmount % 100 > 0)
{
cancelRedoItem.EntrustAmount = AmountRoundUtil.Round(cancelRedoItem.LeftAmount);
}
}
var secuInfo = SecurityInfoManager.Instance.Get(p.SecuCode, p.SecuType);
if (secuInfo != null)
{
cancelRedoItem.SecuName = secuInfo.SecuName;
cancelRedoItem.ExchangeCode = secuInfo.ExchangeCode;
}
else
{
cancelRedoItem.ExchangeCode = SecurityItemHelper.GetExchangeCode(p.SecuCode, p.SecuType);
}
return(cancelRedoItem);
}
/// <summary>
/// Submit to close the position.
/// </summary>
/// <param name="cmdItem"></param>
/// <param name="selectedSecuItems"></param>
/// <returns></returns>
public int SubmitClosePosition(Model.Database.TradeCommand cmdItem, List <ClosePositionSecurityItem> selectedSecuItems)
{
int instanceId = cmdItem.InstanceId;
string instanceCode = cmdItem.InstanceCode;
var secuItems = GetSelectCommandSecurities(instanceId, selectedSecuItems);
//TODO: update the TradingInstance
//string instanceCode = closeItem.InstanceCode;
var instance = _tradeInstanceBLL.GetInstance(instanceCode);
if (instance != null && !string.IsNullOrEmpty(instance.InstanceCode) && instance.InstanceCode.Equals(instanceCode))
{
_tradeInstanceBLL.Update(instance, selectedSecuItems);
}
return(SubmitInternal(cmdItem, secuItems));
}
private int SubmitInternal(Model.Database.TradeCommand cmdItem, List <TradeCommandSecurity> secuItems)
{
int userId = LoginManager.Instance.GetUserId();
cmdItem.SubmitPerson = userId;
//TODO: add the permission control
int commandId = _commanddao.Create(cmdItem, secuItems);
if (commandId > 0)
{
Tracking(ActionType.Submit, ResourceType.TradeCommand, commandId, cmdItem);
var perm = _permissionManager.GetOwnerPermission();
_permissionManager.GrantPermission(userId, commandId, ResourceType.TradeCommand, perm);
}
return(commandId);
}
public int Update(Model.Database.TradeCommand cmdItem)
{
var dbCommand = _dbHelper.GetStoredProcCommand(SP_Modify);
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, cmdItem.CommandId);
_dbHelper.AddInParameter(dbCommand, "@CommandStatus", System.Data.DbType.Int32, (int)cmdItem.ECommandStatus);
_dbHelper.AddInParameter(dbCommand, "@ModifiedDate", System.Data.DbType.DateTime, DateTime.Now);
_dbHelper.AddInParameter(dbCommand, "@StartDate", System.Data.DbType.DateTime, cmdItem.DStartDate);
_dbHelper.AddInParameter(dbCommand, "@EndDate", System.Data.DbType.DateTime, cmdItem.DEndDate);
_dbHelper.AddInParameter(dbCommand, "@Notes", System.Data.DbType.String, cmdItem.Notes);
string modifiedCause = (cmdItem.ModifiedCause != null) ? cmdItem.ModifiedCause : string.Empty;
_dbHelper.AddInParameter(dbCommand, "@ModifiedCause", System.Data.DbType.String, modifiedCause);
string cancelCause = (cmdItem.CancelCause != null) ? cmdItem.CancelCause : string.Empty;
_dbHelper.AddInParameter(dbCommand, "@CancelCause", System.Data.DbType.String, cancelCause);
return(_dbHelper.ExecuteNonQuery(dbCommand));
}
public int Update(CommandManagementItem cmdMngItem)
{
DateTime startDate = DateUtil.GetStartDate(cmdMngItem.DStartDate);
DateTime endDate = DateUtil.GetEndDate(cmdMngItem.DEndDate, startDate);
Model.Database.TradeCommand cmdItem = new Model.Database.TradeCommand
{
CommandId = cmdMngItem.CommandId,
ECommandStatus = Model.EnumType.CommandStatus.Canceled,
ModifiedDate = DateTime.Now,
DStartDate = startDate,
DEndDate = endDate,
Notes = cmdMngItem.Notes ?? string.Empty,
ModifiedCause = cmdMngItem.ModifiedCause,
CancelCause = cmdMngItem.CancelCause,
};
return(_tradeCommandBLL.Update(cmdItem));
}
public Model.Database.TradeCommand Get(int commandId)
{
var dbCommand = _dbHelper.GetStoredProcCommand(SP_Get);
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, commandId);
var item = new Model.Database.TradeCommand();
var reader = _dbHelper.ExecuteReader(dbCommand);
if (reader.HasRows)
{
if (reader.Read())
{
item = GetTradeCommand(reader);
}
}
reader.Close();
_dbHelper.Close(dbCommand);
return(item);
}
/// <summary>
/// Archive the TradeCommand item.
/// </summary>
/// <param name="commandId">An integer value of the TradeCommand ID.</param>
/// <returns>An positive value if it success otherwise it fails.</returns>
public int ArchiveTradeCommand(int commandId)
{
int ret = -1;
Model.Database.TradeCommand tradeCommand = null;
List <Model.Database.TradeCommandSecurity> tradeSecuItems = null;
tradeCommand = _tradeCommandBLL.GetTradeCommand(commandId);
if (tradeCommand != null && tradeCommand.CommandId == commandId)
{
tradeSecuItems = _tradeCommandSecurityBLL.GetTradeCommandSecurities(commandId);
}
if (tradeSecuItems != null && tradeSecuItems.Count > 0)
{
ret = _archiveTradeBLL.Create(tradeCommand, tradeSecuItems);
}
if (ret > 0)
{
ret = ArchiveEntrustCommand(commandId);
if (ret > 0)
{
_entrustCommandBLL.DeleteByCommandId(commandId);
var permItems = _tokenResourcePermissionBLL.GetByResource(commandId, ResourceType.TradeCommand);
if (permItems != null && permItems.Count > 0)
{
ArchivePermission(commandId, ResourceType.TradeCommand, permItems);
}
}
else
{
string msg = string.Format("Fail to archive the EntrustCommand - CommandId: {0}", commandId);
logger.Error(msg);
}
}
return(ret);
}
public int Create(Model.Database.TradeCommand tradeCommand, List <TradeCommandSecurity> securities)
{
return(_archivetradedao.Create(tradeCommand, securities));
}
public int UpdateStatus(Model.Database.TradeCommand cmdItem)
{
return(_tradecommandao.UpdateStatus(cmdItem));
}
public int Update(Model.Database.TradeCommand cmdItem, List <TradeCommandSecurity> modifiedSecuItems, List <TradeCommandSecurity> cancelSecuItems)
{
return(_commanddao.Update(cmdItem, modifiedSecuItems, cancelSecuItems));
}
private bool IsValidTime(Model.Database.TradeCommand tradeCommand)
{
return(tradeCommand.DEndDate > tradeCommand.DStartDate && tradeCommand.DEndDate > DateUtil.OpenDate && tradeCommand.DStartDate < DateUtil.CloseDate);
}
private bool IsValidCommand(Model.Database.TradeCommand tradeCommand)
{
return(tradeCommand.ECommandStatus == CommandStatus.Effective ||
tradeCommand.ECommandStatus == CommandStatus.Entrusted ||
tradeCommand.ECommandStatus == CommandStatus.Modified);
}
private bool IsExpireTime(Model.Database.TradeCommand tradeCommand)
{
return(tradeCommand.DEndDate < DateUtil.OpenDate);
}
private Model.Database.TradeCommand GetTradeCommand(DbDataReader reader)
{
var item = new Model.Database.TradeCommand();
item.CommandId = (int)reader["CommandId"];
item.InstanceId = (int)reader["InstanceId"];
item.CommandNum = (int)reader["CommandNum"];
item.ECommandStatus = (CommandStatus)reader["CommandStatus"];
item.ModifiedTimes = (int)reader["ModifiedTimes"];
item.ECommandType = (CommandType)reader["CommandType"];
item.EExecuteType = (ExecuteType)reader["ExecuteType"];
item.EStockDirection = (EntrustDirection)(int)reader["StockDirection"];
item.EFuturesDirection = (EntrustDirection)(int)reader["FuturesDirection"];
item.EEntrustStatus = (EntrustStatus)reader["EntrustStatus"];
item.EDealStatus = (DealStatus)reader["DealStatus"];
item.SubmitPerson = (int)reader["SubmitPerson"];
item.MonitorUnitId = (int)reader["MonitorUnitId"];
item.InstanceCode = (string)reader["InstanceCode"];
item.MonitorUnitName = (string)reader["MonitorUnitName"];
item.TemplateId = (int)reader["StockTemplateId"];
item.BearContract = (string)reader["BearContract"];
item.PortfolioId = (int)reader["PortfolioId"];
item.PortfolioCode = (string)reader["PortfolioCode"];
item.PortfolioName = (string)reader["PortfolioName"];
item.AccountCode = (string)reader["AccountCode"];
item.AccountName = (string)reader["AccountName"];
item.TemplateName = (string)reader["TemplateName"];
item.Notes = (string)reader["Notes"];
if (reader["CreatedDate"] != null && reader["CreatedDate"] != DBNull.Value)
{
item.CreatedDate = (DateTime)reader["CreatedDate"];
}
if (reader["ModifiedDate"] != null && reader["ModifiedDate"] != DBNull.Value)
{
item.ModifiedDate = (DateTime)reader["ModifiedDate"];
}
if (reader["StartDate"] != null && reader["StartDate"] != DBNull.Value)
{
item.DStartDate = (DateTime)reader["StartDate"];
}
if (reader["EndDate"] != null && reader["EndDate"] != DBNull.Value)
{
item.DEndDate = (DateTime)reader["EndDate"];
}
if (reader["CancelDate"] != null && reader["CancelDate"] != DBNull.Value)
{
item.CancelDate = (DateTime)reader["CancelDate"];
}
if (reader["ModifiedCause"] != null && reader["ModifiedCause"] != DBNull.Value)
{
item.ModifiedCause = (string)reader["ModifiedCause"];
}
if (reader["CancelCause"] != null && reader["CancelCause"] != DBNull.Value)
{
item.CancelCause = (string)reader["CancelCause"];
}
return(item);
}
/// <summary>
/// Submit a new the TradeCommand to open the position. It will create a new row in the tradecommand table.
/// It will check whether the tradeinstance is existed and it will create a new tradeinstance if there is no one.
/// </summary>
/// <param name="openItem">An object of OpenPositionItem contains some basic information, such as portfolio,
/// monitor, instancecode, entrust direction.
/// </param>
/// <param name="secuItems">A list of detailed securities will be entrusted.</param>
/// <param name="startDate">The trade command start date and time.</param>
/// <param name="endDate">The trade command end date and time.</param>
/// <returns>An integer value to indicate whether it is successful or fail. A positive value means success.
/// Otherwise failure.</returns>
public int SubmitOpenPosition(OpenPositionItem openItem, List <OpenPositionSecurityItem> secuItems, DateTime startDate, DateTime endDate)
{
int instanceId = -1;
string instanceCode = openItem.InstanceCode;
var instance = _tradeInstanceBLL.GetInstance(instanceCode);
if (instance != null && !string.IsNullOrEmpty(instance.InstanceCode) && instance.InstanceCode.Equals(instanceCode))
{
instanceId = instance.InstanceId;
instance.OperationCopies += openItem.Copies;
_tradeInstanceBLL.Update(instance, secuItems);
}
else
{
Model.UI.TradeInstance tradeInstance = new Model.UI.TradeInstance
{
InstanceCode = instanceCode,
PortfolioId = openItem.PortfolioId,
MonitorUnitId = openItem.MonitorId,
TemplateId = openItem.TemplateId,
StockDirection = EntrustDirection.BuySpot,
FuturesContract = openItem.FuturesContract,
FuturesDirection = EntrustDirection.SellOpen,
OperationCopies = openItem.Copies,
StockPriceType = StockPriceType.NoLimit,
FuturesPriceType = FuturesPriceType.NoLimit,
Status = TradeInstanceStatus.Active,
};
tradeInstance.Owner = LoginManager.Instance.GetUserId();
instanceId = _tradeInstanceBLL.Create(tradeInstance, secuItems);
}
int ret = -1;
if (instanceId > 0)
{
//success! Will send generate TradingCommand
Model.Database.TradeCommand cmdItem = new Model.Database.TradeCommand
{
InstanceId = instanceId,
ECommandType = CommandType.Arbitrage,
EExecuteType = ExecuteType.OpenPosition,
CommandNum = openItem.Copies,
EStockDirection = EntrustDirection.BuySpot,
EFuturesDirection = EntrustDirection.SellOpen,
EEntrustStatus = EntrustStatus.NoExecuted,
EDealStatus = DealStatus.NoDeal,
ModifiedTimes = 1,
DStartDate = startDate,
DEndDate = endDate,
Notes = openItem.Notes,
};
var cmdSecuItems = GetSelectCommandSecurities(openItem.MonitorId, -1, secuItems);
ret = SubmitInternal(cmdItem, cmdSecuItems);
}
else
{
//TODO: error message
}
return(ret);
}
/// <summary>
/// Create the TradeCommand and TradeCommandSecurity by Transaction.
/// </summary>
/// <param name="cmdItem"></param>
/// <param name="secuItems"></param>
/// <returns>CommandId</returns>
public int Create(Model.Database.TradeCommand cmdItem, List <TradeCommandSecurity> secuItems)
{
var dbCommand = _dbHelper.GetCommand();
_dbHelper.Open(dbCommand);
//use transaction to execute
DbTransaction transaction = dbCommand.Connection.BeginTransaction();
dbCommand.Transaction = transaction;
dbCommand.CommandType = System.Data.CommandType.StoredProcedure;
int ret = -1;
int commandId = -1;
try
{
dbCommand.CommandText = SP_CreateTradeCommand;
_dbHelper.AddInParameter(dbCommand, "@InstanceId", System.Data.DbType.Int32, cmdItem.InstanceId);
_dbHelper.AddInParameter(dbCommand, "@CommandNum", System.Data.DbType.Int32, cmdItem.CommandNum);
_dbHelper.AddInParameter(dbCommand, "@CommandType", System.Data.DbType.Int32, cmdItem.ECommandType);
_dbHelper.AddInParameter(dbCommand, "@ExecuteType", System.Data.DbType.Int32, cmdItem.EExecuteType);
_dbHelper.AddInParameter(dbCommand, "@StockDirection", System.Data.DbType.Int32, (int)cmdItem.EStockDirection);
_dbHelper.AddInParameter(dbCommand, "@FuturesDirection", System.Data.DbType.Int32, (int)cmdItem.EFuturesDirection);
_dbHelper.AddInParameter(dbCommand, "@EntrustStatus", System.Data.DbType.Int32, (int)cmdItem.EEntrustStatus);
_dbHelper.AddInParameter(dbCommand, "@DealStatus", System.Data.DbType.Int32, (int)cmdItem.EDealStatus);
_dbHelper.AddInParameter(dbCommand, "@SubmitPerson", System.Data.DbType.Int32, cmdItem.SubmitPerson);
//command time
DateTime now = DateTime.Now;
_dbHelper.AddInParameter(dbCommand, "@CreatedDate", System.Data.DbType.DateTime, now);
_dbHelper.AddInParameter(dbCommand, "@StartDate", System.Data.DbType.DateTime, cmdItem.DStartDate);
_dbHelper.AddInParameter(dbCommand, "@EndDate", System.Data.DbType.DateTime, cmdItem.DEndDate);
_dbHelper.AddInParameter(dbCommand, "@Notes", System.Data.DbType.String, cmdItem.Notes);
_dbHelper.AddReturnParameter(dbCommand, "@return", System.Data.DbType.Int32);
ret = dbCommand.ExecuteNonQuery();
if (ret >= 0)
{
if (ret > 0)
{
commandId = (int)dbCommand.Parameters["@return"].Value;
cmdItem.CommandId = commandId;
}
foreach (var secuItem in secuItems)
{
dbCommand.Parameters.Clear();
dbCommand.CommandText = SP_CreateTradingSecurity;
secuItem.CommandId = commandId;
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, secuItem.CommandId);
_dbHelper.AddInParameter(dbCommand, "@SecuCode", System.Data.DbType.String, secuItem.SecuCode);
_dbHelper.AddInParameter(dbCommand, "@SecuType", System.Data.DbType.Int32, (int)secuItem.SecuType);
//_dbHelper.AddInParameter(dbCommand, "@WeightAmount", System.Data.DbType.Int32, secuItem.WeightAmount);
_dbHelper.AddInParameter(dbCommand, "@CommandAmount", System.Data.DbType.Int32, secuItem.CommandAmount);
_dbHelper.AddInParameter(dbCommand, "@CommandDirection", System.Data.DbType.Int32, (int)secuItem.EDirection);
_dbHelper.AddInParameter(dbCommand, "@CommandPrice", System.Data.DbType.Double, secuItem.CommandPrice);
//string newid = string.Empty;
ret = dbCommand.ExecuteNonQuery();
}
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
//TODO: add log
logger.Error(ex);
ret = -1;
throw;
}
finally
{
_dbHelper.Close(dbCommand);
transaction.Dispose();
}
return(commandId);
}
public int Update(Model.Database.TradeCommand cmdItem, List <TradeCommandSecurity> modifiedSecuItems, List <TradeCommandSecurity> cancelSecuItems)
{
var dbCommand = _dbHelper.GetCommand();
_dbHelper.Open(dbCommand);
//use transaction to execute
DbTransaction transaction = dbCommand.Connection.BeginTransaction();
dbCommand.Transaction = transaction;
dbCommand.CommandType = System.Data.CommandType.StoredProcedure;
int ret = -1;
int commandId = cmdItem.CommandId;
try
{
dbCommand.CommandText = SP_ModifyTradeCommand;
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, commandId);
_dbHelper.AddInParameter(dbCommand, "@CommandStatus", System.Data.DbType.Int32, (int)cmdItem.ECommandStatus);
_dbHelper.AddInParameter(dbCommand, "@ModifiedDate", System.Data.DbType.DateTime, cmdItem.ModifiedDate);
_dbHelper.AddInParameter(dbCommand, "@StartDate", System.Data.DbType.DateTime, cmdItem.DStartDate);
_dbHelper.AddInParameter(dbCommand, "@EndDate", System.Data.DbType.DateTime, cmdItem.DEndDate);
string notes = (cmdItem.Notes != null) ? cmdItem.Notes : string.Empty;
_dbHelper.AddInParameter(dbCommand, "@Notes", System.Data.DbType.String, notes);
string modifiedCause = (cmdItem.ModifiedCause != null) ? cmdItem.ModifiedCause : string.Empty;
_dbHelper.AddInParameter(dbCommand, "@ModifiedCause", System.Data.DbType.String, modifiedCause);
string cancelCause = (cmdItem.CancelCause != null) ? cmdItem.CancelCause : string.Empty;
_dbHelper.AddInParameter(dbCommand, "@CancelCause", System.Data.DbType.String, cancelCause);
ret = dbCommand.ExecuteNonQuery();
if (ret >= 0)
{
foreach (var secuItem in modifiedSecuItems)
{
dbCommand.Parameters.Clear();
dbCommand.CommandText = SP_ModifyTradingSecurity;
secuItem.CommandId = commandId;
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, commandId);
_dbHelper.AddInParameter(dbCommand, "@SecuCode", System.Data.DbType.String, secuItem.SecuCode);
_dbHelper.AddInParameter(dbCommand, "@SecuType", System.Data.DbType.Int32, (int)secuItem.SecuType);
//_dbHelper.AddInParameter(dbCommand, "@WeightAmount", System.Data.DbType.Int32, secuItem.WeightAmount);
_dbHelper.AddInParameter(dbCommand, "@CommandAmount", System.Data.DbType.Int32, secuItem.CommandAmount);
_dbHelper.AddInParameter(dbCommand, "@CommandDirection", System.Data.DbType.Int32, (int)secuItem.EDirection);
_dbHelper.AddInParameter(dbCommand, "@CommandPrice", System.Data.DbType.Double, secuItem.CommandPrice);
//string newid = string.Empty;
ret = dbCommand.ExecuteNonQuery();
}
foreach (var secuItem in cancelSecuItems)
{
dbCommand.Parameters.Clear();
dbCommand.CommandText = SP_DeleteTradingSecurity;
secuItem.CommandId = commandId;
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, commandId);
_dbHelper.AddInParameter(dbCommand, "@SecuCode", System.Data.DbType.String, secuItem.SecuCode);
_dbHelper.AddInParameter(dbCommand, "@SecuType", System.Data.DbType.Int32, (int)secuItem.SecuType);
//string newid = string.Empty;
ret = dbCommand.ExecuteNonQuery();
}
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
//TODO: add log
logger.Error(ex);
ret = -1;
throw;
}
finally
{
_dbHelper.Close(dbCommand);
transaction.Dispose();
}
return(commandId);
}
public int Create(Model.Database.TradeCommand tradeCommand, List <TradeCommandSecurity> securities)
{
var dbCommand = _dbHelper.GetCommand();
_dbHelper.Open(dbCommand);
//use transaction to execute
DbTransaction transaction = dbCommand.Connection.BeginTransaction();
dbCommand.Transaction = transaction;
dbCommand.CommandType = System.Data.CommandType.StoredProcedure;
int ret = -1;
try
{
//delete all old one
dbCommand.CommandText = SP_CreateArchiveTradeCommand;
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, tradeCommand.CommandId);
_dbHelper.AddInParameter(dbCommand, "@InstanceId", System.Data.DbType.Int32, tradeCommand.InstanceId);
_dbHelper.AddInParameter(dbCommand, "@CommandNum", System.Data.DbType.Int32, tradeCommand.CommandNum);
_dbHelper.AddInParameter(dbCommand, "@ModifiedTimes", System.Data.DbType.Int32, tradeCommand.ModifiedTimes);
_dbHelper.AddInParameter(dbCommand, "@CommandType", System.Data.DbType.Int32, (int)tradeCommand.ECommandType);
_dbHelper.AddInParameter(dbCommand, "@ExecuteType", System.Data.DbType.Int32, (int)tradeCommand.EExecuteType);
_dbHelper.AddInParameter(dbCommand, "@StockDirection", System.Data.DbType.Int32, (int)tradeCommand.EStockDirection);
_dbHelper.AddInParameter(dbCommand, "@FuturesDirection", System.Data.DbType.Int32, (int)tradeCommand.EFuturesDirection);
_dbHelper.AddInParameter(dbCommand, "@CommandStatus", System.Data.DbType.Int32, (int)tradeCommand.ECommandStatus);
_dbHelper.AddInParameter(dbCommand, "@EntrustStatus", System.Data.DbType.Int32, (int)tradeCommand.EEntrustStatus);
_dbHelper.AddInParameter(dbCommand, "@DealStatus", System.Data.DbType.Int32, (int)tradeCommand.EDealStatus);
_dbHelper.AddInParameter(dbCommand, "@SubmitPerson", System.Data.DbType.Int32, tradeCommand.SubmitPerson);
_dbHelper.AddInParameter(dbCommand, "@CreatedDate", System.Data.DbType.DateTime, tradeCommand.CreatedDate);
_dbHelper.AddInParameter(dbCommand, "@ModifiedDate", System.Data.DbType.DateTime, tradeCommand.ModifiedDate);
_dbHelper.AddInParameter(dbCommand, "@ArchiveDate", System.Data.DbType.DateTime, DateTime.Now);
_dbHelper.AddInParameter(dbCommand, "@StartDate", System.Data.DbType.DateTime, tradeCommand.DStartDate);
_dbHelper.AddInParameter(dbCommand, "@EndDate", System.Data.DbType.DateTime, tradeCommand.DEndDate);
_dbHelper.AddInParameter(dbCommand, "@ModifiedCause", System.Data.DbType.String, tradeCommand.ModifiedCause);
_dbHelper.AddInParameter(dbCommand, "@CancelCause", System.Data.DbType.String, tradeCommand.CancelCause);
_dbHelper.AddInParameter(dbCommand, "@Notes", System.Data.DbType.String, tradeCommand.Notes);
_dbHelper.AddReturnParameter(dbCommand, "@return", System.Data.DbType.Int32);
ret = dbCommand.ExecuteNonQuery();
if (ret >= 0)
{
dbCommand.CommandText = SP_CreateArchiveTradeCommand;
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, tradeCommand.CommandId);
int archiveId = -1;
if (ret > 0)
{
archiveId = (int)dbCommand.Parameters["@return"].Value;
}
foreach (var security in securities)
{
dbCommand.Parameters.Clear();
dbCommand.CommandText = SP_CreateArchiveTradeCommandSecurity;
_dbHelper.AddInParameter(dbCommand, "@ArchiveId", System.Data.DbType.Int32, archiveId);
_dbHelper.AddInParameter(dbCommand, "@CommandId", System.Data.DbType.Int32, security.CommandId);
_dbHelper.AddInParameter(dbCommand, "@SecuCode", System.Data.DbType.String, security.SecuCode);
_dbHelper.AddInParameter(dbCommand, "@SecuType", System.Data.DbType.Int32, (int)security.SecuType);
_dbHelper.AddInParameter(dbCommand, "@CommandAmount", System.Data.DbType.Int32, security.CommandAmount);
_dbHelper.AddInParameter(dbCommand, "@CommandDirection", System.Data.DbType.Int32, (int)security.EDirection);
_dbHelper.AddInParameter(dbCommand, "@CommandPrice", System.Data.DbType.Double, security.CommandPrice);
ret = dbCommand.ExecuteNonQuery();
if (ret > 0)
{
//int requetId = (int)dbCommand.Parameters["@return"].Value;
}
}
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
//TODO: add log
logger.Error(ex);
ret = -1;
throw;
}
finally
{
_dbHelper.Close(dbCommand);
transaction.Dispose();
}
return(ret);
}
private int Tracking(ActionType actionType, ResourceType resourceType, int resourceId, Model.Database.TradeCommand cmdItem)
{
int userId = LoginManager.Instance.GetUserId();
int num = 1;
if (cmdItem == null)
{
num = -1;
}
return(_userActionTrackingBLL.Create(userId, actionType, resourceType, resourceId, num, ActionStatus.Normal, JsonUtil.SerializeObject(cmdItem)));
}
