Beispiel #1
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);
                }
            }
        }
        protected Component Add(Component component, Guid accountId)
        {
            if (component == null)
            {
                throw new ArgumentNullException("component");
            }
            component.CreatedDate = DateTime.Now;
            if (component.Parent != null)
            {
                if (component.ComponentTypeId == SystemComponentTypes.Root.Id)
                {
                    throw new ResponseCodeException(
                              ResponseCode.UnknownComponentTypeId,
                              "Нельзя создавать экземпляры компонентов с типом Root");
                }
                component.ParentId     = component.Parent.Id;
                component.ParentEnable = component.Parent.CanProcess;
                var parentRequest = new AccountCacheRequest()
                {
                    AccountId = accountId,
                    ObjectId  = component.Parent.Id
                };
                var parent = AllCaches.Components.Find(parentRequest);
                if (parent == null)
                {
                    throw new Exception("parent == null");
                }
                var child = parent.Childs.FindByName(component.SystemName);
                if (child != null)
                {
                    throw new Exception("У родителя уже есть компонент с таким SystemName");
                }
            }

            component.ExternalStatus        = CreateStatusData(component, Api.EventCategory.ComponentExternalStatus, accountId);
            component.InternalStatus        = CreateStatusData(component, Api.EventCategory.ComponentInternalStatus, accountId);
            component.EventsStatus          = CreateStatusData(component, Api.EventCategory.ComponentEventsStatus, accountId);
            component.UnitTestsStatus       = CreateStatusData(component, Api.EventCategory.ComponentUnitTestsStatus, accountId);
            component.MetricsStatus         = CreateStatusData(component, Api.EventCategory.ComponentMetricsStatus, accountId);
            component.ChildComponentsStatus = CreateStatusData(component, Api.EventCategory.ComponentChildsStatus, accountId);

            // обновим ссылку на компонент
            var statuses = component.GetAllStatuses();

            foreach (var statusData in statuses)
            {
                statusData.ComponentId = component.Id;
                statusData.Component   = component;
            }

            component.LogConfig = new LogConfig()
            {
                ComponentId      = component.Id,
                Component        = component,
                Enabled          = true,
                IsFatalEnabled   = true,
                IsErrorEnabled   = true,
                IsWarningEnabled = true,
                IsInfoEnabled    = true,
                IsDebugEnabled   = true,
                IsTraceEnabled   = true,
                LastUpdateDate   = component.CreatedDate
            };
            var accountDbContext = Context.GetAccountDbContext(accountId);

            accountDbContext.Components.Add(component);
            accountDbContext.SaveChanges();

            // обновим в кэше ссылки на дочерние компоненты у родителя
            if (component.Parent != null)
            {
                var parentRequest = new AccountCacheRequest()
                {
                    AccountId = accountId,
                    ObjectId  = component.Parent.Id
                };
                using (var parent = AllCaches.Components.Write(parentRequest))
                {
                    var componentRef = new CacheObjectReference(component.Id, component.SystemName);
                    parent.WriteChilds.Add(componentRef);
                    parent.BeginSave();
                }
            }

            return(component);
        }
        public IUnitTestCacheReadObject GetOrCreateUnitTest(Guid accountId, GetOrCreateUnitTestRequestData data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            if (string.IsNullOrEmpty(data.SystemName))
            {
                throw new ParameterRequiredException("SystemName");
            }
            if (data.ComponentId == null)
            {
                throw new ParameterRequiredException("ComponentId");
            }
            if (data.UnitTestTypeId == null)
            {
                throw new ParameterRequiredException("UnitTestTypeId");
            }
            var cache       = new AccountCache(accountId);
            var componentId = data.ComponentId.Value;
            var systemName  = data.SystemName;

            // проверим, что тип проверки существует
            var unitTestTypeId = data.UnitTestTypeId.Value;

            if (!SystemUnitTestTypes.IsSystem(unitTestTypeId))
            {
                var unitTestType = AllCaches.UnitTestTypes.Find(new AccountCacheRequest()
                {
                    AccountId = accountId,
                    ObjectId  = unitTestTypeId
                });

                if (unitTestType == null)
                {
                    throw new UnknownUnitTestTypeIdException(unitTestTypeId);
                }
            }

            // получим компонент
            var component = cache.Components.Read(componentId);

            if (component == null)
            {
                throw new UnknownComponentIdException(componentId, accountId);
            }

            // проверим есть ли у него ссылка на проверку
            var unitTestRef = component.UnitTests.FindByName(data.SystemName);

            if (unitTestRef != null)
            {
                // ссылка есть, вернем существующую проверку
                var unitTest = cache.UnitTests.Read(unitTestRef.Id);
                if (unitTest == null)
                {
                    throw new Exception("unitTest == null");
                }
                return(unitTest);
            }

            // ссылки нет
            using (var writeComponent = cache.Components.Write(componentId))
            {
                // проверим ссылку еще раз
                unitTestRef = writeComponent.UnitTests.FindByName(data.SystemName);
                if (unitTestRef != null)
                {
                    var unitTest = cache.UnitTests.Read(unitTestRef.Id);
                    if (unitTest == null)
                    {
                        throw new Exception("unitTest == null");
                    }
                    return(unitTest);
                }

                // создадим проверку
                var accountDbContext = Context.GetAccountDbContext(accountId);

                // Проверим лимиты
                var checker     = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
                var checkResult = checker.CheckMaxUnitTestsCount(accountDbContext);

                if (!checkResult.Success)
                {
                    throw new OverLimitException(checkResult.Message);
                }

                // проверка лимитов пройдена
                if (string.IsNullOrWhiteSpace(data.DisplayName))
                {
                    data.DisplayName = data.SystemName;
                }

                // создаем юнит-тест
                var unitTestObj = Create(accountId, componentId, unitTestTypeId, systemName, data.DisplayName, data.NewId);
                unitTestRef = new CacheObjectReference(unitTestObj.Id, unitTestObj.SystemName);
                writeComponent.WriteUnitTests.Add(unitTestRef);
                writeComponent.BeginSave();

                checker.RefreshApiChecksCount();

                // обновим свойства
                using (var unitTestCache = cache.UnitTests.Write(unitTestObj.Id))
                {
                    unitTestCache.NoSignalColor = data.NoSignalColor;
                    unitTestCache.ErrorColor    = data.ErrorColor;
                    unitTestCache.ActualTime    = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
                    if (data.PeriodSeconds.HasValue)
                    {
                        unitTestCache.PeriodSeconds = data.PeriodSeconds;
                    }
                    if (data.SimpleMode.HasValue)
                    {
                        unitTestCache.SimpleMode = data.SimpleMode.Value;
                    }
                    unitTestCache.BeginSave();
                    unitTestCache.WaitSaveChanges();
                    return(unitTestCache);
                }
            }
        }