public void ReturnsTrueIfActiveIncident()
{
var parentRowKey = "parentRowKey";
var group = new IncidentGroupEntity
{
StartTime = Cursor - StartMessageDelay,
RowKey = parentRowKey
};
var unlinkedIncident = new IncidentEntity
{
StartTime = Cursor,
ParentRowKey = "something else"
};
var shortIncident = new IncidentEntity
{
StartTime = Cursor - StartMessageDelay,
EndTime = Cursor - TimeSpan.FromTicks(1),
ParentRowKey = parentRowKey
};
var activeIncident = new IncidentEntity
{
StartTime = Cursor - StartMessageDelay,
ParentRowKey = parentRowKey
};
Table.SetupQuery(unlinkedIncident, shortIncident, activeIncident);
var result = Filter.CanPostMessages(group, Cursor);
Assert.True(result);
}
public async Task DeactivatesIfMitigated()
{
var cursor = new DateTime(2018, 10, 10);
var incidentEntity = new IncidentEntity
{
IncidentApiId = "id"
};
var incident = new Incident
{
MitigationData = new IncidentStateChangeEventData
{
Date = new DateTime(2018, 10, 11)
}
};
Client
.Setup(x => x.GetIncident(incidentEntity.IncidentApiId))
.ReturnsAsync(incident);
Table
.Setup(x => x.ReplaceAsync(incidentEntity))
.Returns(Task.CompletedTask)
.Verifiable();
await Updater.UpdateAsync(incidentEntity, cursor);
Assert.Equal(incident.MitigationData.Date, incidentEntity.EndTime);
Assert.False(incidentEntity.IsActive);
Table.Verify();
}
public Task <IncidentEntity> AddIncident(IncidentEntity incident)
{
var count = _incidentStore.Count;
incident.Id = count + 1;
incident.CreatedDate = DateTime.Now;
_incidentStore.Add(incident);
return(Task.FromResult(incident));
}
public Void execute(CommandContext commandContext)
{
IncidentContext incidentContext = new IncidentContext();
incidentContext.ExecutionId = execution.Id;
IncidentEntity.createAndInsertIncident("foo", incidentContext, null);
return(null);
}
public virtual object Execute(CommandContext commandContext)
{
var incidentContext = new IncidentContext();
incidentContext.ExecutionId = _execution.Id;
IncidentEntity.CreateAndInsertIncident("foo", incidentContext, null);
return(null);
}
public virtual IIncident CreateIncident(IncidentContext context, string message)
{
var newIncident = IncidentEntity.CreateAndInsertIncident(IncidentHandlerType, context, message);
if (!ReferenceEquals(context.ExecutionId, null))
{
newIncident.CreateRecursiveIncidents();
}
return(newIncident);
}
public virtual Incident createIncident(IncidentContext context, string message)
{
IncidentEntity newIncident = IncidentEntity.createAndInsertIncident(type, context, message);
if (!string.ReferenceEquals(context.ExecutionId, null))
{
newIncident.createRecursiveIncidents();
}
return(newIncident);
}
public async Task CreatesEntityAndDoesNotIncreaseSeverity(ComponentStatus existingStatus)
{
var input = new ParsedIncident(Incident, "the path", ComponentStatus.Degraded);
IncidentEntity entity = null;
Table
.Setup(x => x.InsertOrReplaceAsync(It.IsAny <ITableEntity>()))
.Returns(Task.CompletedTask)
.Callback <ITableEntity>(e =>
{
Assert.IsType <IncidentEntity>(e);
entity = e as IncidentEntity;
});
var group = new IncidentGroupEntity
{
RowKey = "parentRowKey",
AffectedComponentStatus = (int)existingStatus
};
Provider
.Setup(x => x.GetAsync(input))
.ReturnsAsync(group);
var expectedPath = "the provided path";
PathProvider
.Setup(x => x.Get(input))
.Returns(expectedPath);
var result = await Factory.CreateAsync(input);
Assert.Equal(entity, result);
Assert.Equal(input.Id, entity.IncidentApiId);
Assert.Equal(group.RowKey, entity.ParentRowKey);
Assert.Equal(expectedPath, entity.AffectedComponentPath);
Assert.Equal((int)input.AffectedComponentStatus, entity.AffectedComponentStatus);
Assert.Equal(input.StartTime, entity.StartTime);
Assert.Equal(input.EndTime, entity.EndTime);
Assert.Equal((int)existingStatus, group.AffectedComponentStatus);
Table
.Verify(
x => x.InsertOrReplaceAsync(It.IsAny <IncidentEntity>()),
Times.Once());
Table
.Verify(
x => x.ReplaceAsync(It.IsAny <IncidentGroupEntity>()),
Times.Never());
}
public Tuple <bool, string> Post(IncidentEntity entity)
{
// ManageSQLConnection sqlConnection = new ManageSQLConnection();
MySqlConnection sqlConnection = new MySqlConnection();
MySqlTransaction objTrans = null;
string connectionString = GlobalVariables.ConnectionString;
using (sqlConnection = new MySqlConnection(connectionString))
{
DataSet ds = new DataSet();
cmd = new MySqlCommand();
try
{
if (sqlConnection.State == 0)
{
sqlConnection.Open();
}
objTrans = sqlConnection.BeginTransaction();
cmd.Transaction = objTrans;
cmd.Connection = sqlConnection;
cmd.CommandText = "InsertIncidentDetails";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@rcode", entity.RCode);
cmd.Parameters.AddWithValue("@dcode", entity.DCode);
cmd.Parameters.AddWithValue("@shopcode", entity.ShopCode);
cmd.Parameters.AddWithValue("@doc_date", entity.DocDate);
cmd.Parameters.AddWithValue("@reason", entity.Reason);
cmd.Parameters.AddWithValue("@url_path", entity.URL);
cmd.Parameters.AddWithValue("@remarks", entity.Remarks);
cmd.ExecuteNonQuery();
objTrans.Commit();
cmd.Parameters.Clear();
cmd.Dispose();
return(new Tuple <bool, string>(true, JsonConvert.SerializeObject(ds)));
}
catch (Exception ex)
{
AuditLog.WriteError(ex.Message + " : " + ex.StackTrace);
objTrans.Rollback();
return(new Tuple <bool, string>(false, "Exception occured"));
}
finally
{
sqlConnection.Close();
cmd.Dispose();
ds.Dispose();
}
}
}
public static ReportIncidentResponse ToIncidentResponse(this IncidentEntity entity)
{
return(new ReportIncidentResponse
{
CreatedDate = entity.CreatedDate,
Id = entity.Id,
Location = new Location()
{
Latitude = entity.Latitude,
Longitude = entity.Longitude
},
Reference = entity.Reference.ToString()
});
}
protected internal virtual void removeIncident(IncidentContext context, bool incidentResolved)
{
IList <Incident> incidents = Context.CommandContext.IncidentManager.findIncidentByConfiguration(context.Configuration);
foreach (Incident currentIncident in incidents)
{
IncidentEntity incident = (IncidentEntity)currentIncident;
if (incidentResolved)
{
incident.resolve();
}
else
{
incident.delete();
}
}
}
public async Task <IActionResult> ReportIncident([FromBody] ReportIncidentRequest incidentRequest)
{
var incident = new IncidentEntity()
{
AudienceType = incidentRequest.Audience.Type,
Description = incidentRequest.Situation.Description,
Latitude = incidentRequest.Location.Latitude,
Longitude = incidentRequest.Location.Longitude,
NoOfAudience = incidentRequest.Audience.Number,
Reference = Guid.NewGuid(),
};
var createdIncident = await _incidentRepository.AddIncident(incident).ConfigureAwait(false);
var incidentResponse = createdIncident.ToIncidentResponse();
return(Ok(incidentResponse));
}
public async Task <IActionResult> NewIncident(IncidentModel model)
{
//if (!ModelState.IsValid)
//{
// return BadRequest();
//}
var incident = new IncidentEntity
{
Description = model.Description,
Latitude = model.Latitude,
Longitude = model.Longitude,
Group = model.Group,
};
_dbContext.Add(incident);
await _dbContext.SaveChangesAsync();
return(RedirectToAction("IncidentList"));
}
protected internal virtual void InitHistoricIncidentEvent(Event.HistoricIncidentEntity evt, IIncident incident, IHistoryEventType eventType)
{
// init properties
evt.Id = incident.Id;
evt.ProcessDefinitionId = incident.ProcessDefinitionId;
evt.ProcessInstanceId = incident.ProcessInstanceId;
evt.ExecutionId = incident.ExecutionId;
evt.CreateTime = incident.IncidentTimestamp;
evt.IncidentType = incident.IncidentType;
evt.ActivityId = incident.ActivityId;
evt.CauseIncidentId = incident.CauseIncidentId;
evt.RootCauseIncidentId = incident.RootCauseIncidentId;
evt.Configuration = incident.Configuration;
evt.IncidentMessage = incident.IncidentMessage;
evt.TenantId = incident.TenantId;
evt.JobDefinitionId = incident.JobDefinitionId;
IncidentEntity incidentEntity = (IncidentEntity)incident;
ProcessDefinitionEntity definition = incidentEntity.ProcessDefinition;
if (definition != null)
{
evt.ProcessDefinitionKey = definition.Key;
}
// init event type
evt.EventType = eventType.EventName;
// init state
IIncidentState incidentState = IncidentStateFields.Deleted;
if (HistoryEventTypes.IncidentDelete == eventType)
{
incidentState = IncidentStateFields.Deleted;
}
else if (HistoryEventTypes.IncidentResolve.Equals(eventType))
{
incidentState = IncidentStateFields.Resolved;
}
evt.IncidentState = incidentState.StateCode;
}
private CoreIncidentDto InsertOrUpdate(CoreIncidentDto dto)
{
using (var adapter = new DataAccessAdapter())
{
var data = new LinqMetaData(adapter);
var entity = data.Incident.FirstOrDefault(CoreIncidentDtoPersistence.CreatePkPredicate(dto));
if (entity == null)
{
entity = new IncidentEntity();
}
entity.UpdateFromCoreIncidentDto(dto);
adapter.SaveEntity(entity, true);
//We need to do this extra call as per https://www.llblgen.com/Documentation/5.3/Derived%20Models/dto_llblgen.htm#example-projection-on-database-query
var result = data.Incident.Where(x => x.Id == entity.Id).ProjectToCoreIncidentDto().ToList();
return(result[0]);
}
}
public async Task IgnoresDeactivatedIncidents()
{
var cursor = new DateTime(2018, 10, 10);
var endTime = new DateTime(2018, 10, 11);
var incidentEntity = new IncidentEntity
{
EndTime = endTime
};
await Updater.UpdateAsync(incidentEntity, cursor);
Assert.Equal(endTime, incidentEntity.EndTime);
Client
.Verify(
x => x.GetIncident(It.IsAny <string>()),
Times.Never());
Table
.Verify(
x => x.ReplaceAsync(It.IsAny <ITableEntity>()),
Times.Never());
}
public async Task DoesNotSaveIfNotMitigated()
{
var cursor = new DateTime(2018, 10, 10);
var incidentEntity = new IncidentEntity
{
IncidentApiId = "id"
};
var incident = new Incident();
Client
.Setup(x => x.GetIncident(incidentEntity.IncidentApiId))
.ReturnsAsync(incident);
await Updater.UpdateAsync(incidentEntity, cursor);
Assert.True(incidentEntity.IsActive);
Table
.Verify(
x => x.ReplaceAsync(It.IsAny <ITableEntity>()),
Times.Never());
}
public void HandleIncident(IncidentContext context, string message)
{
IncidentEntity.CreateAndInsertIncident(incidentType, context, message);
}
public virtual void consume(IncidentEntity incident)
{
incidents_Renamed.remove(incident);
}
public virtual Incident handleIncident(IncidentContext context, string message)
{
return(IncidentEntity.createAndInsertIncident(incidentType, context, message));
}
public virtual void Consume(IncidentEntity incident)
{
IncidentsRenamed.Remove(incident);
}
protected internal virtual void SwitchVersionOfIncident(CommandContext commandContext,
IncidentEntity incidentEntity, ProcessDefinitionEntity newProcessDefinition)
{
incidentEntity.ProcessDefinitionId = newProcessDefinition.Id;
}
public MigratingIncident(IncidentEntity incident, ScopeImpl targetScope)
{
this.Incident = incident;
this.TargetScope = targetScope;
}
