public SendEmailCommandRepository(AccountDbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Context = context;
}
public ArchivedStatusRepository(AccountDbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Context = context;
}
public DefectService(AccountDbContext accountDbContext)
{
if (accountDbContext == null)
{
throw new ArgumentNullException("accountDbContext");
}
_accountDbContext = accountDbContext;
}
public UserSettingRepository(AccountDbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Context = context;
}
public AccountTariffRepository(AccountDbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Context = context;
}
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);
}
public LimitDataRepository(AccountDbContext context) : base(context)
{
}
public SubscriptionRepository(AccountDbContext context) : base(context)
{
}
public UserRepository(AccountDbContext context) : base(context)
{
}
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 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;
}
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)
{
}
public RoleRepository(AccountDbContext context)
{
Context = context;
}
public ComponentTypeRepository(AccountDbContext context) : base(context)
{
}
public LogRepository(AccountDbContext context)
{
Context = context;
}
public UnitTestRepository(AccountDbContext context) : base(context)
{
}
public StatusDataRepository(AccountDbContext accountDbContext)
: base(accountDbContext)
{
}