示例#1
0
 public SendEmailCommandRepository(AccountDbContext context)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     Context = context;
 }
示例#2
0
 public ArchivedStatusRepository(AccountDbContext context)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     Context = context;
 }
示例#3
0
 public DefectService(AccountDbContext accountDbContext)
 {
     if (accountDbContext == null)
     {
         throw new ArgumentNullException("accountDbContext");
     }
     _accountDbContext = accountDbContext;
 }
示例#4
0
 public UserSettingRepository(AccountDbContext context)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     Context = context;
 }
示例#5
0
 public AccountTariffRepository(AccountDbContext context)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     Context = context;
 }
示例#6
0
        public DefectChange ChangeStatus(
            Guid accountId,
            Defect defect,
            DefectStatus status,
            User user,
            string comment)
        {
            var change = new DefectChange()
            {
                Id     = Guid.NewGuid(),
                Status = status,
                //Defect = defect,
                //User = user,
                Comment  = comment,
                Date     = DateTime.Now,
                UserId   = user.Id,
                DefectId = defect.Id
            };

            defect.LastChange = change;

            // Если дефект закрывается, то нужно внести информацию о версии в тип события
            if (status == DefectStatus.Closed && defect.EventType != null)
            {
                string version;
                using (var context = AccountDbContext.CreateFromAccountId(accountId))
                {
                    var repository = context.GetEventRepository();
                    var lastEvent  = repository.GetLastEventByEndDate(defect.EventType.Id);
                    version = lastEvent != null ? lastEvent.Version : null;
                }

                if (!string.IsNullOrEmpty(version))
                {
                    defect.EventType.OldVersion       = version;
                    defect.EventType.ImportanceForOld = Api.EventImportance.Unknown;
                }
            }

            return(change);
        }
示例#7
0
 public LimitDataRepository(AccountDbContext context) : base(context)
 {
 }
 public SubscriptionRepository(AccountDbContext context) : base(context)
 {
 }
示例#9
0
 public UserRepository(AccountDbContext context) : base(context)
 {
 }
示例#10
0
        public Guid CreateMetric(Guid accountId, Guid componentId, Guid metricTypeId)
        {
            // получаем компонент
            var componentRequest = new AccountCacheRequest()
            {
                AccountId = accountId,
                ObjectId  = componentId
            };

            using (var component = AllCaches.Components.Write(componentRequest))
            {
                var child = component.Metrics.FindByMetricTypeId(metricTypeId);
                if (child != null)
                {
                    throw new UserFriendlyException("У компонента уже есть метрика данного типа");
                }

                // сохраняем метрику в БД
                using (var accountDbContext = AccountDbContext.CreateFromAccountIdLocalCache(accountId))
                {
                    // Проверим лимиты
                    var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
                    limitChecker.CheckMaxMetrics(accountDbContext);

                    var processDate = DateTime.Now;
                    var metricId    = Guid.NewGuid();

                    var statusData = Context.BulbService.CreateBulb(
                        accountId,
                        processDate,
                        EventCategory.MetricStatus,
                        metricId);

                    // загрузим в новый контекст
                    statusData = accountDbContext.Bulbs.Find(statusData.Id);

                    var metric = new Metric()
                    {
                        Id           = metricId,
                        BeginDate    = processDate,
                        ActualDate   = processDate.AddDays(1),
                        ComponentId  = component.Id,
                        Enable       = true,
                        IsDeleted    = false,
                        MetricTypeId = metricTypeId,
                        ParentEnable = component.CanProcess,
                        StatusDataId = statusData.Id,
                        //StatusData = statusData,
                        CreateDate = DateTime.Now,
                        Value      = null
                    };

                    statusData.MetricId = metric.Id;
                    statusData.Metric   = metric;

                    var repository = accountDbContext.GetMetricRepository();
                    repository.Add(metric);
                    accountDbContext.SaveChanges();

                    // обновим статистику лимитов
                    limitChecker.RefreshMetricsCount();

                    // обновляем ссылки у компонента
                    var metricReference = new CacheObjectReference(metric.Id, metricTypeId.ToString());
                    component.WriteMetrics.Add(metricReference);

                    component.BeginSave();
                    return(metric.Id);
                }
            }
        }
