public ActionResult Edit(UnitTestTypeEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var repository = CurrentAccountDbContext.GetUnitTestTypeRepository();
var unitTestType = repository.GetById(model.Id);
CheckEditingPermissions(unitTestType);
var client = GetDispatcherClient();
var response = client.UpdateUnitTestType(CurrentUser.AccountId, new UpdateUnitTestTypeRequestData()
{
UnitTestTypeId = unitTestType.Id,
DisplayName = model.DisplayName,
SystemName = model.SystemName,
ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime),
NoSignalColor = model.NoSignalColor.GetSelectedOne()
});
response.Check();
return(RedirectToAction("Show", new { id = model.Id }));
}
protected override void UpdateBatchObject(AccountDbContext accountDbContext, UnitTestCacheWriteObject unitTest, bool useCheck)
{
if (unitTest.Response.LastSavedData == null)
{
throw new Exception("unitTest.Response.LastSavedData == null");
}
var dbEntity = unitTest.Response.LastSavedData.CreateEf();
accountDbContext.UnitTests.Attach(dbEntity);
dbEntity.IsDeleted = unitTest.IsDeleted;
dbEntity.ComponentId = unitTest.ComponentId;
dbEntity.CreateDate = unitTest.CreateDate;
dbEntity.DisplayName = unitTest.DisplayName;
dbEntity.Enable = unitTest.Enable;
dbEntity.DisableComment = unitTest.DisableComment;
dbEntity.DisableToDate = unitTest.DisableToDate;
dbEntity.ErrorColor = unitTest.ErrorColor;
dbEntity.IsDeleted = unitTest.IsDeleted;
dbEntity.NextExecutionDate = unitTest.NextDate;
dbEntity.ParentEnable = unitTest.ParentEnable;
dbEntity.PeriodSeconds = unitTest.PeriodSeconds;
dbEntity.SimpleMode = unitTest.SimpleMode;
dbEntity.StatusDataId = unitTest.StatusDataId;
dbEntity.SystemName = unitTest.SystemName;
dbEntity.NoSignalColor = unitTest.NoSignalColor;
dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(unitTest.ActualTime);
dbEntity.LastExecutionDate = unitTest.LastExecutionDate;
}
public UnitTest CreateEf()
{
return(new UnitTest()
{
Id = Id,
ErrorColor = ErrorColor,
Enable = Enable,
DisplayName = DisplayName,
DisableToDate = DisableToDate,
DisableComment = DisableComment,
CreateDate = CreateDate,
ComponentId = ComponentId,
IsDeleted = IsDeleted,
NextExecutionDate = NextDate,
ParentEnable = ParentEnable,
PeriodSeconds = PeriodSeconds,
SimpleMode = SimpleMode,
StatusDataId = StatusDataId,
SystemName = SystemName,
TypeId = TypeId,
NoSignalColor = NoSignalColor,
ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime),
LastExecutionDate = LastExecutionDate
});
}
public Metric CreateEf()
{
return(new Metric()
{
Id = Id,
Enable = Enable,
DisableComment = DisableComment,
DisableToDate = DisableToDate,
IsDeleted = IsDeleted,
ParentEnable = ParentEnable,
CreateDate = CreateDate,
Value = Value,
BeginDate = BeginDate,
ComponentId = ComponentId,
ActualDate = ActualDate,
MetricTypeId = MetricTypeId,
StatusDataId = StatusDataId,
NoSignalColor = NoSignalColor,
ConditionAlarm = ConditionRed,
ConditionWarning = ConditionYellow,
ConditionSuccess = ConditionGreen,
ConditionElseColor = ElseColor,
ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime)
});
}
protected override void UpdateBatchObject(AccountDbContext accountDbContext, MetricTypeCacheWriteObject metricType, bool useCheck)
{
var oldMetricType = metricType.Response.LastSavedData;
if (oldMetricType == null)
{
throw new Exception("oldMetricType == null");
}
var dbEntity = oldMetricType.CreateEf();
accountDbContext.MetricTypes.Attach(dbEntity);
dbEntity.CreateDate = metricType.CreateDate;
dbEntity.IsDeleted = metricType.IsDeleted;
dbEntity.CreateDate = metricType.CreateDate;
dbEntity.SystemName = metricType.SystemName;
dbEntity.DisplayName = metricType.DisplayName;
dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(metricType.ActualTime);
dbEntity.NoSignalColor = metricType.NoSignalColor;
dbEntity.ConditionAlarm = metricType.ConditionRed;
dbEntity.ConditionWarning = metricType.ConditionYellow;
dbEntity.ConditionSuccess = metricType.ConditionGreen;
dbEntity.ConditionElseColor = metricType.ElseColor;
}
public ActionResult Edit(EventTypeEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var dispatcher = GetDispatcherClient();
var data = new UpdateEventTypeRequestData()
{
EventTypeId = model.Id,
DisplayName = model.DisplayName,
SystemName = model.SystemName,
OldVersion = model.OldVersion,
JoinIntervalSeconds = TimeSpanHelper.GetSeconds(model.JoinInterval),
ImportanceForOld = model.ImportanceForOld,
ImportanceForNew = model.ImportanceForNew,
UpdateActualEvents = true
};
var response = dispatcher.UpdateEventType(CurrentUser.AccountId, data);
response.Check();
this.SetTempMessage(TempMessageType.Success, "Тип события сохранён");
return(RedirectToAction("Show", new { id = model.Id }));
}
public ActionResult Edit(UnitTestEditModel model)
{
model.UnitTest = GetUnitTestById(model.Id);
if (!ModelState.IsValid)
{
View(model);
}
var updateData = new UpdateUnitTestRequestData()
{
NoSignalColor = model.NoSignalColor.GetSelectedOne(),
ActualTime = TimeSpanHelper.GetSeconds(model.ActualTime),
DisplayName = model.DisplayName,
ComponentId = model.ComponentId,
PeriodSeconds = model.PeriodSeconds,
UnitTestId = model.Id,
SystemName = model.UnitTest.SystemName
};
var dispatcher = GetDispatcherClient();
var response = dispatcher.UpdateUnitTest(CurrentUser.AccountId, updateData);
if (response.Success)
{
return(RedirectToAction("ResultDetails", new { id = model.Id }));
}
SetCommonError(response.ErrorMessage);
return(View(model));
}
protected override void UpdateBatchObject(AccountDbContext accountDbContext, MetricCacheWriteObject metric, bool useCheck)
{
var oldMetric = metric.Response.LastSavedData;
if (oldMetric == null)
{
throw new Exception("oldMetric == null");
}
var dbEntity = oldMetric.CreateEf();
accountDbContext.Metrics.Attach(dbEntity);
dbEntity.ActualDate = metric.ActualDate;
dbEntity.BeginDate = metric.BeginDate;
dbEntity.ComponentId = metric.ComponentId;
dbEntity.CreateDate = metric.CreateDate;
dbEntity.Enable = metric.Enable;
dbEntity.DisableComment = metric.DisableComment;
dbEntity.DisableToDate = metric.DisableToDate;
dbEntity.IsDeleted = metric.IsDeleted;
dbEntity.MetricTypeId = metric.MetricTypeId;
dbEntity.ParentEnable = metric.ParentEnable;
dbEntity.StatusDataId = metric.StatusDataId;
dbEntity.Value = metric.Value;
dbEntity.ConditionAlarm = metric.ConditionRed;
dbEntity.ConditionWarning = metric.ConditionYellow;
dbEntity.ConditionSuccess = metric.ConditionGreen;
dbEntity.ActualTimeSecs = TimeSpanHelper.GetSeconds(metric.ActualTime);
dbEntity.NoSignalColor = metric.NoSignalColor;
dbEntity.ConditionElseColor = metric.ElseColor;
}
public ActionResult Edit(EditModel model)
{
if (model.NoSignalColor.Checked == false)
{
ModelState.AddModelError("NoSignalColor", "Выберите цвет");
}
if (!ModelState.IsValid)
{
return(View(model));
}
Guid metricTypeId;
var client = GetDispatcherClient();
if (model.Id.HasValue)
{
metricTypeId = model.Id.Value;
var noSignalColor = model.NoSignalColor.GetSelectedColors().Single();
var updateData = new UpdateMetricTypeRequestData()
{
MetricTypeId = metricTypeId,
SystemName = model.SystemName,
DisplayName = model.DisplayName,
AlarmCondition = model.ConditionRed,
WarningCondition = model.ConditionYellow,
SuccessCondition = model.ConditionGreen,
ElseColor = model.ElseColor.GetSelectedOne(),
ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime),
NoSignalColor = noSignalColor
};
client.UpdateMetricType(CurrentUser.AccountId, updateData).Check();
}
else
{
var createData = new CreateMetricTypeRequestData()
{
SystemName = model.SystemName,
DisplayName = model.DisplayName,
AlarmCondition = model.ConditionRed,
WarningCondition = model.ConditionYellow,
SuccessCondition = model.ConditionGreen,
ElseColor = model.ElseColor.GetSelectedOne(),
NoSignalColor = model.NoSignalColor.GetSelectedColors().SingleOrDefault(),
ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime)
};
var response = client.CreateMetricType(CurrentUser.AccountId, createData);
response.Check();
metricTypeId = response.Data.MetricTypeId;
}
return(RedirectToAction("Show", new { id = metricTypeId }));
}
public void SaveCommonSettings()
{
var dispatcher = FullRequestContext.Current.Controller.GetDispatcherClient();
// получим юнит-тест
if (Id == null)
{
var unitTestResponse = dispatcher.GetOrCreateUnitTest(
User.AccountId,
new GetOrCreateUnitTestRequestData()
{
ComponentId = ComponentId,
SystemName = "GUID_" + Guid.NewGuid(),
DisplayName = CheckName,
UnitTestTypeId = UnitTestTypeId
});
unitTestResponse.Check();
GetUnitTest(unitTestResponse.Data.Id);
}
else
{
GetUnitTest(Id.Value);
}
var isSystem = SystemUnitTestTypes.IsSystem(UnitTest.TypeId);
// обновим данные юнит-теста
var updateResponse = dispatcher.UpdateUnitTest(
User.AccountId,
new UpdateUnitTestRequestData()
{
ComponentId = ComponentId,
DisplayName = CheckName,
PeriodSeconds = Period != null ? Period.Value.TotalSeconds : (double?)null,
ActualTime = !isSystem ? TimeSpanHelper.GetSeconds(ActualTime) : null,
ErrorColor = ErrorColor.GetSelectedUnitTestResultStatuses().FirstOrDefault(),
NoSignalColor = !isSystem ? NoSignalColor.GetSelectedColors().FirstOrDefault() : Core.Common.ObjectColor.Gray,
UnitTestId = UnitTest.Id,
SimpleMode = false
});
updateResponse.Check();
var setNextTime = new SetUnitTestNextTimeRequestData()
{
UnitTestId = UnitTest.Id
};
dispatcher.SetUnitTestNextTime(User.AccountId, setNextTime).Check();
GetUnitTest(UnitTest.Id);
}
public MetricType CreateEf()
{
return(new MetricType()
{
Id = Id,
IsDeleted = IsDeleted,
CreateDate = CreateDate,
SystemName = SystemName,
DisplayName = DisplayName,
ActualTimeSecs = TimeSpanHelper.GetSeconds(ActualTime),
NoSignalColor = NoSignalColor,
ConditionAlarm = ConditionRed,
ConditionWarning = ConditionYellow,
ConditionSuccess = ConditionGreen,
ConditionElseColor = ElseColor
});
}
public void EventTypeShowTest()
{
var account = TestHelper.GetTestAccount();
var user = TestHelper.GetAccountAdminUser(account.Id);
var eventType = TestHelper.GetTestEventType(account.Id);
using (var controller = new EventTypesController(account.Id, user.Id))
{
var result = (ViewResultBase)controller.Show(eventType.Id, TimelineInterval.Day);
var model = (EventTypeShowModel)result.Model;
Assert.Equal(eventType.Id, model.Id);
Assert.Equal(eventType.DisplayName, model.DisplayName);
Assert.Equal(eventType.SystemName, model.SystemName);
Assert.Equal(eventType.Category, model.Category);
Assert.Equal(eventType.JoinIntervalSeconds, TimeSpanHelper.GetSeconds(model.JoinInterval));
Assert.Equal(eventType.OldVersion, model.OldVersion);
Assert.Equal(eventType.ImportanceForOld, model.ImportanceForOld);
Assert.Equal(eventType.ImportanceForNew, model.ImportanceForNew);
Assert.Equal(eventType.IsSystem, model.IsSystem);
}
}
public ActionResult Add(EventTypeEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var repository = CurrentAccountDbContext.GetEventTypeRepository();
var eventType = new EventType()
{
DisplayName = model.DisplayName,
SystemName = model.SystemName,
Category = EventCategory.ComponentEvent,
JoinIntervalSeconds = TimeSpanHelper.GetSeconds(model.JoinInterval),
OldVersion = model.OldVersion,
ImportanceForOld = model.ImportanceForOld,
ImportanceForNew = model.ImportanceForNew
};
repository.Add(eventType);
this.SetTempMessage(TempMessageType.Success, string.Format("Добавлен тип события <a href='{1}' class='alert-link'>{0}</a>", eventType.DisplayName, Url.Action("Show", new { id = eventType.Id })));
return(RedirectToAction("Index"));
}
public ActionResult Edit(SubscriptionEditModel model)
{
var modelState = new ModelStateHelper <SubscriptionEditModel>(ModelState);
// Проверка ComponentTypeId
if (model.Object == SubscriptionObject.ComponentType && model.ComponentTypeId == null)
{
modelState.AddErrorFor(x => x.ComponentTypeId, "Выберите тип компонента");
}
// Проверка ComponentId
if (model.Object == SubscriptionObject.Component && model.ComponentId == null)
{
modelState.AddErrorFor(x => x.ComponentId, "Выберите компонент");
}
// Проверка Channel
if (model.Id == null && model.Channel == null)
{
// канал должен указываться явно только для новых подписок
modelState.AddErrorFor(x => x.Channel, "Выберите канал");
}
// Проверка UserId
if (model.Id == null && model.UserId == null)
{
// Пользователь должен указываться явно только для новых подписок
modelState.AddErrorFor(x => x.UserId, "Выберите пользователя");
}
// проверка цвета
var color = model.Color.GetSelectedOne();
if (color == null)
{
modelState.AddErrorFor(x => x.Color, "Укажите цвет");
}
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
// проверка прав
var isOtherUser = CurrentUser.Id != model.UserId;
if (isOtherUser)
{
if (CurrentUser.IsAdmin() == false)
{
throw new UserFriendlyException("Нет прав на создание подписок другим пользователям");
}
}
var importance = ImportanceHelper.Get(color).Value;
var client = GetDispatcherClient();
if (model.Id == null)
{
// создание новой подписки
var createData = new CreateSubscriptionRequestData()
{
UserId = model.UserId.Value,
Channel = model.Channel.Value,
DurationMinimumInSeconds = TimeSpanHelper.GetSeconds(model.MinimumDuration),
ResendTimeInSeconds = TimeSpanHelper.GetSeconds(model.ResendTime),
Importance = importance,
IsEnabled = model.IsEnabled,
NotifyBetterStatus = model.NotifyBetterStatus,
Object = model.Object
};
if (model.Object == SubscriptionObject.Component)
{
createData.ComponentId = model.ComponentId;
}
if (model.Object == SubscriptionObject.ComponentType)
{
createData.ComponentTypeId = model.ComponentTypeId;
}
var response = client.CreateSubscription(CurrentUser.AccountId, createData);
response.Check();
model.Id = response.Data.Id;
}
else
{
// редактирование существующей подписки
var updateData = new UpdateSubscriptionRequestData()
{
Id = model.Id.Value,
NotifyBetterStatus = model.NotifyBetterStatus,
IsEnabled = model.IsEnabled,
ResendTimeInSeconds = TimeSpanHelper.GetSeconds(model.ResendTime),
DurationMinimumInSeconds = TimeSpanHelper.GetSeconds(model.MinimumDuration),
Importance = importance
};
var response = client.UpdateSubscription(CurrentUser.AccountId, updateData);
response.Check();
}
if (model.ModalMode)
{
return(GetSuccessJsonResponse(new { subscriptionId = model.Id }));
}
return(Redirect(model.ReturnUrl));
}
catch (UserFriendlyException exception)
{
model.Exception = exception;
}
return(View(model));
}
public UnitTest SaveSimpleCheck(T model)
{
var dispatcher = GetDispatcherClient();
var unitTestDisplayName = GetUnitTestDisplayName(model);
if (model.Id.HasValue)
{
var unitTest = GetUnitTestById(model.Id.Value);
var updateData = new UpdateUnitTestRequestData()
{
ComponentId = unitTest.ComponentId,
DisplayName = unitTestDisplayName,
PeriodSeconds = TimeSpanHelper.GetSeconds(model.Period),
UnitTestId = unitTest.Id,
ErrorColor = unitTest.ErrorColor,
NoSignalColor = ObjectColor.Gray,
SystemName = unitTest.SystemName,
SimpleMode = true
};
dispatcher.UpdateUnitTest(CurrentUser.AccountId, updateData).Check();
// Зем: название компонента решили не менять, чтобы не было неожиданных сюрпризов,
// меняешь проверку, а меняется компонент, если нужно изменить название компонента,
// пусть пользователь сделает это явно вручную
// Обновим параметры
SetUnitTestParams(unitTest, model);
CurrentAccountDbContext.SaveChanges();
this.SetTempMessage(TempMessageType.Success, string.Format("Обновлена проверка <a href='{1}' class='alert-link'>{0}</a>", unitTest.DisplayName, Url.Action("Edit", "Checks", new { id = unitTest.Id })));
return(unitTest);
}
else // создание проверки
{
// Создаём компонент только если его ещё нет
ComponentInfo component;
if (!model.ComponentId.HasValue)
{
// Создадим папку для компонента
var componentRepository = CurrentAccountDbContext.GetComponentRepository();
var root = componentRepository.GetRoot();
var createFolderResponse = dispatcher.GetOrCreateComponent(CurrentUser.AccountId, new GetOrCreateComponentRequestData()
{
SystemName = GetFolderSystemName(model),
DisplayName = GetFolderDisplayName(model),
TypeId = SystemComponentTypes.Folder.Id,
ParentComponentId = root.Id
});
if (!createFolderResponse.Success)
{
throw new UserFriendlyException("Ошибка создания папки для проверки: " + createFolderResponse.ErrorMessage);
}
var folder = createFolderResponse.Data.Component;
// Создадим тип компонента
var createComponentTypeResponse = dispatcher.GetOrCreateComponentType(CurrentUser.AccountId, new GetOrCreateComponentTypeRequestData()
{
SystemName = GetTypeSystemName(model),
DisplayName = GetTypeDisplayName(model)
});
if (!createComponentTypeResponse.Success)
{
throw new UserFriendlyException("Ошибка создания типа компонента для проверки: " + createComponentTypeResponse.ErrorMessage);
}
var componentType = createComponentTypeResponse.Data;
// Создадим компонент
var componentId = Guid.NewGuid();
var createComponentResponse = dispatcher.GetOrCreateComponent(CurrentUser.AccountId, new GetOrCreateComponentRequestData()
{
NewId = componentId,
SystemName = GetComponentSystemName(componentId),
DisplayName = GetComponentDisplayName(model),
TypeId = componentType.Id,
ParentComponentId = folder.Id
});
if (!createComponentResponse.Success)
{
throw new UserFriendlyException("Ошибка создания компонента для проверки: " + createComponentResponse.ErrorMessage);
}
component = createComponentResponse.Data.Component;
}
else
{
component = dispatcher.GetComponentById(CurrentUser.AccountId, model.ComponentId.Value).Data;
}
// Создадим проверку
var unitTestId = Guid.NewGuid();
var createUnitTestData = new GetOrCreateUnitTestRequestData()
{
ActualTimeSecs = null,
ComponentId = component.Id,
DisplayName = unitTestDisplayName,
ErrorColor = UnitTestResult.Alarm,
NewId = unitTestId,
SimpleMode = true,
NoSignalColor = ObjectColor.Gray,
PeriodSeconds = TimeSpanHelper.GetSeconds(model.Period),
SystemName = UnitTestHelper.GetDynamicSystemName(unitTestId),
UnitTestTypeId = GetUnitTestTypeId()
};
dispatcher.GetOrCreateUnitTest(CurrentUser.AccountId, createUnitTestData).Check();
var unitTest = GetUnitTestById(unitTestId);
SetUnitTestParams(unitTest, model);
CurrentAccountDbContext.SaveChanges();
this.SetTempMessage(TempMessageType.Success, string.Format("Добавлена проверка <a href='{1}' class='alert-link'>{0}</a>", unitTest.DisplayName, Url.Action("Edit", "Checks", new { id = unitTest.Id })));
return(unitTest);
}
}
public ActionResult Edit(EditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var component = GetComponentById(model.ComponentId.Value);
if (model.Id == null)
{
var oldMetric = component.Metrics.FirstOrDefault(x => x.IsDeleted == false && x.MetricTypeId == model.MetricTypeId);
if (oldMetric != null)
{
ModelState.AddModelError("MetricTypeId", "Метрика данного типа уже есть у компонента");
return(View(model));
}
}
var client = GetDispatcherClient();
Guid metricId;
if (model.Id.HasValue)
{
metricId = model.Id.Value;
var updateData = new UpdateMetricRequestData()
{
MetricId = model.Id.Value,
AlarmCondition = model.ConditionRed,
WarningCondition = model.ConditionYellow,
SuccessCondition = model.ConditionGreen,
ElseColor = model.ElseColor.GetSelectedOne(),
ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime),
NoSignalColor = model.NoSignalColor.GetSelectedOne()
};
client.UpdateMetric(CurrentUser.AccountId, updateData).Check();
}
else
{
var metricType = GetMetricTypeById(model.MetricTypeId.Value);
var createData = new CreateMetricRequestData()
{
ComponentId = model.ComponentId.Value,
MetricName = metricType.SystemName,//todo сделать отдельную версию, где передается MetricTypeId
AlarmCondition = model.ConditionRed,
WarningCondition = model.ConditionYellow,
SuccessCondition = model.ConditionGreen,
ElseColor = model.ElseColor.GetSelectedOne(),
NoSignalColor = model.NoSignalColor.GetSelectedOne(),
ActualTimeSecs = TimeSpanHelper.GetSeconds(model.ActualTime)
};
metricId = client.CreateMetric(CurrentUser.AccountId, createData).Data.MetricId;
}
return(RedirectToAction("Show", new { id = metricId }));
}
catch (UserFriendlyException exception)
{
SetCommonError(exception);
if (model.Id.HasValue)
{
model.Metric = GetMetricById(model.Id.Value);
}
return(View(model));
}
}
