public RequestStatus SendEditPendingRequest(ProtectedOperationContext secCtx, PendingOrder ord)
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.ModifyOrder))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx, true, true))
{
return(RequestStatus.Unauthorized);
}
}
Account account;
var dealer = GetDealerByAccount(ord.AccountID, out account);
if (dealer == null)
{
return(RequestStatus.GroupUnsupported);
}
try
{
var rst = dealer.ModifyPendingOrderRequest(ord);
AccountLogger.InfoFormat(
"SendEditPendingRequest({0}, {1} {2} {3}, {4} at {5}, SL={6}, TP={7}): {8}, пользователь: {9}",
ord.ID, (DealType)ord.Side, ord.PriceSide,
ord.Volume, ord.Symbol, ord.PriceFrom.ToStringUniformPriceFormat(),
ord.StopLoss, ord.TakeProfit,
rst, secCtx.userMachineName);
return(rst);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка дилера {0}: {1}", dealer, ex);
return(RequestStatus.DealerError);
}
}
/// <summary>
/// подписать на портфель
/// отключить остальные подписки
/// если портфель пользовательский - сохранить его
/// </summary>
public RequestStatus SubscribeOnPortfolio(
ProtectedOperationContext secCtx,
string subscriberLogin,
TopPortfolio portfolio,
decimal?maxFee,
AutoTradeSettings tradeAutoSettings)
{
//Logger.InfoFormat("SubscribeOnPortfolio({0})", subscriberLogin);
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.BindToSignal))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.BindToSignal), false))
{
return(RequestStatus.Unauthorized);
}
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
return(walletRepository.SubscribeUserOnPortfolio(ctx, subscriberLogin, portfolio, maxFee, tradeAutoSettings));
}
catch (Exception ex)
{
Logger.Error("Ошибка в SubscribeOnPortfolio()", ex);
return(RequestStatus.ServerError);
}
}
public RequestStatus SendDeletePendingOrderRequest(
ProtectedOperationContext secCtx,
PendingOrder order,
PendingOrderStatus status, int?positionID, string closeReason)
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.CloseOrder))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.ModifyOrder), true))
{
return(RequestStatus.Unauthorized);
}
}
Account account;
var dealer = GetDealerByAccount(order.AccountID, out account);
if (dealer == null)
{
return(RequestStatus.GroupUnsupported);
}
try
{
var rst = dealer.DeletePendingOrderRequest(order, status, positionID, closeReason);
AccountLogger.InfoFormat("SendDeletePendingOrderRequest({0}, {1} {2} {3}): {4}",
order.ID, (DealType)order.Side, order.PriceSide, order.Symbol, rst);
return(rst);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка дилера {0}: {1}", dealer, ex);
return(RequestStatus.DealerError);
}
}
public AuthenticationResponse GetUserAccountsWithDetail(string login, ProtectedOperationContext secCtx,
out List <Account> accounts)
{
accounts = new List <Account>();
try
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.GetAccountDetail))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.GetAccountDetail), false))
{
return(AuthenticationResponse.WrongPassword);
}
}
}
catch (Exception ex)
{
Logger.Error("GetUserAccountsWithDetail - PermitUserOperation error", ex);
return(AuthenticationResponse.ServerError);
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
try
{
var user = ctx.PLATFORM_USER.FirstOrDefault(ac => ac.Login == login);
if (user == null)
{
return(AuthenticationResponse.InvalidAccount);
}
accounts = (from ar in ctx.PLATFORM_USER_ACCOUNT
join ac in ctx.ACCOUNT on ar.Account equals ac.ID
where ar.PlatformUser == user.ID
select ac).ToList().Select(LinqToEntity.DecorateAccount).ToList();
}
catch (Exception ex)
{
Logger.Error("Ошибка в GetUserAccountsWithDetail", ex);
return(AuthenticationResponse.ServerError);
}
return(AuthenticationResponse.OK);
}
}
catch (Exception ex)
{
Logger.Error("GetUserAccountsWithDetail - error making DB context", ex);
return(AuthenticationResponse.ServerError);
}
}
public RequestStatus UnsubscribePortfolio(ProtectedOperationContext secCtx,
string subscriberLogin, bool deletePortfolio, bool deleteSubscriptions)
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.GetAccountDetail))
{
if (
!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(
UserOperation.BindToSignal), false))
{
return(RequestStatus.Unauthorized);
}
}
using (var ctx = DatabaseContext.Instance.Make())
return(walletRepository.UnsubscribeUserFromPortfolio(ctx, subscriberLogin, deletePortfolio, deleteSubscriptions));
}
public RequestStatus ApplyPortfolioTradeSettings(ProtectedOperationContext secCtx, string login,
AutoTradeSettings sets)
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.BindToSignal))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.BindToSignal), false))
{
return(RequestStatus.Unauthorized);
}
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var user = ctx.PLATFORM_USER.FirstOrDefault(u => u.Login == login);
if (user == null)
{
return(RequestStatus.Unauthorized);
}
var subsription = ctx.USER_TOP_PORTFOLIO.FirstOrDefault(u => u.User == user.ID);
if (subsription == null)
{
return(RequestStatus.CommonError);
}
subsription.AutoTrade = sets.TradeAuto;
subsription.MaxLeverage = sets.MaxLeverage;
subsription.PercentLeverage = sets.PercentLeverage;
subsription.HedgingOrdersEnabled = sets.HedgingOrdersEnabled;
subsription.FixedVolume = sets.FixedVolume;
subsription.MinVolume = sets.MinVolume;
subsription.MaxVolume = sets.MaxVolume;
subsription.VolumeRound = (int?)sets.VolumeRound;
subsription.StepVolume = sets.StepVolume;
subsription.TargetAccount = sets.TargetAccount;
ctx.SaveChanges();
return(RequestStatus.OK);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в ApplyPortfolioTradeSettings()", ex);
return(RequestStatus.ServerError);
}
}
public AuthenticationResponse GetUserAccounts(string login, ProtectedOperationContext secCtx,
out List <int> accounts, out List <AccountRights> roles)
{
accounts = new List <int>();
roles = new List <AccountRights>();
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.GetAccountDetail))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.GetAccountDetail), false))
{
return(AuthenticationResponse.WrongPassword);
}
}
using (var ctx = DatabaseContext.Instance.Make())
{
try
{
var user = ctx.PLATFORM_USER.FirstOrDefault(ac => ac.Login == login);
if (user == null)
{
return(AuthenticationResponse.InvalidAccount);
}
var accountRoles = (from ar in ctx.PLATFORM_USER_ACCOUNT
where ar.PlatformUser == user.ID
select ar);
foreach (var acRole in accountRoles)
{
accounts.Add(acRole.Account);
roles.Add((AccountRights)acRole.RightsMask);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в GetUserAccounts", ex);
return(AuthenticationResponse.ServerError);
}
return(AuthenticationResponse.OK);
}
}
public AuthenticationResponse ChangePassword(ProtectedOperationContext ctx, string login, string newPassword)
{
try
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.ChangeAccountSettings))
{
if (!UserSessionStorage.Instance.PermitUserOperation(ctx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.ChangeAccountSettings), false))
{
return(AuthenticationResponse.NotAuthorized);
}
}
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка в AuthenticationResponse({0}): {1}", login, ex);
return(AuthenticationResponse.ServerError);
}
using (var dbContext = DatabaseContext.Instance.Make())
{
try
{
var user = dbContext.PLATFORM_USER.FirstOrDefault(u => u.Login == login);
if (user == null)
{
return(AuthenticationResponse.InvalidAccount);
}
user.Password = newPassword;
dbContext.SaveChanges();
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка в ChangePassword({0}) : {1}", login, ex);
return(AuthenticationResponse.ServerError);
}
}
return(AuthenticationResponse.OK);
}
public RequestStatus QueryReadonlyUserForAccount(ProtectedOperationContext secCtx, int accountId,
out PlatformUser user)
{
user = null;
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.GetAccountDetail))
{
if (
!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(
UserOperation.GetAccountDetail), false))
{
return(RequestStatus.Unauthorized);
}
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var existingUserRecord = ctx.PLATFORM_USER_ACCOUNT.FirstOrDefault(ua => ua.Account == accountId &&
ua.RightsMask ==
(int)AccountRights.Просмотр);
if (existingUserRecord != null)
{
user = LinqToEntity.DecoratePlatformUser(ctx.PLATFORM_USER.First(u => u.ID == existingUserRecord.PlatformUser));
}
return(RequestStatus.OK);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в QueryReadonlyUserForAccount()", ex);
return(RequestStatus.CommonError);
}
}
public List <UserEvent> GetUserEvents(ProtectedOperationContext ctx, string userLogin,
bool deleteReceivedEvents)
{
var evList = new List <UserEvent>();
try
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.GetAccountDetail))
{
if (!UserSessionStorage.Instance.PermitUserOperation(ctx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.GetAccountDetail), true))
{
return(evList);
}
}
}
catch (Exception ex)
{
Logger.Error("GetUserEvents() - PermitUserOperation error", ex);
return(evList);
}
return(UserEventStorage.Instance.GetUserEvents(userLogin));
}
public RequestStatus SendCloseRequest(ProtectedOperationContext secCtx,
int accountId, int orderId, PositionExitReason reason)
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.CloseOrder))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.ModifyOrder), true))
{
return(RequestStatus.Unauthorized);
}
}
// получить позу
POSITION order;
using (var ctx = DatabaseContext.Instance.Make())
{
order = ctx.POSITION.FirstOrDefault(p => p.ID == orderId && p.AccountID == accountId);
if (order != null)
{
if (order.State != (int)PositionState.Opened)
{
return(RequestStatus.BadRequest);
}
}
}
if (order == null)
{
return(RequestStatus.NotFound);
}
AccountLogger.InfoFormat("Вызов SendCloseRequest(acc #{0}, orderId #{1}, us. machine \"{2}\")",
accountId, orderId, secCtx.userMachineName);
return(SendCloseRequest(order, reason));
}
public CreateReadonlyUserRequestStatus MakeOrDeleteReadonlyUser(ProtectedOperationContext secCtx,
int accountId, bool makeNew, string pwrd, out PlatformUser user)
{
user = null;
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.ChangeAccountSettings))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.ChangeAccountSettings), false))
{
return(CreateReadonlyUserRequestStatus.NotPermitted);
}
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var existingUserRecord = ctx.PLATFORM_USER_ACCOUNT.FirstOrDefault(ua => ua.Account == accountId &&
ua.RightsMask ==
(int)AccountRights.Просмотр);
if (!makeNew)
{
// удалить
if (existingUserRecord == null)
{
return(CreateReadonlyUserRequestStatus.UserNotFound);
}
ctx.PLATFORM_USER_ACCOUNT.Remove(existingUserRecord);
// удалить самого пользователя платформы
var userRow = ctx.PLATFORM_USER.First(u => u.ID == existingUserRecord.PlatformUser);
ctx.PLATFORM_USER.Remove(userRow);
ctx.SaveChanges();
return(CreateReadonlyUserRequestStatus.Success);
}
// создать нового или редактировать старого
if (existingUserRecord != null)
{
var userRow = ctx.PLATFORM_USER.First(u => u.ID == existingUserRecord.PlatformUser);
user = LinqToEntity.DecoratePlatformUser(userRow);
userRow.Password = pwrd;
ctx.SaveChanges();
return(CreateReadonlyUserRequestStatus.Success);
}
// таки создать нового
var newUser = new PLATFORM_USER
{
Title = "Read" + accountId,
Login = "******" + accountId,
Password = pwrd,
RegistrationDate = DateTime.Now,
RoleMask = (int)UserRole.Trader
};
user = LinqToEntity.DecoratePlatformUser(newUser);
var usr = ctx.PLATFORM_USER.Add(newUser);
ctx.SaveChanges();
ctx.PLATFORM_USER_ACCOUNT.Add(new PLATFORM_USER_ACCOUNT
{
Account = accountId,
PlatformUser = usr.ID,
RightsMask = (int)AccountRights.Просмотр
});
ctx.SaveChanges();
return(CreateReadonlyUserRequestStatus.Success);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в CreateReadonlyUserRequestStatus()", ex);
return(CreateReadonlyUserRequestStatus.CommonError);
}
}
/// <summary>
/// вернуть акаунты, которыми трейдер владеет!
/// опционально - исключив демки
/// по каждому акаунту посчитать средства и резерв. маржу
/// </summary>
public AuthenticationResponse GetUserOwnedAccountsWithActualBalance(string login,
ProtectedOperationContext secCtx, bool realOnly, out List <Account> accounts)
{
accounts = new List <Account>();
try
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.GetAccountDetail))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.GetAccountDetail), false))
{
return(AuthenticationResponse.WrongPassword);
}
}
}
catch (Exception ex)
{
Logger.Error("GetUserOwnedAccountsWithActualBalance - PermitUserOperation error", ex);
return(AuthenticationResponse.ServerError);
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
try
{
var user = ctx.PLATFORM_USER.FirstOrDefault(ac => ac.Login == login);
if (user == null)
{
return(AuthenticationResponse.InvalidAccount);
}
var accountRoles = (from ar in ctx.PLATFORM_USER_ACCOUNT
where ar.PlatformUser == user.ID &&
ar.RightsMask == (int)AccountRights.Управление
select ar);
foreach (var acRole in accountRoles)
{
var acId = acRole.Account;
var acc = realOnly
? ctx.ACCOUNT.FirstOrDefault(a => a.ID == acId && a.ACCOUNT_GROUP.IsReal)
: ctx.ACCOUNT.FirstOrDefault(a => a.ID == acId);
if (acc == null)
{
continue;
}
// заполнить данные о актуальном балансе и т.д. и т.п.
decimal equity, reservedMargin, exposure;
profitCalculator.CalculateAccountExposure(acId, out equity, out reservedMargin,
out exposure, TradeSharp.Contract.Util.BL.QuoteStorage.Instance.ReceiveAllData(),
ManagerAccount.Instance, accountRepository.GetAccountGroup);
var accountDec = LinqToEntity.DecorateAccount(acc);
accountDec.Equity = equity;
accountDec.UsedMargin = reservedMargin;
accounts.Add(accountDec);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в GetUserOwnedAccountsWithActualBalance", ex);
return(AuthenticationResponse.ServerError);
}
return(AuthenticationResponse.OK);
}
}
catch (Exception ex)
{
Logger.Error("GetUserOwnedAccountsWithActualBalance - error making DB context", ex);
return(AuthenticationResponse.ServerError);
}
}
/// <summary>
/// закрыть все сделки по инструменту
/// маржинальные требования не проверяются
/// </summary>
public RequestStatus SendCloseByTickerRequest(ProtectedOperationContext secCtx,
int accountId, string ticker, PositionExitReason reason)
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.CloseOrder))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(
UserOperation.ModifyOrder), true))
{
return(RequestStatus.Unauthorized);
}
}
List <MarketOrder> orders;
using (var ctx = DatabaseContext.Instance.Make())
{
orders = ctx.POSITION.Where(p => p.Symbol == ticker &&
p.AccountID == accountId).ToList().Select(LinqToEntity.DecorateOrder).ToList();
if (orders.Count == 0)
{
return(RequestStatus.OK);
}
}
// дилер, обрабатывающий запрос
Account account;
var dealer = GetDealerByAccount(orders[0].AccountID, out account);
if (dealer == null)
{
return(RequestStatus.GroupUnsupported);
}
// сформировать запросы на закрытие для дилера
var results = new List <RequestStatus>();
foreach (var order in orders)
{
try
{
var res = dealer.SendCloseRequest(order, reason);
if (res == RequestStatus.OK)
{
Logger.InfoFormat("Ордер {0} закрыт, счет {1} символ {2}, объем {3}, тип {4}", order.ID,
order.AccountID, order.Symbol, order.Volume, order.Side == 1 ? "buy" : "sell");
}
else
{
Logger.ErrorFormat("Ошибка закрытия ордера {0} - ответ дилера:{1}", order.ID, res);
}
results.Add(res);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка дилера {0}: {1}", dealer, ex);
return(RequestStatus.DealerError);
}
}
return(results.Mode());
}
public RequestStatus SendNewOrderRequest(
ProtectedOperationContext secCtx,
int requestUniqueId,
MarketOrder order,
OrderType orderType,
decimal requestedPrice,
decimal slippagePoints)
{
// уникальность запроса
if (RequestIdStorage.Instance.RequestsIsDoubled(order.AccountID, requestUniqueId))
{
return(RequestStatus.DoubledRequest);
}
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.MakeNewOrder))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.ModifyOrder), true))
{
return(RequestStatus.Unauthorized);
}
}
IDealer dealer;
Account account;
decimal equity;
// объем входа и тикер
if (order.Volume <= 0)
{
return(RequestStatus.BadRequest);
}
if (!DalSpot.Instance.GetTickerNames().Contains(order.Symbol))
{
return(RequestStatus.BadRequest);
}
try
{
// проверить маржинальные требования и предел плеча
if (!tradeManager.IsEnterEnabled(order.AccountID, order.Symbol, order.Side, order.Volume, out equity))
{
return(RequestStatus.MarginOrLeverageExceeded);
}
// по группе счета выбрать дилера и отправить ему запрос
dealer = GetDealerByAccount(order.AccountID, out account);
if (dealer == null)
{
return(RequestStatus.GroupUnsupported);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в SendNewOrderRequest", ex);
return(RequestStatus.ServerError);
}
try
{
var orderStatus = dealer.SendNewOrderRequest(account, order, orderType,
requestedPrice, slippagePoints);
AccountLogger.InfoFormat("Вызов SendNewOrderRequest(acc #{0}, {1} {2}, us. machine \"{3}\")",
order.AccountID, order.Symbol, order.Volume, secCtx.userMachineName);
return(orderStatus);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка дилера {0}: {1}", dealer, ex);
return(RequestStatus.DealerError);
}
}
/// <summary>
/// "отправить", точнее - сохранить торговый сигнал
/// </summary>
public void SendTradeSignalEvent(ProtectedOperationContext secCtx,
int accountId, int serviceId, UserEvent acEvent)
{
try
{
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.SendTradeSignal))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.SendTradeSignal), true))
{
Logger.InfoFormat("SendTradeSignalEvent (ac={0}) - not permitted", accountId);
return;
}
}
}
catch (Exception ex)
{
Logger.Error("GetUserEvents() - SendTradeSignalEvent error", ex);
return;
}
acEvent.Code = AccountEventCode.TradeSignal;
acEvent.Time = DateTime.Now;
using (var ctx = DatabaseContext.Instance.Make())
{
try
{
// проверить авторские права счета accountId на кат. tradeSignalCategory
var acCat = ctx.SERVICE.FirstOrDefault(u => u.AccountId == accountId && u.ID == serviceId);
if (acCat == null)
{
Logger.InfoFormat("SendTradeSignalEvent (ac={0}) - no rights record", accountId);
return;
}
// получить подписчиков
var subs = from subscriber in ctx.SUBSCRIPTION
where subscriber.Service == serviceId
select subscriber;
var newEvents = new List <UserEvent>();
foreach (var sub in subs)
{
var newEvt = acEvent.Copy();
newEvt.User = sub.User;
newEvents.Add(newEvt);
}
//Logger.InfoFormat("Сообщение {0} добавлено в очередь {1} подписчикам", acEvent, newEvents.Count);
// создать ивент для самого отправителя
var ownerEvt = acEvent.Copy();
ownerEvt.User = acCat.User;
ownerEvt.Action = AccountEventAction.DoNothing;
ownerEvt.Code = AccountEventCode.TradeSignal;
ownerEvt.Title = "Торг. сигнал отправлен";
ownerEvt.Text = ownerEvt.Text.Length > 35 ? ownerEvt.Text.Substring(20) + "..." : ownerEvt.Text;
newEvents.Add(ownerEvt);
UserEventStorage.Instance.PushEvents(newEvents);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка в ServerManagerAccount.SendTradeSignalEvent(ac={0}): {1}",
accountId, ex);
}
}
}
public RequestStatus SendNewPendingOrderRequest(
ProtectedOperationContext secCtx,
int requestUniqueId,
PendingOrder order)
{
try
{
// уникальность запроса
if (RequestIdStorage.Instance.RequestsIsDoubled(order.AccountID, requestUniqueId))
{
return(RequestStatus.DoubledRequest);
}
if (UserOperationRightsStorage.IsProtectedOperation(UserOperation.MakeNewOrder))
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx,
UserOperationRightsStorage.IsTradeOperation(UserOperation.ModifyOrder), true))
{
return(RequestStatus.Unauthorized);
}
}
// проверить -
// время не должно быть вне указанных пределов
if (order.TimeFrom >= order.TimeTo || DateTime.Now >= order.TimeTo)
{
return(RequestStatus.WrongTime);
}
// определить автоматом тип ордера (STOP - LIMIT)
var pricePair = QuoteStorage.Instance.ReceiveValue(order.Symbol);
if (pricePair == null)
{
Logger.ErrorFormat("Невозможно создать отложенный ордер (счет {0}, {1}) - нет цены",
order.AccountID, order.Symbol);
return(RequestStatus.NoPrice);
}
var price = order.Side > 0 ? pricePair.ask : pricePair.bid;
var delta = DalSpot.Instance.GetPointsValue(order.Symbol, Math.Abs(price - order.PriceFrom));
if (delta < 1)
{
Logger.ErrorFormat("Отложенный ордер (счет {0}, {1}) - близко к рынку {2}",
order.AccountID, order.Symbol, price);
return(RequestStatus.WrongPrice);
}
// проверить правильность задания интервалов цен
var priceCorrect = true;
if (order.PriceSide == PendingOrderType.Stop && order.Side > 0)
{
priceCorrect = order.PriceTo != null
? price <order.PriceFrom && order.PriceTo.Value> order.PriceFrom
: price < order.PriceFrom;
}
else if (order.PriceSide == PendingOrderType.Limit && order.Side > 0)
{
priceCorrect = order.PriceTo != null
? price > order.PriceFrom && order.PriceTo.Value <order.PriceFrom
: price> order.PriceFrom;
}
else if (order.PriceSide == PendingOrderType.Stop && order.Side < 0)
{
priceCorrect = order.PriceTo != null
? price > order.PriceFrom && order.PriceTo.Value <order.PriceFrom
: price> order.PriceFrom;
}
else
{
priceCorrect = order.PriceTo != null
? price <order.PriceFrom && order.PriceTo.Value> order.PriceFrom
: price < order.PriceFrom;
}
if (!priceCorrect)
{
Logger.ErrorFormat("Отложенный ордер (счет {0}, {1}) - неверные цены {2} [{3}-{4}]",
order.AccountID, order.Symbol, price, order.PriceFrom, order.PriceTo ?? 0);
return(RequestStatus.WrongPrice);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в SendNewPendingOrderRequest", ex);
return(RequestStatus.ServerError);
}
// по группе счета выбрать дилера и отправить ему запрос
Account account;
var dealer = GetDealerByAccount(order.AccountID, out account);
if (dealer == null)
{
return(RequestStatus.GroupUnsupported);
}
try
{
AccountLogger.InfoFormat("Вызов SendNewPendingOrderRequest(acc #{0}, {1} {2}, us. machine \"{3}\")",
order.AccountID, order.Symbol, order.Volume, secCtx.userMachineName);
return(dealer.SendNewPendingOrderRequest(account, order));
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка дилера {0}: {1}", dealer, ex);
return(RequestStatus.DealerError);
}
}