示例#11
0
        protected UnitTest Create(
            Guid accountId,
            Guid componentId,
            Guid unitTestTypeId,
            string systemName,
            string displayName,
            Guid?newId)
        {
            // создаем отдельный контекст, чтобы после обработки объектов кэшем основной контекст загрузил актуальную версию из БД
            using (var accountDbContext = AccountDbContext.CreateFromAccountIdLocalCache(accountId))
            {
                var now       = DateTime.Now;
                var component = accountDbContext.Components.Single(x => x.Id == componentId);

                var unitTestId = newId ?? Guid.NewGuid();

                var statusData = Context.BulbService.CreateBulb(
                    accountId,
                    now,
                    EventCategory.UnitTestStatus,
                    unitTestId);

                var unitTest = new UnitTest()
                {
                    Id           = unitTestId,
                    SystemName   = systemName,
                    DisplayName  = displayName,
                    ComponentId  = componentId,
                    Component    = component,
                    Enable       = true,
                    ParentEnable = component.ParentEnable,
                    TypeId       = unitTestTypeId,
                    CreateDate   = now,
                    StatusDataId = statusData.Id
                };

                // чтобы не получилось так, что период равен нулю и начнется непрерывное выполнение проверки
                if (SystemUnitTestTypes.IsSystem(unitTestTypeId))
                {
                    if (unitTestTypeId == SystemUnitTestTypes.DomainNameTestType.Id)
                    {
                        // для доменной проверки период задается системой, пользователь НЕ может его менять сам
                        unitTest.PeriodSeconds = (int)TimeSpan.FromDays(1).TotalSeconds;
                    }
                    else
                    {
                        unitTest.PeriodSeconds = (int)TimeSpan.FromMinutes(10).TotalSeconds;
                    }
                }

                if (unitTestTypeId == SystemUnitTestTypes.HttpUnitTestType.Id)
                {
                    unitTest.HttpRequestUnitTest = new HttpRequestUnitTest()
                    {
                        UnitTestId = unitTestId
                    };
                }

                statusData.UnitTestId = unitTest.Id;

                accountDbContext.UnitTests.Add(unitTest);
                accountDbContext.SaveChanges();
                Context.GetAccountDbContext(accountId).SaveChanges();
                return(unitTest);
            }
        }
 public NotificationRepository(AccountDbContext context)
 {
     Context = context;
 }
示例#13
0
 public MetricRepository(AccountDbContext context) : base(context)
 {
 }
 public LimitDataForUnitTestRepository(AccountDbContext context) : base(context)
 {
 }
        public IUnitTestTypeCacheReadObject GetOrCreateUnitTestType(Guid accountId, GetOrCreateUnitTestTypeRequestData data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if (string.IsNullOrEmpty(data.SystemName))
            {
                throw new ParameterRequiredException("SystemName");
            }

            var lockObj = typeof(UnitTestTypeService);

            lock (lockObj)
            {
                var unitTestTypeCache = AllCaches.UnitTestTypes.FindByName(accountId, data.SystemName);

                if (unitTestTypeCache != null)
                {
                    return(unitTestTypeCache);
                }

                var accountDbContext = Context.GetAccountDbContext(accountId);

                // Проверим лимит
                var checker     = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
                var checkResult = checker.CheckMaxUnitTestTypes(accountDbContext);
                if (!checkResult.Success)
                {
                    throw new OverLimitException(checkResult.Message);
                }

                Guid unitTestTypeId;

                // создаем отдельный контекст, чтобы после обработки объектов кэшем основной контекст загрузил актуальную версию из БД
                using (var accountDbContextNew = AccountDbContext.CreateFromAccountIdLocalCache(accountId))
                {
                    if (string.IsNullOrEmpty(data.DisplayName))
                    {
                        data.DisplayName = data.SystemName;
                    }

                    var unitTestType = new UnitTestType()
                    {
                        SystemName     = data.SystemName,
                        DisplayName    = data.DisplayName,
                        IsSystem       = false,
                        ActualTimeSecs = data.ActualTimeSecs,
                        NoSignalColor  = data.NoSignalColor
                    };

                    var unitTestTypeRepository = accountDbContextNew.GetUnitTestTypeRepository();
                    unitTestTypeRepository.Add(unitTestType);
                    unitTestTypeId = unitTestType.Id;
                }

                checker.RefreshUnitTestTypesCount();

                unitTestTypeCache = AllCaches.UnitTestTypes.Read(new AccountCacheRequest()
                {
                    AccountId = accountId,
                    ObjectId  = unitTestTypeId
                });

                return(unitTestTypeCache);
            }
        }
 public ComponentPropertyRepository(AccountDbContext context) : base(context)
 {
 }
示例#17
0
 public RoleRepository(AccountDbContext context)
 {
     Context = context;
 }
 public ComponentTypeRepository(AccountDbContext context) : base(context)
 {
 }
示例#19
0
 public LogRepository(AccountDbContext context)
 {
     Context = context;
 }
 public UnitTestRepository(AccountDbContext context) : base(context)
 {
 }
示例#21
0
 public StatusDataRepository(AccountDbContext accountDbContext)
     : base(accountDbContext)
 {
 }