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 UpdateEventTypeResponse UpdateEventType(Guid accountId, UpdateEventTypeRequestData data)
{
var request = GetRequest <UpdateEventTypeRequest>(accountId);
request.Data = data;
var dispatcher = DispatcherHelper.GetDispatcherService();
return(dispatcher.UpdateEventType(request));
}
public JsonResult ChangeImportance(ChangeImportanceModel model)
{
try
{
var eventType = GetEventTypeById(model.EventTypeId);
if (model.EventTypeId == Guid.Empty)
{
throw new UserFriendlyException("Не удалось получить ИД типа события");
}
if (model.Importance == null)
{
throw new UserFriendlyException("Не удалось получить важность");
}
if (model.Version != null && VersionHelper.FromString(model.Version) == null)
{
throw new UserFriendlyException("Неверный формат версии");
}
var dispatcher = GetDispatcherClient();
var data = new UpdateEventTypeRequestData()
{
EventId = model.EventId,
EventTypeId = model.EventTypeId,
DisplayName = eventType.DisplayName,
ImportanceForNew = eventType.ImportanceForNew,
ImportanceForOld = eventType.ImportanceForOld,
OldVersion = eventType.OldVersion,
UpdateActualEvents = true
};
if (string.IsNullOrEmpty(model.Version))
{
data.ImportanceForNew = model.Importance.Value;
data.OldVersion = null;
}
else
{
data.ImportanceForOld = model.Importance.Value;
data.OldVersion = model.Version;
}
dispatcher.UpdateEventType(CurrentUser.AccountId, data).Check();
return(GetSuccessJsonResponse());
}
catch (Exception exception)
{
MvcApplication.HandleException(exception);
return(GetErrorJsonResponse(exception));
}
}
public void UpdateComponentStatus2Test()
{
var account = TestHelper.GetTestAccount();
var client = account.GetClient();
var component = account.CreateRandomComponentControl();
// Отправляем ошибку
var error = TestHelper.CreateRandomApplicationError(component);
error.JoinInterval = TimeSpan.Zero;
error.Importance = EventImportance.Alarm;
error.StartDate = DateTime.Now;
error.Version = "2.0.0.0";
var eventResponse = error.Send();
Assert.True(eventResponse.Success);
// Проверим, что статус компонента Alarm
var state = component.GetTotalState(false);
Assert.Equal(MonitoringStatus.Alarm, state.Data.Status);
// Отметим в типе события, что для данной версии нужно снижать важность и считать их обработанными
var dispatcher = account.GetDispatcherClient();
var updateData = new UpdateEventTypeRequestData()
{
EventTypeId = eventResponse.Data.EventTypeId,
DisplayName = null,
OldVersion = error.Version,
ImportanceForOld = Zidium.Core.Api.EventImportance.Warning,
ImportanceForNew = null,
UpdateActualEvents = true
};
dispatcher.UpdateEventType(account.Id, updateData).Check();
// Отправим ещё раз
error.Send();
Assert.True(eventResponse.Success);
// Проверим, что статус компонента Alarm
account.SaveAllCaches();
state = client.ApiService.GetComponentTotalState(component.Info.Id, false);
Assert.Equal(MonitoringStatus.Warning, state.Data.Status);
}
public void Update(Guid accountId, UpdateEventTypeRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var accountDbContext = Context.GetAccountDbContext(accountId);
var repository = GetEventTypeRepository(accountId);
var eventType = repository.GetById(data.EventTypeId);
if (eventType.IsSystem)
{
throw new UserFriendlyException("Нельзя менять системный тип события");
}
eventType.OldVersion = data.OldVersion;
eventType.ImportanceForOld = data.ImportanceForOld;
eventType.ImportanceForNew = data.ImportanceForNew;
eventType.JoinIntervalSeconds = data.JoinIntervalSeconds;
if (string.IsNullOrEmpty(data.DisplayName) == false)
{
eventType.DisplayName = data.DisplayName;
}
if (string.IsNullOrEmpty(data.SystemName) == false)
{
eventType.SystemName = data.SystemName;
}
accountDbContext.SaveChanges();
if (data.UpdateActualEvents == false)
{
return;
}
// Обновим старые события
long?oldVersion = VersionHelper.FromString(eventType.OldVersion);
var now = DateTime.Now;
var components = new List <Guid>();
var eventRepository = accountDbContext.GetEventRepository();
var events = eventRepository
.GetAllByType(eventType.Id)
.Where(t => t.ActualDate >= now) // неактуальные уже нина что не влияют, нет смысла их менять
.ToList();
// если есть событие - инициатор (на основании которого решили изменить важность)
if (data.EventId.HasValue)
{
var eventObj = eventRepository.GetById(data.EventId.Value);
events.Add(eventObj);
}
// обновим события в БД
foreach (var _event in events)
{
if (eventType.ImportanceForOld.HasValue && _event.VersionLong <= oldVersion)
{
// ставим важность для старых событий
if (_event.Importance != eventType.ImportanceForOld.Value)
{
_event.Importance = eventType.ImportanceForOld.Value;
components.Add(_event.OwnerId);
}
}
else if (eventType.ImportanceForNew.HasValue &&
(oldVersion == null || _event.VersionLong > oldVersion))
{
// ставим важность для новых событий
if (_event.Importance != eventType.ImportanceForNew.Value)
{
_event.Importance = eventType.ImportanceForNew.Value;
components.Add(_event.OwnerId);
}
}
}
accountDbContext.SaveChanges();
// выгрузим события из кэша
foreach (var _event in events)
{
AllCaches.Events.Unload(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = _event.Id
});
}
// обновим статусы компонентов
var componentIds = components.Distinct().ToList();
foreach (var id in componentIds)
{
Context.ComponentService.CalculateEventsStatus(accountId, id);
}
}
