コード例 #1
0
        /// <summary>
        /// Сохраниение внесённых изменений в "группу счетов", но только тех свойств, которые относятся к диллеру
        /// </summary>
        /// <param name="accGrp">Группа счетов</param>
        public bool SaveChangesDealerFealdInAccountGroup(AccountGroup accGrp)
        {
            Logger.Info(string.Format("попытка сохраниения внесённых изменений в описание диллера для группы счетов {0}", accGrp.Code));

            try
            {
                using (var ctx = DatabaseContext.Instance.Make())
                {
                    var dealerGroup = ctx.DEALER_GROUP.Single(x => x.ACCOUNT_GROUP.Code == accGrp.Code);

                    if (!string.IsNullOrEmpty(accGrp.SessionName)) dealerGroup.SessionName = accGrp.SessionName;
                    if (!string.IsNullOrEmpty(accGrp.SenderCompId)) dealerGroup.SenderCompId = accGrp.SenderCompId;
                    if (!string.IsNullOrEmpty(accGrp.HedgingAccount)) dealerGroup.HedgingAccount = accGrp.HedgingAccount;
                    if (!string.IsNullOrEmpty(accGrp.MessageQueue)) dealerGroup.MessageQueue = accGrp.MessageQueue;
                    ctx.SaveChanges();

                    Logger.Info(string.Format("Сохранины изменения в описание диллера для группы счетов {0}", accGrp.Code));
                    return true;
                }
            }
            catch (Exception ex)
            {
                Logger.Error(string.Format(
                    "SaveChangesDealerFealdInAccountGroup(). Не удалось сохраниенить внесённые изменения в описание диллера для группы счетов {0}",
                    accGrp.Code), ex);
                return false;
            }
        }
コード例 #2
0
        public void SaveChangesDealerFealdInAccountGroup()
        {
            var accGroup = new AccountGroup
            {
                SessionName = "TestSessionName",
                SenderCompId = "TestSenderCompId",
                HedgingAccount = "TestHedgingAccount",
                MessageQueue = "TestMessageQueue"
            };

            using (var ctx = DatabaseContext.Instance.Make())
            {accGroup.Code = ctx.DEALER_GROUP.First().ACCOUNT_GROUP.Code;}

            var resultUpdate = dealerRepository.SaveChangesDealerFealdInAccountGroup(accGroup);
            Assert.IsTrue(resultUpdate);

            using (var ctx = DatabaseContext.Instance.Make())
            {
                var actualDealer = ctx.DEALER_GROUP.First();
                Assert.AreEqual("TestSessionName", actualDealer.SessionName);
                Assert.AreEqual("TestSenderCompId", actualDealer.SenderCompId);
                Assert.AreEqual("TestHedgingAccount", actualDealer.HedgingAccount);
                Assert.AreEqual("TestMessageQueue", actualDealer.MessageQueue);
            }

            accGroup.SessionName = "FaileSessionName";
            DatabaseContext.InitializeFake(exceptionConnectionPersistent);
            Assert.IsFalse(dealerRepository.SaveChangesDealerFealdInAccountGroup(accGroup));
        }
コード例 #3
0
        public static float GetMarkupAbs(string groupCode, string ticker, out AccountGroup.MarkupType markType)
        {
            //Logger.InfoFormat("Markup: GetMarkupAbs({0}, {1})", groupCode, ticker);
            markType = AccountGroup.MarkupType.NoMarkup;
            // пришло время обновить словарь?
            var lastTimeUpdate = lastTimeDicIsUpdated.GetLastHitIfHitted();
            var milsSinceUpdate = lastTimeUpdate == null
                                      ? int.MaxValue
                                      : (DateTime.Now - lastTimeUpdate.Value).TotalMilliseconds;
            if (milsSinceUpdate > MaxMilsBetweenUpdate)
            {
                //Logger.InfoFormat("Markup: Updating dic");
                // таки обновить словарь
                var dicMarkup = DictionaryManager.Instance.GetMarkupByGroup();
                //Logger.InfoFormat("Markup: Dic is updated - {0} records", dicMarkup.Count);
                if (!locker.TryEnterWriteLock(LockTimeout))
                {
                    Logger.ErrorFormat("AcccountMarkupDictionary - write timeout ({0} ms)", LockTimeout);
                }
                else
                {
                    markups = dicMarkup.ToDictionary(m => m.GroupCode, m => m);
                    locker.ExitWriteLock();
                }
            }

            GroupMarkup mark;
            // безопасно прочитать данные
            if (!locker.TryEnterReadLock(LockTimeout))
            {
                Logger.ErrorFormat("AcccountMarkupDictionary - read timeout ({0} ms)", LockTimeout);
                return 0;
            }
            try
            {
                markups.TryGetValue(groupCode, out mark);
            }
            finally
            {
                locker.ExitReadLock();
            }

            if (mark == null) return 0;
            //Logger.InfoFormat("Markup: got value ({0}, {1})", mark.DefaultSpread, mark.MarkupType);
            if (mark.MarkupType == AccountGroup.MarkupType.NoMarkup) return 0;
            markType = mark.MarkupType;

            float spread;
            if (mark.spreadByTicker.TryGetValue(ticker, out spread))
                return spread;

            // посчитать спред из пунктов
            return mark.DefaultSpread == 0
                       ? 0
                       : DalSpot.Instance.GetAbsValue(ticker, mark.DefaultSpread);
        }
