private void LoadEventsFromDb()
{
try
{
var plainList = new List <UserEvent>();
using (var ctx = DatabaseContext.Instance.Make())
{
foreach (var evt in ctx.USER_EVENT)
{
plainList.Add(LinqToEntity.DecorateUserEvent(evt));
}
// удалить старые сообщения
ctx.ClearOldUserEvents(new DateTime(1900, 1, 1));
}
// заполнить список
var dic = plainList.GroupBy(x => x.User).ToDictionary(gdc => gdc.Key, gdc => gdc.ToList());
userEvent.Clear();
foreach (var evt in dic)
{
userEvent.UpdateValues(evt.Key, evt.Value);
}
Logger.InfoFormat("Прочитано {0} записей USER_EVENT", plainList.Count);
}
catch (Exception ex)
{
Logger.Error("Ошибка в UserEventStorage.LoadEventsFromDb()", ex);
}
}
public PaymentSystemTransfer GetTransferById(int id)
{
PaymentSystemTransfer result;
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var ps = (from x in ctx.PAYMENT_SYSTEM_TRANSFER
where x.Id == id
select new { transfer = x,
paySys = x.USER_PAYMENT_SYSTEM != null ? (PaymentSystem)x.USER_PAYMENT_SYSTEM.SystemPayment : PaymentSystem.Unknown,
wallet = x.USER_PAYMENT_SYSTEM != null ? ctx.WALLET.FirstOrDefault(w => w.User == x.USER_PAYMENT_SYSTEM.UserId) : null }).Single();
result = LinqToEntity.DecoratePaymentSystemTransfer(ps.transfer);
result.Wallet = ps.wallet != null?LinqToEntity.DecorateWallet(ps.wallet) : new Wallet();
result.PaymentSys = ps.paySys;
}
}
catch (Exception ex)
{
Logger.Error("GetUnknownTransfers()", ex);
return(null);
}
return(result);
}
public void Setup()
{
// подготовить свежие котировки
QuoteMaker.FillQuoteStorageWithDefaultValues();
// соединение и тестовые данные
TradeSharpConnectionPersistent.RestoreCsvFilesInMoqDbFolder();
conn = TradeSharpConnectionPersistent.InitializeTradeSharpConnection();
MakeTestData();
// словари
TradeSharpDictionary.Initialize(MoqTradeSharpDictionary.Mock);
// тестируемый менеджер
ManagerTrade.MakeTestInstance(
new Dictionary <string, IDealer>
{
{ testAccount.AccountGroup,
new DemoDealer.DemoDealer(new DealerDescription(), conn.ACCOUNT_GROUP.Select(g => g.Code).ToList()) }
});
managerTrade = ManagerTrade.Instance;
var mockAccountRepository = new Mock <IAccountRepository>();
mockAccountRepository.Setup(s => s.GetAccount(It.IsAny <int>())).Returns(
(int id) => LinqToEntity.DecorateAccount(testAccount));
managerTrade.accountRepository = mockAccountRepository.Object;
managerTrade.orderRepository = OrderRepository.Instance;
}
public ActionResult EditDealerDetails(string code)
{
using (var ctx = DatabaseContext.Instance.Make())
{
return(View(LinqToEntity.DecorateDealerDescription(ctx.DEALER.FirstOrDefault(x => x.Code == code))));
}
}
public AuthenticationResponse GetUserDetail(string login, string password, out PlatformUser userDecorated)
{
userDecorated = null;
using (var dbContext = DatabaseContext.Instance.Make())
{
try
{
var user = dbContext.PLATFORM_USER.FirstOrDefault(u => u.Login == login);
if (user == null)
{
return(AuthenticationResponse.InvalidAccount);
}
if (user.Password != password)
{
return(AuthenticationResponse.WrongPassword);
}
userDecorated = LinqToEntity.DecoratePlatformUser(user);
return(AuthenticationResponse.OK);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка в GetUserDetail({0}) : {1}", login, ex);
return(AuthenticationResponse.ServerError);
}
}
}
private void StoreEventsInDb(object logMsg)
{
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
// удалить старые сообщения
ctx.ClearOldUserEvents(new DateTime(1900, 1, 1));
// сохранить новые
var countTotal = 0;
var events = userEvent.ReceiveAllData();
foreach (var evtList in events)
{
var evtToSave = evtList.Value.Take(100).Reverse().ToList();
countTotal += evtToSave.Count;
foreach (var evt in evtToSave)
{
var usEvt = LinqToEntity.UndecorateUserEvent(evt);
ctx.USER_EVENT.Add(usEvt);
}
}
ctx.SaveChanges();
if ((bool)logMsg)
{
Logger.InfoFormat("Сохранено {0} записей USER_EVENT", countTotal);
}
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в UserEventStorage.StoreEventsInDb()", ex);
}
}
/// <summary>
/// получить список отложенных ордеров
/// </summary>
public RequestStatus GetPendingOrders(int accountId, out List <PendingOrder> orders)
{
orders = new List <PendingOrder>();
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var pendingOrders = from ord in ctx.PENDING_ORDER
where ord.AccountID == accountId
select ord;
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var ord in pendingOrders) // нельзя рефакторить
// ReSharper restore LoopCanBeConvertedToQuery
{
orders.Add(LinqToEntity.DecoratePendingOrder(ord));
}
}
}
catch (Exception ex)
{
Logger.Error("Ошибка при получении списка отложенных ордеров", ex);
return(RequestStatus.ServerError);
}
return(RequestStatus.OK);
}
public void InitTest()
{
// забить котировки
QuoteMaker.FillQuoteStorageWithDefaultValues();
// словари
TradeSharpDictionary.Initialize(MoqTradeSharpDictionary.Mock);
tradeManager = new TradeManager(
null,
null,
QuoteStorage.Instance, accountId =>
{
// ReSharper disable ConvertToLambdaExpression
return(LinqToEntity.DecorateAccountGroup(conn.ACCOUNT.First(a => a.ID == accountId).ACCOUNT_GROUP));
// ReSharper restore ConvertToLambdaExpression
});
// временно удалить файл начального наполнения (открытые ордера)
TradeSharpConnectionPersistent.RestoreCsvFilesInMoqDbFolder();
TradeSharpConnectionPersistent.RenameCsvFilesContainingAccountDataInMoqDbFolder();
conn = TradeSharpConnectionPersistent.InitializeTradeSharpConnection();
MakeTestData();
}
/// <summary>
/// получить закрытые ордера по дате закрытия
/// </summary>
public RequestStatus GetHistoryOrdersByCloseDate(int?accountId, DateTime?startDate,
out List <MarketOrder> orders)
{
using (var ctx = DatabaseContext.Instance.Make())
{
try
{
var positions = from pos in ctx.POSITION_CLOSED
where
pos.AccountID == (accountId ?? pos.AccountID) &&
(pos.TimeExit >= startDate) || (!startDate.HasValue)
select pos;
orders = new List <MarketOrder>();
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var position in positions)
// ReSharper restore LoopCanBeConvertedToQuery
{
orders.Add(LinqToEntity.DecorateOrder(position));
}
return(RequestStatus.OK);
}
catch (Exception ex)
{
orders = null;
Logger.ErrorFormat("Ошибка в GetHistoryOrdersByCloseDate({0}): {1}", accountId, ex);
return(RequestStatus.ServerError);
}
}
}
/// <summary>
/// получить список открытых позиций
/// </summary>
public RequestStatus GetMarketOrders(int accountId, out List <MarketOrder> orders)
{
using (var ctx = DatabaseContext.Instance.Make())
try
{
var positions = from pos in ctx.POSITION
where (pos.State == (int)(PositionState.Opened) || pos.State == (int)(PositionState.StartOpened) ||
pos.State == (int)(PositionState.StartClosed)) && pos.AccountID == accountId
select pos;
orders = new List <MarketOrder>();
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var position in positions)
// ReSharper restore LoopCanBeConvertedToQuery
{
orders.Add(LinqToEntity.DecorateOrder(position));
}
return(RequestStatus.OK);
}
catch (Exception ex)
{
orders = null;
Logger.ErrorFormat("Ошибка в GetMarketOrders({0}): {1}", accountId, ex);
return(RequestStatus.ServerError);
}
}
/// <summary>
/// Добавляем в базу новую сущность
/// </summary>
/// <param name="newTopPortfolio">Объект содержит значения полей для новой сущность</param>
/// <returns></returns>
private static TopPortfolio AddTopPortfolio(TopPortfolioItem newTopPortfolio)
{
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var topPortfolio = new TOP_PORTFOLIO
{
Name = newTopPortfolio.Name,
Criteria = newTopPortfolio.Criteria,
ParticipantCount = newTopPortfolio.ParticipantCount,
DescendingOrder = newTopPortfolio.DescendingOrder,
MarginValue = newTopPortfolio.MarginValue,
ManagedAccount = newTopPortfolio.ManagedAccount
};
ctx.TOP_PORTFOLIO.Add(topPortfolio);
ctx.SaveChanges();
return(LinqToEntity.DecoratePortfolio(topPortfolio));
}
}
catch (Exception ex)
{
Logger.Error("AddTopPortfolio", ex);
return(null);
}
}
public Wallet GetUserWallet(ProtectedOperationContext secCtx, string userLogin)
{
// запрос разрешен?
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx, false, false))
{
return(null);
}
// получить кошелек пользователя и вернуть его
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var queryWallet = from us in ctx.PLATFORM_USER where us.Login == userLogin select us.WALLET;
foreach (var walInf in queryWallet)
{
var wallet = LinqToEntity.DecorateWallet(walInf);
return(wallet);
}
}
}
catch (Exception ex)
{
Logger.ErrorFormat("GetUserWallet({0}) - exception: {1}", userLogin, ex);
}
return(null);
}
public PaymentTransferModel GetTransfers()
{
var result = new PaymentTransferModel();
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var ps = (from x in ctx.PAYMENT_SYSTEM_TRANSFER
where x.Transfer == null
select new { transfer = x,
paySys = x.USER_PAYMENT_SYSTEM != null ? (PaymentSystem)x.USER_PAYMENT_SYSTEM.SystemPayment : PaymentSystem.Unknown,
wallet = x.USER_PAYMENT_SYSTEM != null ? ctx.WALLET.FirstOrDefault(w => w.User == x.USER_PAYMENT_SYSTEM.UserId) : null }).ToList();
foreach (var p in ps)
{
var decorP = LinqToEntity.DecoratePaymentSystemTransfer(p.transfer);
decorP.PaymentSys = p.paySys;
if (p.wallet != null)
{
decorP.Wallet = LinqToEntity.DecorateWallet(p.wallet);
}
result.UndefinedPaymentTransfer.Add(decorP);
}
}
}
catch (Exception ex)
{
Logger.Error("GetUnknownTransfers()", ex);
return(null);
}
return(result);
}
public bool SavePendingOrder(PendingOrder order, out int orderID)
{
orderID = -1;
using (var ctx = DatabaseContext.Instance.Make())
{
var account = ctx.ACCOUNT.FirstOrDefault(ac => ac.ID == order.AccountID);
if (account == null)
{
return(false);
}
// найти парный ордер, чтобы прописать OCO
PENDING_ORDER pairOrder = null;
if (order.PairOCO.HasValue && order.PairOCO.Value > 0)
{
pairOrder = ctx.PENDING_ORDER.FirstOrDefault(o => o.ID == order.PairOCO.Value);
if (pairOrder == null)
{
order.PairOCO = null;
}
else
{
var anotherPair = ctx.PENDING_ORDER.FirstOrDefault(o => o.ID == pairOrder.ID);
if (anotherPair != null)
{
anotherPair.PairOCO = null;
ctx.Entry(anotherPair).State = EntityState.Modified;
}
}
}
var pendingOrder = LinqToEntity.UndecorateLiveActiveOrder(order);
account.PENDING_ORDER.Add(pendingOrder);
try
{
ctx.SaveChanges();
orderID = pendingOrder.ID;
// таки прописать ID парному ордеру
if (pairOrder != null)
{
pairOrder.PairOCO = orderID;
ctx.SaveChanges();
}
}
catch (Exception ex)
{
Logger.Error("Ошибка сохранения сущности PENDING_ORDER", ex);
ServiceManagerClientManagerProxy.Instance.NewOrderResponse(null,
RequestStatus.ServerError, "crudsav");
return(false);
}
}
// отправить уведомление клиенту
ServiceManagerClientManagerProxy.Instance.NewPendingOrderResponse(order, RequestStatus.OK, "");
return(true);
}
public Account GetAccountDetail(string hash, string userLogin, long localTime,
int accountId, bool calculateEquity,
out decimal brokerLeverage, out decimal exposure)
{
brokerLeverage = 0;
exposure = 0;
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var user = ctx.PLATFORM_USER.FirstOrDefault(u => u.Login == userLogin);
if (user == null)
{
return(null);
}
var userHash = CredentialsHash.MakeCredentialsHash(userLogin, user.Password, localTime);
if (userHash != hash)
{
return(null);
}
// авторизован?
if (!PlatformUser.IsManager(user.RoleMask) && !PlatformUser.IsAdmin(user.RoleMask))
{
if (!ctx.PLATFORM_USER_ACCOUNT.Any(pa => pa.PlatformUser == user.ID && pa.Account == accountId))
{
return(null);
}
}
var account = LinqToEntity.DecorateAccount(ctx.ACCOUNT.First(a => a.ID == accountId));
if (!calculateEquity)
{
return(account);
}
// получить открытые ордера по счету
var orders = ctx.POSITION.Where(p => p.AccountID == accountId && p.State ==
(int)PositionState.Opened).ToList().Select(LinqToEntity.DecorateOrder).ToList();
// посчитать открытый результат и экспозицию в валюте депо
var quotes = QuoteStorage.Instance.ReceiveAllData();
var errors = new List <string>();
exposure = DalSpot.Instance.CalculateExposure(orders, quotes, account.Currency, errors);
var group = ctx.ACCOUNT_GROUP.First(g => g.Code == account.Group);
brokerLeverage = group.BrokerLeverage;
account.UsedMargin = exposure / brokerLeverage;
return(account);
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в GetAccountDetail()", ex);
return(null);
}
}
public bool DeletePendingOrder(PendingOrder orderDecorated,
PendingOrderStatus status, int?positionID, string closeReason)
{
var order = LinqToEntity.UndecorateLiveActiveOrder(orderDecorated);
using (var ctx = DatabaseContext.Instance.Make())
{
// получить текущую цену
var pair = QuoteStorage.Instance.ReceiveValue(order.Symbol);
var priceClosed = pair == null ? 0 : order.Side > 0 ? pair.bid : pair.ask;
var hist = new PENDING_ORDER_CLOSED
{
OrderID = order.ID,
AccountID = order.AccountID,
Comment = order.Comment,
ExpertComment = order.ExpertComment,
Magic = order.Magic,
PairOCO = order.PairOCO,
PriceFrom = order.PriceFrom,
PriceTo = order.PriceTo,
Side = order.Side,
Status = (int)status,
Stoploss = order.Stoploss,
Takeprofit = order.Takeprofit,
Symbol = order.Symbol,
TimeClosed = DateTime.Now,
Volume = order.Volume,
PriceClosed = (decimal)priceClosed,
Position = positionID,
CloseReason = closeReason
};
try
{
ctx.PENDING_ORDER_CLOSED.Add(hist);
var ord = ctx.PENDING_ORDER.FirstOrDefault(p => p.ID == order.ID);
if (ord == null)
{
Logger.ErrorFormat("DeletePendingOrder - ордер {0} не найден", order.ID);
ServiceManagerClientManagerProxy.Instance.NewOrderResponse(null,
RequestStatus.ServerError, "crudsav");
return(false);
}
ctx.PENDING_ORDER.Remove(ord);
// сохранить изменения
ctx.SaveChanges();
return(true);
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка в DeletePendingOrder (#{0}): {1}", order.ID, ex);
}
}
return(false);
}
public void SaveProviderMessage(BrokerOrder msg)
{
using (var ctx = DatabaseContext.Instance.Make())
{
var brokOrder = LinqToEntity.UndecorateBrokerOrder(msg);
ctx.BROKER_ORDER.Add(brokOrder);
ctx.SaveChanges();
}
}
public WalletError SetPaymentWalletsBySystem(ProtectedOperationContext secCtx,
PaymentSystem syst,
List <UserPaymentSystem> actualPaySys,
string userLogin, string walletPwrd)
{
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx, false, false))
{
return(WalletError.InsufficientRights);
}
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var user = ctx.PLATFORM_USER.FirstOrDefault(u => u.Login == userLogin);
if (user == null)
{
return(WalletError.AuthenticationError);
}
// уничтожить старые записи того же типа
var existRecs =
ctx.USER_PAYMENT_SYSTEM.Where(r => r.UserId == user.ID && r.SystemPayment == (int)syst).ToList();
foreach (var rec in existRecs)
{
ctx.USER_PAYMENT_SYSTEM.Remove(rec);
}
ctx.SaveChanges();
// добавить новые записи
foreach (var paySyst in actualPaySys)
{
paySyst.UserId = user.ID;
paySyst.SystemPayment = syst;
ctx.USER_PAYMENT_SYSTEM.Add(LinqToEntity.UndecorateUserPaymentSystem(paySyst));
}
ctx.SaveChanges();
return(WalletError.OK);
}
}
catch (DbUpdateException ex)
{
if (ex.InnerException.InnerException is SqlException)
{
Logger.Error("SetPaymentWalletsBySystem() error: возможно, запись с таким RootId и PurseId уже есть в таблице USER_PAYMENT_SYSTEM", ex);
return(WalletError.ServerSqlError);
}
Logger.Error("SetPaymentWalletsBySystem() error", ex);
return(WalletError.ServerError);
}
catch (Exception ex)
{
Logger.Error("SetPaymentWalletsBySystem() error", ex);
return(WalletError.ServerError);
}
}
public Wallet UpdateBalance(int walletId, decimal transferVolume, bool deposit, out WalletError error)
{
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var wallet = ctx.WALLET.FirstOrDefault(x => x.User == walletId);
if (wallet == null)
{
Logger.InfoFormat("не найден кошек {0}", walletId);
error = WalletError.InvalidData;
return(null);
}
if (transferVolume <= 0)
{
Logger.Info("объём зачисляемых средств должен быть больше нуля}");
error = WalletError.InvalidData;
return(LinqToEntity.DecorateWallet(wallet));
}
var currentAmount = deposit ? transferVolume : -transferVolume;
var oldWalletBalance = wallet.Balance;
wallet.Balance += currentAmount;
Logger.InfoFormat("средства на кошеке {0} изменены с {1} на {2}",
walletId, oldWalletBalance, wallet.Balance);
var newTransfer = new TRANSFER
{
Amount = currentAmount,
TargetAmount = currentAmount,
User = walletId,
Comment = "Изменение администратором средств кошелька № " + walletId,
ValueDate = DateTime.Now,
BalanceChange = null,
};
ctx.TRANSFER.Add(newTransfer);
Logger.Info("Сохраняем изменения...");
ctx.SaveChanges();
error = WalletError.OK;
return(LinqToEntity.DecorateWallet(wallet));
}
}
catch (Exception ex)
{
Logger.Error("UpdateUserWallet()", ex);
error = WalletError.CommonError;
return(null);
}
}
public void TestProcessOrderOpening()
{
var order = MakeTestOrder();
var bill = BillingManager.ProcessOrderOpening(order, LinqToEntity.DecorateAccount(account));
Assert.IsNotNull(bill, "ProcessOrderOpening - bill не должен быть null");
var pointCost = DalSpot.Instance.GetAbsValue(order.Symbol, 1f);
var amountCounter = pointCost * 1; // order.Volume;
var delta = Math.Abs(amountCounter - bill.MarkupEnter);
Assert.Less(delta, 0.01, "ProcessOrderOpening - при открытии должна быть списана корректная сумма");
}
public PaidServiceDetail GetPaidServiceDetail(int serviceId)
{
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var service = ctx.SERVICE.First(s => s.ID == serviceId);
if (service == null)
{
return(null);
}
var srvDec = LinqToEntity.DecoratePaidService(service);
var detail = new PaidServiceDetail
{
Currency = service.Currency,
DayFee = service.FixedPrice,
MonthFee = srvDec.FixedPriceMonth,
AccountId = service.AccountId
};
var signalOwner = LinqToEntity.DecoratePlatformUser(ctx.PLATFORM_USER.First(u => u.ID == service.User));
detail.UserName = signalOwner.MakeNameWithInitials();
if (srvDec.AccountId.HasValue)
{
var account = LinqToEntity.DecorateAccount(ctx.ACCOUNT.First(a => a.ID == srvDec.AccountId));
detail.AccountGroup = account.Group;
}
// информация по торговым сигналам
var userSignal =
ctx.SERVICE.FirstOrDefault(us => us.User == service.User);
if (userSignal == null)
{
return(detail);
}
detail.SignalTitle =
string.IsNullOrEmpty(userSignal.Comment) ? "Сигналы №" + userSignal.ID : userSignal.Comment;
var subsCount = ctx.SUBSCRIPTION.Count(us => us.Service == userSignal.ID);
detail.SubscribersCount = subsCount;
return(detail);
}
}
catch (Exception ex)
{
Logger.Error("Error in GetPaidServiceDetail()", ex);
return(null);
}
}
public void TestProcessOrderClosing()
{
var order = MakeTestOrder();
var bill = BillingManager.ProcessOrderOpening(order, LinqToEntity.DecorateAccount(account));
Assert.IsNotNull(bill, "ProcessPriceForOrderClosing - открытие не обработано");
BillingManager.SaveNewOrderBill(bill, order.ID, conn);
conn.SaveChanges();
var billClose = BillingManager.ProcessPriceForOrderClosing(order,
LinqToEntity.DecorateAccount(account), conn);
Assert.IsNotNull(billClose, "ProcessPriceForOrderClosing - bill не должен быть null");
}
private List <PaidService> GetServicesByUserOrId(int id, bool byUser, out PlatformUser serviceOwner)
{
serviceOwner = null;
var srvList = new List <PaidService>();
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var query = byUser
? ctx.SERVICE.Where(s => s.User == id)
: ctx.SERVICE.Where(s => s.ID == id);
foreach (var srv in query)
{
var paidServ = LinqToEntity.DecoratePaidService(srv);
var srvId = srv.ID;
// добавить рейты
foreach (var rate in ctx.SERVICE_RATE.Where(r => r.Service == srvId))
{
paidServ.serviceRates.Add(new PaidServiceRate
{
Amount = rate.Amount,
RateType = (PaidServiceRate.ServiceRateType)rate.RateType,
UserBalance = rate.UserBalance
});
}
srvList.Add(paidServ);
}
if (byUser)
{
serviceOwner = LinqToEntity.DecoratePlatformUser(ctx.PLATFORM_USER.First(u => u.ID == id));
}
else
{
var srv = srvList.FirstOrDefault();
if (srv != null)
{
serviceOwner = LinqToEntity.DecoratePlatformUser(ctx.PLATFORM_USER.First(u => u.ID == srv.User));
}
}
}
return(srvList);
}
catch (Exception ex)
{
Logger.ErrorFormat("GetServicesByUserOrId({0}, {1}) error: {2}", id, byUser, ex);
return(srvList);
}
}
public List <TradeTicker> GetTickers(out long lotByGroupHash)
{
lotByGroupHash = 0;
var ticks = new List <TradeTicker>();
using (var ctx = DatabaseContext.Instance.Make())
{
foreach (var tradeTicker in ctx.SPOT)
{
ticks.Add(LinqToEntity.DecorateTicker(tradeTicker));
}
}
return(ticks);
}
/// <summary>
/// проверить SL, TP, трейлинги
/// </summary>
private void CheckOrders()
{
if (!WorkingDay.Instance.IsWorkingDay(DateTime.Now))
{
return;
}
var curPrices = QuoteStorage.Instance.ReceiveAllData();
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
// позиции
foreach (var order in ctx.POSITION)
{
if ((PositionState)order.State != PositionState.Opened)
{
continue;
}
try
{
tradeManager.CheckOrder(LinqToEntity.DecorateOrder(order), curPrices);
}
catch (Exception ex)
{
Logger.Error("AccountCheckStream.CheckOrder() error", ex);
}
}
// отложенные ордера
foreach (var order in ctx.PENDING_ORDER)
{
try
{
tradeManager.CheckPendingOrder(LinqToEntity.DecoratePendingOrder(order), curPrices);
}
catch (Exception ex)
{
Logger.Error("AccountCheckStream.CheckPendingOrder() error", ex);
}
}
}
}
catch (Exception ex)
{
Logger.Error("Ошибка в CheckOrders()", ex);
}
}
/// <summary>
/// Заполняет список allOrders позициями (сделками) из БД
/// </summary>
private void MakeOrders()
{
allOrders = new List <MarketOrder>();
using (var ctx = DatabaseContext.Instance.Make())
{
foreach (var pos in ctx.POSITION)
{
allOrders.Add(LinqToEntity.DecorateOrder(pos));
}
foreach (var pos in ctx.POSITION_CLOSED)
{
allOrders.Add(LinqToEntity.DecorateOrder(pos));
}
}
}
public bool CloseOrder(int orderId, decimal price, PositionExitReason exitReason)
{
MarketOrder orderDecor;
using (var ctx = DatabaseContext.Instance.Make())
{
var orderQuery = ctx.POSITION.Where(p => p.ID == orderId).ToList();
if (orderQuery.Count == 0)
{
Logger.ErrorFormat("CloseOrder(Id = {0}) - позиция не найдена", orderId);
return(false);
}
orderDecor = LinqToEntity.DecorateOrder(orderQuery[0]);
}
return(CloseOrder(orderDecor, price, exitReason));
}
public WalletError GetTransferExtendedInfo(ProtectedOperationContext secCtx,
int transferId, out BalanceChange balanceChange, out PlatformUser user)
{
balanceChange = null;
user = null;
if (!UserSessionStorage.Instance.PermitUserOperation(secCtx, false, false))
{
return(WalletError.InsufficientRights);
}
var error = WalletError.ServerError;
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
var trans = ctx.TRANSFER.FirstOrDefault(t => t.ID == transferId);
if (trans == null)
{
return(WalletError.InvalidData);
}
if (trans.BalanceChange.HasValue)
{
balanceChange = LinqToEntity.DecorateBalanceChange(trans.BALANCE_CHANGE);
return(WalletError.OK);
}
if (trans.RefWallet.HasValue)
{
var us = ctx.PLATFORM_USER.FirstOrDefault(u => u.ID == trans.RefWallet.Value);
if (us != null)
{
user = LinqToEntity.DecoratePlatformUser(us);
user.Password = string.Empty;
}
}
}
}
catch (Exception ex)
{
Logger.ErrorFormat("GetTransferExtendedInfo({0}) error: {1}", transferId, ex);
error = WalletError.ServerError;
}
return(error);
}
/// <summary>
/// формирует модель для представления PositionDetails
/// </summary>
/// <param name="positionId">Уникальным идентификатором является сделки</param>
/// <remarks>Не тестируется</remarks>
public MarketOrder GetPositionItemDetails(int positionId)
{
MarketOrder positionItem = null;
try
{
using (var ctx = DatabaseContext.Instance.Make())
{
// Проверяем, есть ли указанная сделка среди открытых (потому что их меньше), если нет - ищём её среди закрытых
if (ctx.POSITION.Any(x => x.ID == positionId))
{
POSITION position;
try
{
position = ctx.POSITION.Single(x => x.ID == positionId);
}
catch (Exception ex)
{
Logger.Error(string.Format("GetPositionItemDetails() - При запросе подробностей о сделке c id {0} не удалось получить конкретный элемент из POSITION", positionId), ex);
return(null);
}
positionItem = LinqToEntity.DecorateOrder(position);
}
else
{
POSITION_CLOSED position;
try
{
position = ctx.POSITION_CLOSED.Single(x => x.ID == positionId);
}
catch (Exception ex)
{
Logger.Error(string.Format("GetPositionItemDetails() - При запросе подробностей о сделке c id {0} не удалось получить конкретный элемент из POSITION_CLOSED", positionId), ex);
return(null);
}
positionItem = LinqToEntity.DecorateOrder(position);
}
}
}
catch (Exception ex)
{
Logger.Error("GetPositionItemDetails Exception", ex);
}
return(positionItem);
}
private PaidService GetPaidServiceProgressiveFeeScaleDetail(TradeSharpConnection ctx, SERVICE srv)
{
var fees = ctx.SERVICE_RATE.Where(r => r.Service == srv.ID).OrderBy(r => r.UserBalance).ToList();
if (fees.Count == 0)
{
return(null);
}
var service = LinqToEntity.DecoratePaidService(srv);
service.serviceRates = fees.Select(f => new PaidServiceRate
{
Amount = f.Amount,
RateType = PaidServiceRate.ServiceRateType.Percent,
UserBalance = f.UserBalance
}).ToList().ToList();
return(service);
}
