public void DeleteMetricType(Guid accountId, Guid metricTypeId)
{
var cache = new AccountCache(accountId);
using (var metricType = cache.MetricTypes.Write(metricTypeId))
{
metricType.IsDeleted = true;
metricType.BeginSave();
}
var metrics = cache.Metrics.GetAllLoaded()
.Where(x => x.MetricTypeId == metricTypeId)
.ToArray();
foreach (var metric in metrics)
{
using (var writeMetric = cache.Metrics.Write(metric))
{
writeMetric.IsDeleted = true;
writeMetric.BeginSave();
}
}
// подождем сохранения всех изменений в БД
AllCaches.MetricTypes.SaveChanges();
AllCaches.Metrics.SaveChanges();
// обновим статистику лимитов
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
limitChecker.RefreshMetricsCount();
// статусы НЕ обновляем, т.к. это может выполняться очень долго
}
protected void DoSaveLimits(object obj)
{
var startTime = DateTime.Now;
var count = AccountLimitsCheckerManager.Save();
var endTime = DateTime.Now;
var duration = endTime - startTime;
var control = DispatcherService.Wrapper.Control;
if (AccountLimitsCheckerManager.LastSaveException != null)
{
if (control != null)
{
control.SendApplicationError(AccountLimitsCheckerManager.LastSaveException);
}
}
if (UnitTestControl != null)
{
if (AccountLimitsCheckerManager.LastSaveException == null)
{
UnitTestControl.SendResult(UnitTestResult.Success, TimeSpan.FromMinutes(10), "Сохранено записей: " + count + " за " + duration);
}
else
{
UnitTestControl.SendResult(UnitTestResult.Alarm, TimeSpan.FromMinutes(10), AccountLimitsCheckerManager.LastSaveException.Message);
}
}
if (LimitsSavingTimer != null)
{
LimitsSavingTimer.Dispose();
}
LimitsSavingTimer = new Timer(DoSaveLimits, null, AccountLimitsChecker.LimitDataTimeStep * 60 * 1000, Timeout.Infinite);
}
public IEventCacheReadObject JoinEvent(Guid accountId, Guid componentId, JoinEventData joinEventData)
{
// Проверим, что компонент вообще есть
var componentRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = componentId
};
var component = AllCaches.Components.Find(componentRequest);
if (component == null)
{
throw new UnknownComponentIdException(componentId, accountId);
}
if (component.CanProcess == false)
{
throw new ResponseCodeException(Zidium.Api.ResponseCode.ObjectDisabled, "Компонент выключен");
}
// проверка лимитов
var accountDbContext = Context.GetAccountDbContext(accountId);
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
limitChecker.CheckEventsRequestsPerDay(accountDbContext);
// Проверим лимит размера хранилища
var size = joinEventData.Message != null ? joinEventData.Message.Length * 2 : 0;
limitChecker.CheckStorageSize(accountDbContext, size);
var eventType = Context.EventTypeService.GetOneById(joinEventData.TypeId ?? Guid.Empty, accountId);
// расчитаем важность
joinEventData.Importance = GetEventImportance(joinEventData.Importance, eventType.Category);
var localEvent = CreateEvent(
accountId,
joinEventData.StartDate,
joinEventData.StartDate,
joinEventData.Count,
joinEventData.Version,
joinEventData.Importance,
TimeSpan.FromSeconds(joinEventData.JoinInterval ?? 0),
joinEventData.Message,
null,
eventType,
componentId,
joinEventData.JoinKey ?? 0);
var joinInterval = (joinEventData.JoinInterval.HasValue)
? TimeSpan.FromSeconds(joinEventData.JoinInterval.Value)
: (eventType.JoinInterval ?? TimeSpan.Zero);
var dbEvent = ProcessSimpleEvent(componentId, localEvent, joinEventData.EventId, joinInterval, accountId);
limitChecker.AddEventsSizePerDay(accountDbContext, size);
return(dbEvent);
}
public Guid GetOrCreateTypeId(Guid accountId, string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
var key = GetMapKey(accountId, name);
Guid id;
if (NameToIdMap.TryGetValue(key, out id))
{
return(id);
}
lock (UpdateMapLock)
{
if (NameToIdMap.TryGetValue(key, out id))
{
return(id);
}
using (var accountDbContext = AccountDbContext.CreateFromAccountIdLocalCache(accountId))
{
var repository = accountDbContext.GetMetricTypeRepository();
var metricType = repository.GetOneOrNullByName(name);
if (metricType == null /* || metricType.IsDeleted*/) // репозиторий не возвращает удалённые
{
// Проверим лимиты
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var checkResult = limitChecker.CheckMaxMetrics(accountDbContext);
if (!checkResult.Success)
{
throw new OverLimitException(checkResult.Message);
}
metricType = new MetricType()
{
Id = Guid.NewGuid(),
IsDeleted = false,
CreateDate = DateTime.Now,
SystemName = name,
DisplayName = name
};
repository.Add(metricType);
accountDbContext.SaveChanges();
limitChecker.RefreshMetricsCount();
}
bool success = NameToIdMap.TryAdd(key, metricType.Id);
if (success)
{
return(metricType.Id);
}
throw new Exception("Не удалось добавить тип метрики в карту");
}
}
}
public void SaveLogMessages(Guid accountId, SendLogData[] messages)
{
// Проверка на наличие необходимых параметров
if (messages == null)
{
throw new ParameterRequiredException("Request.Messages");
}
// Проверим лимиты
var accountDbContext = Context.GetAccountDbContext(accountId);
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var totalSize = messages.Sum(t => t.GetSize());
checker.CheckLogSizePerDay(accountDbContext, totalSize);
// Проверим лимит размера хранилища
checker.CheckStorageSize(accountDbContext, totalSize);
var componentService = Context.ComponentService;
var logRepository = Context.DbContext.GetAccountDbContext(accountId).GetLogRepository();
// Добавим все записи в одной транзакции
foreach (var message in messages)
{
if (message.Message == null)
{
throw new ParameterRequiredException("Request.Message.Message"); //todo надо переименовать
}
if (message.Message.Length > 4000)
{
message.Message = message.Message.Substring(0, 4000);
}
if (message.Context != null && message.Context.Length > 255)
{
message.Context = message.Context.Substring(0, 255);
}
var component = componentService.GetComponentById(accountId, message.ComponentId.Value);
var log = ApiConverter.GetLog(component.Id, message);
logRepository.Add(log);
}
Context.SaveChanges();
checker.AddLogSizePerDay(accountDbContext, totalSize);
}
public bool SendHttpUnitTestBanner(Guid accountId, Guid unitTestId, bool hasBanner)
{
var accountDbContext = Context.GetAccountDbContext(accountId);
lock (BannerLock)
{
var repository = accountDbContext.GetUnitTestRepository();
var unitTest = repository.GetById(unitTestId);
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var hasBannerChanged = (unitTest.HttpRequestUnitTest.LastBannerCheck == null) || (unitTest.HttpRequestUnitTest.HasBanner != hasBanner);
if (hasBannerChanged)
{
unitTest.HttpRequestUnitTest.HasBanner = hasBanner;
}
// В любом случае баннер проверяется не чаще 1 раза в день
unitTest.HttpRequestUnitTest.LastBannerCheck = DateTime.Now;
accountDbContext.SaveChanges();
if (hasBannerChanged)
{
limitChecker.RefreshHttpChecksNoBannerCount();
}
// Если баннера нет, то надо проверить лимит
if (!hasBanner)
{
var checkResult = limitChecker.CheckMaxHttpChecksNoBanner(accountDbContext);
if (!checkResult.Success)
{
var disableData = new SetUnitTestDisableRequestData()
{
UnitTestId = unitTestId,
Comment = "Проверка выключена из-за отсутствия бесплатного баннера",
ToDate = null
};
Disable(accountId, disableData);
accountDbContext.SaveChanges();
limitChecker.RefreshHttpChecksNoBannerCount();
}
return(checkResult.Success);
}
return(true);
}
}
public ComponentType GetOrCreateComponentType(
Guid accountId,
GetOrCreateComponentTypeRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (data.DisplayName == null)
{
data.DisplayName = data.SystemName;
}
if (data.SystemName == null)
{
data.SystemName = data.DisplayName;
}
if (string.IsNullOrEmpty(data.SystemName))
{
throw new UserFriendlyException("Не задано системное имя типа компонента");
}
var context = Context.GetAccountDbContext(accountId);
var repository = context.GetComponentTypeRepository();
var lockObject = LockObject.ForAccount(accountId);
lock (lockObject)
{
var result = repository.GetOneOrNullBySystemName(data.SystemName);
if (result == null)
{
// Проверим лимит
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var limitCheckResult = checker.CheckMaxComponentTypes(context);
if (!limitCheckResult.Success)
{
throw new OverLimitException(limitCheckResult.Message);
}
result = repository.Add(data.DisplayName, data.SystemName);
checker.RefreshComponentTypesCount();
}
return(result);
}
}
public void SaveLogMessage(Guid accountId, Guid componentId, SendLogData message)
{
// Проверка на наличие необходимых параметров
if (message == null)
{
throw new ParameterRequiredException("Request.Message");
}
if (message.Message == null)
{
throw new ParameterRequiredException("Request.Message.Message"); //todo надо переименовать
}
if (message.Message.Length > 4000)
{
message.Message = message.Message.Substring(0, 4000);
}
if (message.Context != null && message.Context.Length > 255)
{
message.Context = message.Context.Substring(0, 255);
}
// Проверим лимиты
var accountDbContext = Context.GetAccountDbContext(accountId);
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var size = message.GetSize();
checker.CheckLogSizePerDay(accountDbContext, size);
// Проверим лимит размера хранилища
checker.CheckStorageSize(accountDbContext, size);
// Получим компонент
var componentService = Context.ComponentService;
var component = componentService.GetComponentById(accountId, componentId);
var logRepository = Context.DbContext.GetAccountDbContext(accountId).GetLogRepository();
var log = ApiConverter.GetLog(component.Id, message);
logRepository.Add(log);
Context.SaveChanges();
checker.AddLogSizePerDay(accountDbContext, size);
}
public void Delete(Guid accountId, Guid typeId)
{
var repository = Context.GetAccountDbContext(accountId).GetComponentTypeRepository();
var componentType = repository.GetById(typeId);
repository.Remove(componentType);
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
checker.RefreshComponentTypesCount();
var componentService = Context.ComponentService;
foreach (var component in componentType.Components.ToArray())
{
componentService.DeleteComponent(accountId, component.Id);
}
}
public void DeleteUnitTestType(Guid accountId, Guid unitTestTypeId)
{
var request = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = unitTestTypeId
};
using (var unitTest = AllCaches.UnitTestTypes.Write(request))
{
unitTest.IsDeleted = true;
unitTest.BeginSave();
unitTest.WaitSaveChanges();
}
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
checker.RefreshUnitTestTypesCount();
}
public IEventCacheReadObject SendEvent(Guid accountId, Guid componentId, SendEventData message)
{
// Проверим, что компонент вообще есть
var componentRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = componentId
};
var component = AllCaches.Components.Find(componentRequest);
if (component == null)
{
throw new UnknownComponentIdException(componentId, accountId);
}
if (component.CanProcess == false)
{
throw new ResponseCodeException(Zidium.Api.ResponseCode.ObjectDisabled, "Компонент выключен");
}
// проверка лимитов
var accountDbContext = Context.GetAccountDbContext(accountId);
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
limitChecker.CheckEventsRequestsPerDay(accountDbContext);
// Проверим лимит размера хранилища
var size = message.GetSize();
limitChecker.CheckStorageSize(accountDbContext, size);
// todo нет проверки обязательных параметров
FixEventMessageNames(message);
FixEventMessageTypeCode(message);
FixEventMessageJoinKey(message); // todo не уверен, что нужно менять ключ склейки при разных версиях (но склеивать с разными версиями нельзя!)
FixEventMessageJoinInterval(message);
// категория
if (message.Category == null)
{
message.Category = EventCategory.ComponentEvent;
}
// важность
message.Importance = GetEventImportance(message.Importance, message.Category.Value);
if (message.StartDate == null)
{
message.StartDate = DateTime.Now;
}
var eventType = GetOrCreateEventType(
accountId,
message.Category.Value,
message.TypeSystemName,
message.TypeDisplayName,
component.ComponentTypeId,
message.TypeCode);
var joinTime = DataConverter.GetTimeSpanFromSeconds(message.JoinInterval);
var localEvent = CreateEvent(
accountId,
message.StartDate,
message.StartDate,
message.Count,
message.Version,
message.Importance,
TimeSpan.FromMinutes(1),
message.Message,
message.Properties,
eventType,
componentId,
message.JoinKey ?? 0);
// eventType.JoinInterval стоит на первом месте, чтобы можно было изменить поведение БЕЗ перекомпиляции кода
var joinInterval = eventType.JoinInterval ?? joinTime ?? TimeSpan.Zero;
if (!EventCategoryHelper.IsCustomerEventCategory(eventType.Category))
{
throw new Exception("Недопустимая категория события: " + eventType.Category);
}
var result = ProcessSimpleEvent(componentId, localEvent, null, joinInterval, accountId);
limitChecker.AddEventsRequestsPerDay(accountDbContext);
limitChecker.AddEventsSizePerDay(accountDbContext, size);
// если есть закрытый или тестируемый дефект и событие - новая ошибка, то переоткроем дефект
if (eventType.Defect != null)
{
var defectStatus = eventType.Defect.GetStatus();
if ((defectStatus == DefectStatus.Closed || defectStatus == DefectStatus.Testing) && !EventIsOld(eventType.OldVersion, result.Version))
{
var defectService = accountDbContext.GetDefectService();
defectService.AutoReopen(accountId, eventType.Defect);
accountDbContext.SaveChanges();
}
}
// проверим "событие из будущего"
CheckEventStartDate(message, accountId, eventType.Id, result.Id);
return(result);
}
public Component GetOrCreateComponentInternal(Guid accountId, GetOrCreateComponentRequestData data, bool createNew)
{
if (data == null)
{
throw new ParameterRequiredException("Request.Data");
}
if (data.TypeId == null)
{
throw new ParameterRequiredException("Request.Data.TypeId");
}
if (string.IsNullOrEmpty(data.SystemName))
{
throw new ParameterRequiredException("data.SystemName");
}
if (data.ParentComponentId == null)
{
data.ParentComponentId = GetRootId(accountId);
}
var componentId = data.NewId ?? Guid.NewGuid();
var systemName = data.SystemName;
var properties = ApiConverter.GetComponentProperties(data.Properties);
var accountDbContext = Context.GetAccountDbContext(accountId);
var componentRepository = accountDbContext.GetComponentRepository();
var lockObj = LockObject.ForComponent(systemName);
lock (lockObj)
{
// ищем в детях
var component = componentRepository.GetChild(data.ParentComponentId.Value, systemName);
bool isExists = true;
if (component == null)
{
// ищем в папках
var parent = componentRepository.GetById(data.ParentComponentId.Value);
component = FindBySystemName(parent, systemName);
if (component == null)
{
// Проверим лимит
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var limitCheckResult = checker.CheckMaxComponents(accountDbContext);
if (!limitCheckResult.Success)
{
throw new OverLimitException(limitCheckResult.Message);
}
// создаем новый
component = Add(
accountId,
componentId,
data.ParentComponentId.Value,
data.DisplayName ?? systemName,
systemName,
data.TypeId.Value);
isExists = false;
checker.RefreshComponentsCount();
}
}
if (isExists && createNew)
{
throw new ResponseCodeException(
ResponseCode.ParameterError,
"Компонент с таким системным именем уже существует");
}
// обновим версию
if (string.IsNullOrEmpty(data.Version) == false)
{
component.Version = data.Version;
}
// обновим свойства
foreach (var property in properties)
{
component.SetProperty(property);
}
accountDbContext.SaveChanges();
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);
}
}
}
public IMetricCacheReadObject SaveMetric(Guid accountId, SendMetricRequestData data)
{
if (data.Value.HasValue && (double.IsNaN(data.Value.Value) || double.IsInfinity(data.Value.Value)))
{
throw new ParameterErrorException("Metric value can't be Nan or Infinity");
}
var processDate = DateTime.Now;
var accountDbContext = Context.GetAccountDbContext(accountId);
// Проверим лимиты
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
limitChecker.CheckMetricsRequestsPerDay(accountDbContext);
// Проверим лимит размера хранилища
var size = data.GetSize();
limitChecker.CheckStorageSize(accountDbContext, size);
// получим тип метрики
var metricType = GetOrCreateType(accountId, data.Name);
// получим метрику
var componentId = data.ComponentId.Value;
var metricInfo = FindMetric(accountId, componentId, metricType.Id);
if (metricInfo == null)
{
var createMetricLock = LockObject.ForComponent(componentId);
lock (createMetricLock)
{
metricInfo = FindMetric(accountId, componentId, metricType.Id);
if (metricInfo == null)
{
CreateMetric(accountId, componentId, metricType.Id);
metricInfo = FindMetric(accountId, componentId, metricType.Id);
if (metricInfo == null)
{
throw new Exception("Не удалось создать метрику");
}
}
}
}
using (var metric = AllCaches.Metrics.Write(metricInfo))
{
GetActualMetricInternal(metric, processDate);
// если метрика выключена
if (metric.CanProcess == false)
{
throw new ResponseCodeException(Zidium.Api.ResponseCode.ObjectDisabled, "Метрика выключена");
}
// Рассчитаем цвет
ObjectColor color;
string errorMessage = null;
try
{
color = GetColor(metricType, metric, data.Value);
}
catch (Exception exception)
{
color = ObjectColor.Red;
errorMessage = "Ошибка вычисления цвета метрики:" + exception.Message;
}
// Запишем метрику в хранилище
var status = MonitoringStatusHelper.Get(color);
// Время актуальности
var actualTime =
metric.ActualTime
?? metricType.ActualTime
?? TimeSpanHelper.FromSeconds(data.ActualIntervalSecs)
?? TimeSpan.FromHours(1);
var actualDate = processDate + actualTime;
var statusData = SetMetricValue(metricType, metric, data.Value, processDate, actualDate, status, errorMessage, true);
limitChecker.AddMetricsRequestsPerDay(accountDbContext);
limitChecker.AddMetricsSizePerDay(accountDbContext, size);
metric.BeginSave();
return(metric);
}
}
public void DeleteComponent(Guid accountId, Guid componentId)
{
var cache = new AccountCache(accountId);
IComponentCacheReadObject component = null;
ComponentCacheWriteObject componentWrite = null;
// Удаление компонента
using (componentWrite = cache.Components.Write(componentId))
{
if (componentWrite.IsDeleted)
{
return;
}
if (componentWrite.IsRoot)
{
throw new UserFriendlyException("Нельзя удалить root компонент");
}
componentWrite.IsDeleted = true;
componentWrite.BeginSave();
}
componentWrite.WaitSaveChanges(TimeSpan.FromSeconds(30));
component = componentWrite;
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
checker.RefreshComponentsCount();
// удаляем колбаски
foreach (var statusDataId in component.GetAllStatusesIds())
{
using (var statusData = cache.StatusDatas.Write(statusDataId))
{
statusData.IsDeleted = true;
statusData.BeginSave();
}
}
// Удаление метрик
foreach (var meticRef in component.Metrics.GetAll())
{
using (var metric = cache.Metrics.Write(meticRef.Id))
{
metric.IsDeleted = true;
metric.BeginSave();
// удаление колбаски метрики
using (var metricStatusData = cache.StatusDatas.Write(metric.StatusDataId))
{
metricStatusData.IsDeleted = true;
metricStatusData.BeginSave();
}
}
}
// Удаление проверок
foreach (var unitTestRef in component.UnitTests.GetAll())
{
using (var unitTest = cache.UnitTests.Write(unitTestRef.Id))
{
unitTest.IsDeleted = true;
unitTest.BeginSave();
// удаление колбаски проверки
using (var metricStatusData = cache.StatusDatas.Write(unitTest.StatusDataId))
{
metricStatusData.IsDeleted = true;
metricStatusData.BeginSave();
}
}
}
// Удаление вложенных компонентов
foreach (var child in component.Childs.GetAll())
{
DeleteComponent(accountId, child.Id);
}
// Если есть родитель, обновим его статус
if (component.ParentId.HasValue)
{
CalculateAllStatuses(accountId, component.ParentId.Value);
}
}
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);
}
}
}
public void Delete(Guid accountId, Guid unitTestId)
{
// удаляем юнит-тест
var unitTestRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = unitTestId
};
Guid componentId;
Guid componentUnitTestsStatudDataId;
Guid unitTestStatusDataId;
using (var unitTest = AllCaches.UnitTests.Write(unitTestRequest))
{
componentId = unitTest.ComponentId;
unitTestStatusDataId = unitTest.StatusDataId;
unitTest.IsDeleted = true;
unitTest.BeginSave();
}
// удаляем колбасу юнит-теста
var statusDataRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = unitTestStatusDataId
};
using (var statusData = AllCaches.StatusDatas.Write(statusDataRequest))
{
statusData.IsDeleted = true;
statusData.BeginSave();
}
// удаляем ссылку на юнит-тест в компоненте
var componentRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = componentId
};
using (var component = AllCaches.Components.Write(componentRequest))
{
componentUnitTestsStatudDataId = component.UnitTestsStatusId;
component.WriteUnitTests.Delete(unitTestId);
component.BeginSave();
}
// обновляем статус колбаски тестов
var allUnitTestsStatusDataIds = new List <Guid>();
var component1 = AllCaches.Components.Find(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = componentId
});
foreach (var unitTestRef in component1.UnitTests.GetAll())
{
var unitTest = AllCaches.UnitTests.Find(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = unitTestRef.Id
});
if (unitTest != null && unitTest.IsDeleted == false)
{
allUnitTestsStatusDataIds.Add(unitTest.StatusDataId);
}
}
var statuservice = Context.BulbService;
statuservice.CalculateByChilds(accountId, componentUnitTestsStatudDataId, allUnitTestsStatusDataIds);
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
checker.RefreshApiChecksCount();
}
public void DeleteMetric(Guid accountId, DeleteMetricRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (data.MetricId == null)
{
throw new ParameterRequiredException("MetricId");
}
// удаляем метрику
Guid componentId;
Guid statusDataId;
Guid componentMetricsStatusDataId;
var metricRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = data.MetricId.Value
};
using (var metric = AllCaches.Metrics.Write(metricRequest))
{
componentId = metric.ComponentId;
statusDataId = metric.StatusDataId;
metric.IsDeleted = true;
metric.BeginSave();
metric.WaitSaveChanges();
}
// Проверим лимиты
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
limitChecker.RefreshMetricsCount();
// удаляем колбасу метрики
var statusDataRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = statusDataId
};
using (var statusData = AllCaches.StatusDatas.Write(statusDataRequest))
{
statusData.IsDeleted = true;
statusData.BeginSave();
}
// удаляем ссылку на метрику в компоненте
var componentRequest = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = componentId
};
using (var component = AllCaches.Components.Write(componentRequest))
{
componentMetricsStatusDataId = component.MetricsStatusId;
component.WriteChilds.Delete(data.MetricId.Value);
component.BeginSave();
}
// обновим колбасу метрик компонента
var componentMetricsStatusDataIds = new List <Guid>();
var component1 = AllCaches.Components.Find(componentRequest);
foreach (var metricRef in component1.Metrics.GetAll())
{
var metric = AllCaches.Metrics.Find(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = metricRef.Id
});
if (metric == null)
{
throw new Exception("metric == null");
}
if (metric.IsDeleted)
{
continue;
}
componentMetricsStatusDataIds.Add(metric.StatusDataId);
}
Context.BulbService.CalculateByChilds(
accountId,
componentMetricsStatusDataId,
componentMetricsStatusDataIds);
}
public IBulbCacheReadObject SendUnitTestResult(Guid accountId, SendUnitTestResultRequestData data)
{
// Проверка на наличие необходимых параметров
if (data == null)
{
throw new ParameterRequiredException("Request.Data");
}
if (data.UnitTestId == null)
{
throw new ParameterRequiredException("Request.Data.UnitTestId");
}
using (var unitTest = AllCaches.UnitTests.Write(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = data.UnitTestId.Value
}))
{
var processDate = DateTime.Now;
// получим актуальную колбасу, чтобы не было пробелов между результатами
GetUnitTestResultInternal(unitTest, processDate);
// если проверка выключена или выключен один из её родителей
if (unitTest.CanProcess == false)
{
throw new ResponseCodeException(Zidium.Api.ResponseCode.ObjectDisabled, "Проверка выключена");
}
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
// Проверим лимит "Количество запросов в день"
var accountDbContext = Context.GetAccountDbContext(accountId);
checker.CheckUnitTestResultsPerDay(accountDbContext);
// Проверим лимит размера хранилища
var size = data.GetSize();
checker.CheckStorageSize(accountDbContext, size);
var resultEvent = CreateUnitTestResultEvent(unitTest, data, processDate);
if (resultEvent.ActualDate < processDate)
//todo это источник проблем из-за разного времени клиента и сервера
{
// код ниже никогда не выполнится, но пусть на всякий случай будет
throw new ResponseCodeException(
Zidium.Api.ResponseCode.ServerError,
"Результат юнит-теста неактуален (date + actualInterval < now)");
}
//if (resultEvent.ActualDate < unitTest.StatusData.EndDate)
//{
// // код ниже никогда не выполнится, но пусть на всякий случай будет
// throw new ResponseCodeException(
// Zidium.Api.ResponseCode.ServerError,
// "Результат юнит-теста неактуален (actualDate < unitTest.StatusData.EndDate)");
// сохраним результаты
var result = SaveResultEvent(processDate, unitTest, resultEvent);
// увеличим счетчик лимита проверки "Количество запросов в день"
checker.AddUnitTestsSizePerDay(accountDbContext, size);
checker.AddUnitTestResultsPerDay(accountDbContext, unitTest.Id);
return(result);
}
}
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);
}
}