コード例 #4
0
 public static AccountGroup DecorateAccountGroup(ACCOUNT_GROUP ag)
 {
     var group = new AccountGroup
     {
         Code = ag.Code,
         BrokerLeverage = (float)ag.BrokerLeverage,
         DefaultVirtualDepo = ag.DefaultVirtualDepo ?? 0,
         IsReal = ag.IsReal,
         MarginCallPercentLevel = (float)ag.MarginCallPercentLevel,
         Name = ag.Name,
         StopoutPercentLevel = (float)ag.StopoutPercentLevel,
         Markup = (AccountGroup.MarkupType)ag.MarkupType,
         DefaultMarkupPoints = (float)ag.DefaultMarkupPoints
     };
     return group;
 }
コード例 #5
0
        /// <summary>
        /// Сохраниение внесённых изменений в "группу счетов"
        /// </summary>
        /// <param name="accGrp">Ссылка на редактируемую группу счетов</param>
        public string SaveAccountGroupChanges(AccountGroup accGrp)
        {
            string message;
            Logger.Info(String.Format("попытка сохраниения внесённых изменений в группу счетов {0}", accGrp.Code));

            try
            {
                using (var ctx = DatabaseContext.Instance.Make())
                {
                    var undecorateAccountGroup = ctx.ACCOUNT_GROUP.First(x => x.Code == accGrp.Code);
                    LinqToEntity.UndecorateAccountGroup(undecorateAccountGroup, accGrp);
                    ctx.SaveChanges();

                    message = string.Format("{1} {0}.", accGrp.Code, Resource.MessageAccountGroupEditedSuccessful);
                }
            }

            catch (Exception ex)
            {
                Logger.Error(String.Format("Не удалось сохранить внесённые изменения в группу счетов {0}", accGrp.Code), ex);
                message = string.Format("{1} {0}.", accGrp.Code, Resource.ErrorMessageAccountGroupSave);
            }

            if (accGrp.Dealer != null)
            {
                message += dealerRepository.SaveChangesDealerFealdInAccountGroup(accGrp)
                    ? string.Format("{2} {0} {3} {1}", accGrp.Dealer, accGrp.Code, Resource.MessageAccountGroupSaveDealerInfo, Resource.MessageAccountGroupFor)
                    : string.Format("{1} {0}.", accGrp.Code, Resource.ErrorMessageAccountGroupSaveDeallerInfo);
            }
            else
            {
                message += string.Format("  {1} {0}.", accGrp.Code, Resource.ErrorMessageAccountGroupSaveDeallerInfo);
            }

            return message;
        }
コード例 #6
0
 public AccountGroupTag(AccountGroup group)
 {
     this.group = group;
 }
コード例 #7
0
 /// <summary>
 /// Мапинг объекта "группа счетов" в объект Entity FW. Изменяется переданный объект.
 /// </summary>
 /// <param name="dest"></param>
 /// <param name="src"></param>
 public static void UndecorateAccountGroup(ACCOUNT_GROUP dest, AccountGroup src)
 {
     dest.Code = src.Code;
     dest.Name = src.Name;
     dest.IsReal = src.IsReal;
     dest.BrokerLeverage = (decimal)src.BrokerLeverage;
     dest.MarginCallPercentLevel = (decimal)src.MarginCallPercentLevel;
     dest.StopoutPercentLevel = (decimal)src.StopoutPercentLevel;
     dest.DefaultMarkupPoints = src.DefaultMarkupPoints;
     dest.DefaultVirtualDepo = src.DefaultVirtualDepo;
     dest.MarkupType = (int)src.Markup;
     dest.SwapFree = src.SwapFree;
 }
コード例 #8
0
 /// <summary>
 /// Мапинг объекта "группа счетов" в объект Entity FW. Возвращает новый объект ACCOUNT_GROUP
 /// </summary>
 /// <param name="src"></param>
 /// <returns></returns>
 public static ACCOUNT_GROUP UndecorateAccountGroup(AccountGroup src)
 {
     var result = new ACCOUNT_GROUP
         {
             Code = src.Code,
             Name = src.Name,
             IsReal = src.IsReal,
             BrokerLeverage = (decimal)src.BrokerLeverage,
             MarginCallPercentLevel = (decimal)src.MarginCallPercentLevel,
             StopoutPercentLevel = (decimal)src.StopoutPercentLevel,
             DefaultMarkupPoints = src.DefaultMarkupPoints,
             DefaultVirtualDepo = src.DefaultVirtualDepo,
             MarkupType = (int)src.Markup,
             SwapFree = src.SwapFree
         };
     return result;
 }