public void ProcessData(ScenarioCampaignFailureOutput data, Run run, Scenario scenario)
{
if (!_saveData)
{
PreGenerateReport(data.Data, run, scenario);
return;
}
try
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start insert of campaign failures. ScenarioId: {data.ScenarioId} Count: {data.Data.Count}"));
using (var internalScope = _repositoryFactory.BeginRepositoryScope())
{
var scenarioCampaignFailureRepository = internalScope.CreateRepository <IScenarioCampaignFailureRepository>();
scenarioCampaignFailureRepository.AddRange(data.Data, false);
scenarioCampaignFailureRepository.SaveChanges();
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Complete insert of campaign failures. ScenarioId: {data.ScenarioId} Count: {data.Data.Count}"));
}
catch (Exception e)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error while processing scenario campaign failures. ScenarioId: {scenario.Id}", e));
throw;
}
PreGenerateReport(data.Data, run, scenario);
}
public ScenarioCampaignLevelResult ProcessFile(Guid scenarioId, string folder)
{
string pathToFile = FileHelpers.GetPathToFileIfExists(folder, FileName);
var result = new ScenarioCampaignLevelResult {
Id = scenarioId
};
if (string.IsNullOrEmpty(pathToFile))
{
_audit.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, $"File {pathToFile} was not found."));
return(result);
}
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processing output file {pathToFile}"));
var importSettings = CSVImportSettings.GetImportSettings(pathToFile, typeof(ScenarioCampaignLevelResultHeaderMap), typeof(ScenarioCampaignLevelResultIndexMap));
IScenarioCampaignLevelResultsImportRepository repository = new CSVScenarioCampaignLevelResultsImportRepository(importSettings);
var data = repository.GetAll();
result.Items = _mapper.Map <List <ScenarioCampaignLevelResultItem> >(data);
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processed output file {pathToFile}"));
return(result);
}
public IEnumerable <ConversionEfficiency> Process(string pathToFile)
{
if (!File.Exists(pathToFile))
{
_audit?.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, "File was not found."));
return(Enumerable.Empty <ConversionEfficiency>());
}
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processing output file {pathToFile}"));
try
{
var importSettings = CSVImportSettings.GetImportSettings(pathToFile, typeof(ConversionEfficiencyHeaderMap), typeof(ConversionEfficiencyIndexMap));
var conversionEfficiency = new CSVConversionEfficiencyImportRepository(importSettings);
var data = conversionEfficiency.GetAll();
var output = _mapper.Map <IEnumerable <ConversionEfficiency> >(data);
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processed output file {pathToFile}"));
return(output);
}
catch (Exception exception)
{
_audit?.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error processing file {pathToFile}", exception));
return(Enumerable.Empty <ConversionEfficiency>());
}
}
public void ProcessScenarioCampaignMetrics(Guid runId, Guid scenarioId, IEnumerable <Recommendation> scenarioRecommendations)
{
try
{
var scenarioCampaignMetrics = new ScenarioCampaignMetric
{
Id = scenarioId,
Metrics = GenerateCampaignKPIs(runId, scenarioId, scenarioRecommendations)
};
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start insert of scenario campaign metrics. ScenarioId: {scenarioId} Count: {scenarioCampaignMetrics.Metrics.Count}"));
using (var innerScope = _repositoryFactory.BeginRepositoryScope())
{
var scenarioCampaignMetricRepository = innerScope.CreateRepository <IScenarioCampaignMetricRepository>();
scenarioCampaignMetricRepository.AddOrUpdate(scenarioCampaignMetrics);
scenarioCampaignMetricRepository.SaveChanges();
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"End insert of scenario campaign metrics. ScenarioId: {scenarioId} Count: {scenarioCampaignMetrics.Metrics.Count}"));
}
catch (Exception e)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error while processing scenario campaign metrics. ScenarioId: {scenarioId}", e));
}
}
/// <summary>
/// It is called dynamically.
/// </summary>
public async Task Execute(CancellationToken cancellationToken, AutoBook autoBook)
{
try
{
try
{
_autoBooks.Create(autoBook);
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Creating AutoBook instance (AutoBookID={autoBook.Id}): Waiting for Idle notification"));
}
catch (Exception ex)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0,
$"Error creating AutoBook (AutoBookID={autoBook.Id})", ex));
autoBook.Status = AutoBookStatuses.Fatal_Error;
_autoBookRepository.Update(autoBook);
}
}
finally
{
foreach (var dbContext in _tenantDbContexts)
{
try
{
await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
catch //ignore exception
{
}
}
}
}
public void ProcessData(SpotsReqmOutput data, Run run, Scenario scenario)
{
try
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start insert of recommendations. ScenarioId: {data.ScenarioId} Count: {data.Recommendations.Count}"));
using (var innerScope = _repositoryFactory.BeginRepositoryScope())
{
var recommendationBatchRepository = innerScope.CreateRepository <IRecommendationRepository>();
recommendationBatchRepository.Insert(data.Recommendations, false);
recommendationBatchRepository.SaveChanges();
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"End insert of recommendations. ScenarioId: {data.ScenarioId}"));
}
catch (Exception e)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error while processing scenario recommendations. ScenarioId: {scenario.Id}", e));
throw;
}
// do not generate report for scenario with smooth
if (run.Smooth)
{
return;
}
var fileName = ReportFileNameHelper.RecommendationResult(run, scenario);
PreGenerateReport(data.Recommendations, fileName, scenario.Id);
}
private void PreGenerateReport(IReadOnlyCollection <Recommendation> data, string fileName, Guid scenarioId)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start recommendations report generation. ScenarioId: {scenarioId} Count: {data.Count}"));
try
{
using (var reportStream = _recommendationsReportCreator.GenerateReport(data))
{
_ = _cloudStorage.Upload(new S3UploadComment
{
BucketName = _awsSettings.S3Bucket,
DestinationFilePath = fileName,
FileStream = reportStream
});
}
}
catch (Exception e)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error while generating report for scenario recommendations. ScenarioId: {scenarioId}", e));
throw;
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"End recommendations report generation. ScenarioId: {scenarioId}"));
}
/// <summary>
/// Waits for the task instance status to change or timeout
/// </summary>
/// <param name="id"></param>
/// <param name="process"></param>
/// <param name="currentStatus"></param>
/// <param name="timeout"></param>
/// <returns></returns>
private TaskInstanceStatues WaitForStatusChange(Guid id, Process process, TaskInstanceStatues currentStatus, TimeSpan timeout)
{
var timeNow = DateTime.UtcNow;
var waitTimeout = timeNow.Add(timeout);
TaskInstanceStatues newStatus = currentStatus;
do
{
// Wait a bit before we check the status
if (!process.HasExited)
{
Thread.Sleep(2000);
}
using var scope = _repositoryFactory.BeginRepositoryScope();
var taskInstanceRepository = scope.CreateRepository <ITaskInstanceRepository>();
TaskInstance taskInstance = taskInstanceRepository.Get(id);
newStatus = taskInstance.Status;
} while (currentStatus == newStatus && DateTime.UtcNow < waitTimeout && !process.HasExited);
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
string.Format("WaitForStatusChange [TID: {0}] Waited for {1}", id, DateTime.UtcNow - timeNow)));
return(newStatus);
}
public ProcessBreakEfficiencyOutput ProcessFile(Guid scenarioId, string folder)
{
var output = new ProcessBreakEfficiencyOutput();
var run = _dataSnapshot.Run.Value;
var efficiencySettings = _efficiencySettingsRepository.GetDefault();
if (!run.Manual || run.Manual && efficiencySettings.PersistEfficiency == PersistEfficiency.AllRun)
{
if (scenarioId == run.Scenarios.OrderBy(c => c.Id).First().Id)
{
try
{
output = ProcessFileInternal(scenarioId, folder);
}
catch (Exception exception)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error processing Break Efficiency", exception));
}
}
else
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, $"Ignoring break efficiency because it should only be processed once for the run"));
}
}
return(output);
}
private string CreateAutoBookRequest(IReadOnlyCollection <AutoBookInstanceConfiguration> autoBookInstanceConfigurations)
{
//AutoDistributed - autoBookRequest needs to be sent with the new API autodistributed model
// "Id": "imag-dev07-1",
var respondTo = "http://" + _configuration["Environment:Id"] + "-api.xggamplan.com/autobooks/";
AutoBookRequestModel autoBookRequest = new AutoBookRequestModel
{
respondTo = respondTo,
runId = RunId.ToString(),
scenarioId = ScenarioId.ToString(),
instanceType = autoBookInstanceConfigurations.First().InstanceType, //check
storageSizeGB = autoBookInstanceConfigurations.First().StorageSizeGb, //check
version = _autoBooks.Settings.ApplicationVersion,
binariesVersion = _autoBooks.Settings.BinariesVersion,
maxInstances = _autoBooks.Settings.MaxInstances,
mock = "false" //set to true in dev stage, not needed in prod
//Mock = false in prod, will actually call the nec. lambda:
// otherwise respond with : will have invoked:
// bash aws/request-invoke.sh http://imag-dev07-1-api.xggamplan.com/autobooks/ t3.medium 50 v4.4.0 xg-gameplan-autobook-binaries.2.40.012.120 3
};
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"AutoDistributed - AutoBookRequest object: " +
$"{autoBookRequest.respondTo}, {autoBookRequest.runId}, {autoBookRequest.scenarioId}, {autoBookRequest.instanceType}, " +
$"{autoBookRequest.storageSizeGB}, {autoBookRequest.version}, {autoBookRequest.binariesVersion}, " +
$"{autoBookRequest.maxInstances}, {autoBookRequest.mock}"));
return(_autoBooks.CreateAutoBookRequestRun(autoBookRequest));
}
/// <summary>
/// Deletes all logs of specific type that are older than date range
///
/// Log format: [Date].[Optional:Something].[LogType].txt
/// </summary>
/// <param name="retention"></param>
/// <param name="folder"></param>
/// <param name="logType"></param>
/// <returns></returns>
private List <SystemTaskResult> DeleteLogsByType(TimeSpan retention, string folder, string logType)
{
List <SystemTaskResult> results = new List <SystemTaskResult>();
try
{
DateTime minEventDate = DateTime.UtcNow.Subtract(retention);
const string eventLogDateFormat = "dd-MM-yyyy";
Dictionary <string, string> fileNamePatternByLogType = FileNamePatternByLogType;
if (Directory.Exists(folder))
{
foreach (string logFile in GetLogsByType(folder, logType, fileNamePatternByLogType[logType]))
{
DateTime eventsDate = DateHelper.GetDate(Path.GetFileNameWithoutExtension(logFile), eventLogDateFormat);
if (eventsDate < minEventDate)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, string.Format("Deleting {0} log {1}", logType, Path.GetFileName(logFile))));
File.Delete(logFile);
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, string.Format("Deleted {0} log {1}", logType, Path.GetFileName(logFile))));
}
}
}
}
catch (System.Exception exception)
{
results.Add(new SystemTaskResult(SystemTaskResult.ResultTypes.Error, this.Id, string.Format("Error deleting logs for type {0}: {1}", logType, exception.Message)));
}
return(results);
}
/// <summary>
/// Load breaks for break efficiency import record if not already in memory
/// </summary>
/// <param name="salesArea"></param>
/// <param name="breakEfficiencyImport"></param>
/// <param name="schedules"></param>
private void LoadBreaks(SalesArea salesArea, BreakEfficiencyImport breakEfficiencyImport, List <ScheduleIndexed <Break, int> > schedules, IScheduleRepository scheduleRepository)
{
DateTime startDateTime = GetStartDateTime(breakEfficiencyImport);
// Load Schedule document if necessary
var schedule = schedules.Where(s => s.SalesArea == salesArea.Name && s.Date.Date == startDateTime.Date).FirstOrDefault();
if (schedule == null) // Not in memory, load it
{
var scheduleObject = scheduleRepository.GetSchedule(salesArea.Name, startDateTime.Date);
if (scheduleObject != null)
{
if (scheduleObject.Breaks != null && scheduleObject.Breaks.Count > 0) // Schedule has breaks
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, string.Format("Break Efficiency processing. Schedule loaded for sales area {0} and date {1}", salesArea.Name, startDateTime.Date)));
scheduleObject.Breaks.ForEach(@break => @break.BreakEfficiencyList = null);
}
else // No breaks
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, string.Format("Break Efficiency processing. Schedule document has no breaks for sales area {0} and date {1}", salesArea.Name, startDateTime.Date)));
}
schedules.Add(new ScheduleIndexed <Break, int>(scheduleObject, delegate(Break currentBreak) { return(currentBreak); }, delegate(Break currentBreak) { return(currentBreak.CustomId); }));
}
else // No Schedule document, log warning
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, string.Format("Break Efficiency processing. Schedule document does not exist for sales area {0} and date {1}", salesArea.Name, startDateTime.Date)));
}
}
}
public override void Log(ExceptionLoggerContext context)
{
if (context.Exception == null)
{
return;
}
_logger.LogError(context.Exception, "application exception");
try
{
_auditEventRepository.Insert(
AuditEventFactory.CreateAuditEventForException(
tenantId: 0,
userId: 0,
message: GetAuditInfo(context),
exception: context.Exception));
}
catch (Exception ex)
{
_logger.LogError(ex, "auditevent insert exception"); // hope unreachable code
};
base.Log(context);
}
public async Task Execute(Guid runId)
{
var runCompleted = false;
try
{
runCompleted = await WaitForRunCompletedAsync(runId).ConfigureAwait(false);
}
catch (Exception ex)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0,
$"Completed run notification error (RunID={runId})", ex));
}
finally
{
if (runCompleted)
{
_runManager.CreateNotificationForCompletedRun(_run);
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Completed run notification has sent (RunID={runId})"));
}
else
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0,
$"Completed run notification warning, Run not found (RunID={runId})"));
}
}
}
/// <summary>
/// Creates set of spots
/// </summary>
/// <param name="spots">entities to be persisted</param>
/// <returns>List of created entities</returns>
private IEnumerable <Spot> CreateSpots(List <CreateSpot> spots)
{
var createdSpots = new List <Spot>();
bool isScheduleDataUploadStarted = false;
using (MachineLock.Create("xggameplan.checkisscheduledatauploadstarted", TimeSpan.FromSeconds(30)))
{
isScheduleDataUploadStarted = _repository.CountAll == 0 && _breakRepository.CountAll == 0;
}
foreach (var spot in spots)
{
var dto = _mapper.Map <Spot>(spot);
dto.Uid = Guid.NewGuid();
_repository.Add(dto);
createdSpots.Add(dto);
}
// Generate notification for schedule data upload started
if (isScheduleDataUploadStarted)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForScheduleDataUploadStarted(0, 0, null));
}
return(createdSpots);
}
public CampaignsReqmOutput ProcessFile(Guid scenarioId, string folder)
{
string pathToFile = FileHelpers.GetPathToFileIfExists(folder, FileName);
var result = new CampaignsReqmOutput();
if (String.IsNullOrEmpty(pathToFile))
{
_audit.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, $"File {pathToFile} was not found."));
return(result);
}
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processing output file {pathToFile}"));
var importSettings = CSVImportSettings.GetImportSettings(pathToFile, typeof(CampaignsReqmHeaderMap), typeof(CampaignsReqmIndexMap));
ICampaignsReqmImportRepository _fileReader = new CSVCampaignsReqmImportRepository(importSettings);
var data = _fileReader.GetAll().ToList();
result.Data = _mapper.Map <IEnumerable <CampaignsReqm> >(data);
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processed output file {pathToFile}"));
return(result);
}
/// <summary>
/// Executes systems task
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
public List<SystemTaskResult> ExecuteTask(string taskId)
{
var allSystemTaskResults = new List<SystemTaskResult>();
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, String.Format("Executing system task {0}", taskId)));
try
{
// Get task to run
var systemTask = GetSystemTasks().Where(mt => mt.Id == taskId).First();
var systemTaskResults = systemTask.Execute();
allSystemTaskResults.AddRange(systemTaskResults);
// Log results
foreach (var systemTaskResult in systemTaskResults)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, String.Format("System task result for {0}: {1}: {2}", taskId, systemTaskResult.ResultType, systemTaskResult.Message)));
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, String.Format("Executed system task {0}", taskId)));
}
catch (System.Exception exception)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, String.Format("Error executing system task {0}", taskId), exception));
throw;
}
return allSystemTaskResults;
}
/// <summary>
/// Deletes SpotPlacement docs for dead spots, not modified for more than N days
/// </summary>
/// <returns></returns>
private List <SystemTaskResult> DeleteSpotPlacements(TimeSpan spotPlacementRetention)
{
List <SystemTaskResult> results = new List <SystemTaskResult>();
if (spotPlacementRetention.Ticks != 0)
{
try
{
using (var scope = _repositoryFactory.BeginRepositoryScope())
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, string.Format("Deleting spot placements (Days Old={0})", spotPlacementRetention.TotalDays)));
var spotPlacementRepository = scope.CreateRepository <ISpotPlacementRepository>();
DateTime modifiedBefore = DateTime.UtcNow.Subtract(spotPlacementRetention);
spotPlacementRepository.DeleteBefore(modifiedBefore);
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, "Deleted spot placements"));
}
}
catch (System.Exception exception)
{
results.Add(new SystemTaskResult(SystemTaskResult.ResultTypes.Error, this.Id, string.Format("Error deleting spot placements: {0}", exception.Message)));
}
}
return(results);
}
private void PreGenerateReport(List <ScenarioCampaignLevelResultItem> data, Run run, Scenario scenario)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start scenario campaign level results report generation. ScenarioId: {scenario.Id} Count: {data.Count}"));
try
{
_campaignResultReportCreator.EnablePerformanceKPIColumns(_includeScenarioPerformanceMeasurementKpIs);
_campaignResultReportCreator.EnableCampaignLevel(!_saveData);
string fileName = ReportFileNameHelper.ScenarioCampaignResult(scenario, run.ExecuteStartedDateTime.Value);
using (var reportStream = _campaignResultReportCreator.GenerateReport(() =>
ScenarioCampaignResultReportHelper.MapToExtendedResults(data, scenario.CampaignPassPriorities, _mapper)))
{
_ = _cloudStorage.Upload(new S3UploadComment
{
BucketName = _awsSettings.S3Bucket,
DestinationFilePath = fileName,
FileStream = reportStream
});
}
}
catch (Exception e)
{
_auditEventRepository.Insert(
AuditEventFactory.CreateAuditEventForException(
0,
0,
$"Error while generating report for scenario campaign level results. ScenarioId: {scenario.Id}", e
)
);
throw;
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"End scenario campaign level results report generation. ScenarioId: {scenario.Id}"));
}
private List <SystemTestResult> ExecuteLoggingTest()
{
var results = new List <SystemTestResult>();
// Write audit event
AuditEvent auditEvent = AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, "Test message");
_auditEventRepository.Insert(auditEvent);
// Try reading audit event, may fail if there's an issue such as log file permissions
AuditEventFilter auditEventFilter = new AuditEventFilter()
{
MinTimeCreated = auditEvent.TimeCreated.AddSeconds(-1),
MaxTimeCreated = auditEvent.TimeCreated.AddSeconds(1)
};
var auditEvents = _auditEventRepository.Get(auditEventFilter);
AuditEvent auditEventLogged = auditEvents.Where(ae => ae.ID == auditEvent.ID).FirstOrDefault();
if (auditEventLogged == null) // Not logged
{
results.Add(new SystemTestResult(SystemTestResult.ResultTypes.Error, _category, "Event logging logging mechanism is not working because it was not possible to log a test event. There may be a problem with log folder permissions or disk space on the Gameplan API server.", ""));
}
else
{
results.Add(new SystemTestResult(SystemTestResult.ResultTypes.Information, _category, "Event logging mechanism is OK", ""));
}
return(results);
}
public IHttpActionResult Post([FromBody] List <CreateBreak> breaks)
{
if (breaks is null || !breaks.Any() || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Determine if they've just started uploading schedule data
bool isScheduleDataUploadStarted = false;
using (MachineLock.Create("xggameplan.checkisscheduledatauploadstarted", TimeSpan.FromSeconds(30)))
{
isScheduleDataUploadStarted = _breakRepository.CountAll == 0 && _spotRepository.CountAll == 0;
}
ValidateBreaks(breaks);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// zero out BroadcastDate's times
foreach (var b in breaks)
{
if (b.BroadcastDate.HasValue)
{
b.BroadcastDate = b.BroadcastDate.Value.Date;
}
}
// group by date and channels
breaks.GroupBy(s => new { s.ScheduledDate.Date, s.SalesArea }).ForEach(grp =>
{
using (MachineLock.Create(string.Format("xggameplan.scheduleday.{0}.{1}", grp.Key.SalesArea, grp.Key.Date), new TimeSpan(0, 10, 0)))
{
var schedule = _scheduleRepository.GetOrCreateSchedule(grp.Key.SalesArea, grp.Key.Date);
var breaklist = _mapper.Map <List <Break> >(grp.ToList());
LoadBreakProperties(ref breaklist);
_breakRepository.Add(breaklist);
schedule.Breaks = breaklist.ToList();
_scheduleRepository.Add(schedule);
_scheduleRepository.SaveChanges();
}
});
// Generate notification for schedule data upload started
if (isScheduleDataUploadStarted)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForScheduleDataUploadStarted(0, 0, null));
}
return(Ok());
}
/// <inheritdoc />
public List <KPI> CalculateKPIs(HashSet <string> kpiNamesToCalculate, Guid rawRunId, Guid rawScenarioId)
{
if (kpiNamesToCalculate is null)
{
throw new ArgumentNullException(nameof(kpiNamesToCalculate));
}
var runId = rawRunId.ToString();
var scenarioId = rawScenarioId.ToString();
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Executing KPI processing (RunID={runId}, ScenarioID={scenarioId}) "
+ $"KPIs to calculate: [{string.Join(", ", kpiNamesToCalculate)}]"));
var kpis = new List <KPI>();
foreach (var kpiName in kpiNamesToCalculate)
{
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Executing KPI calculation (KPI={kpiName}, RunID={runId}, ScenarioID={scenarioId})"));
try
{
var kpiResult = _kpiResolver.Resolve(kpiName);
if (kpiResult is null || !kpiResult.Any())
{
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"No result of {kpiName} KPI calculation (RunID={runId}, ScenarioID={scenarioId})"));
continue;
}
kpis.AddRange(kpiResult);
}
catch (DependencyResolutionException exception)
{
_audit?.Insert(AuditEventFactory.CreateAuditEventForException(0, 0,
$"Error resolving calculator for {kpiName} KPI for Scenario {scenarioId} of Run {runId}",
exception));
}
catch (Exception exception)
{
_audit?.Insert(AuditEventFactory.CreateAuditEventForException(0, 0,
$"Error calculating {kpiName} KPI for Scenario {scenarioId} of Run {runId}",
exception));
}
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Executed KPI calculation (KPI={kpiName}, RunID={runId}, ScenarioID={scenarioId})"));
}
_audit?.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Executed KPI processing (RunID={runId}, ScenarioID={scenarioId})"));
return(kpis);
}
public Failures ProcessFile(Guid scenarioId, string folder)
{
string pathToFile = FileHelpers.GetPathToFileIfExists(folder, FileName);
var failures = new Failures {
Id = scenarioId
};
if (string.IsNullOrEmpty(pathToFile))
{
_audit.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, $"File {pathToFile} was not found."));
return(failures);
}
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processing output file {pathToFile}"));
var importSettings = CSVImportSettings.GetImportSettings(pathToFile, typeof(FailureHeaderMap), typeof(FailureIndexMap));
var campaignsIndex = _dataSnapshot.AllCampaigns.Value.ToDictionary(c => (long)c.CustomId);
var salesAreaIndex = _dataSnapshot.AllSalesAreas.Value.ToDictionary(c => c.CustomId);
IFailureImportRepository failureRepository = new CSVFailureImportRepository(importSettings);
foreach (var summary in failureRepository.GetAll())
{
var failure = new Failure();
if (!campaignsIndex.TryGetValue(summary.Campaign, out var campaign))
{
failure.ExternalId = failure.CampaignName = "Unknown";
}
else
{
failure.ExternalId = campaign.ExternalId;
failure.CampaignName = campaign.Name;
}
failure.Type = summary.Type;
failure.Failures = summary.Failures;
failure.Campaign = summary.Campaign;
failure.SalesAreaName = !salesAreaIndex.TryGetValue(summary.SalesAreaNumberOfBooking, out var salesArea)
? "Unknown"
: salesArea.Name;
failures.Items.Add(failure);
}
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processed output file {pathToFile}"));
return(failures);
}
public List <SystemTaskResult> Execute()
{
IReadOnlyCollection <Run> GetRunsToDeleteForLastNDays(DateTime minCreatedDate)
{
using (var scope = _repositoryFactory.BeginRepositoryScope())
{
var runRepository = scope.CreateRepository <IRunRepository>();
return(runRepository.GetAll()
.Where(r => r.CreatedDateTime.Year > 2000 && r.CreatedDateTime < minCreatedDate)
.OrderBy(r => r.CreatedDateTime)
.ToList());
}
}
DateTime minCreated = DateTime.UtcNow.Subtract(_runRetention);
IReadOnlyCollection <Run> runs = GetRunsToDeleteForLastNDays(minCreated);
var results = new List <SystemTaskResult>();
foreach (var run in runs)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Deleting run {run.Id} ({run.Description})"
));
try
{
Run.ValidateForDelete(run);
_runManager.DeleteRun(run.Id);
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForRunDeleted(0, 0, run.Id, null));
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Deleted run {run.Id} ({run.Description})"
));
}
catch (Exception exception)
{
results.Add(
new SystemTaskResult(SystemTaskResult.ResultTypes.Error, Id,
$"Error deleting run {run.Id} ({run.Description}): {exception.Message}"
)
);
}
}
return(results);
}
public List <SystemTaskResult> Execute()
{
List <SystemTaskResult> results = new List <SystemTaskResult>();
try
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, "Deleting access tokens"));
var accessTokens = _accessTokensRepository.RemoveAllExpired();
_accessTokensRepository.SaveChanges();
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, $"Deleted {accessTokens.Count()} access tokens"));
}
catch (Exception exception)
{
results.Add(new SystemTaskResult(SystemTaskResult.ResultTypes.Error, Id, $"Error deleting access tokens: {exception.Message}"));
}
return(results);
}
private void PreGenerateReport(IReadOnlyCollection <ScenarioCampaignFailure> data, Run run, Scenario scenario)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start scenario campaign failures report generation. ScenarioId: {scenario.Id} Count: {data.Count}"));
try
{
var reportService = new ScenarioCampaignFailuresReportCreator();
var reportData = new ScenarioCampaignFailuresDataSnapshot();
var fileName = ScenarioCampaignFailuresReportCreator.GetFilePath(scenario.Name, run.ExecuteStartedDateTime.Value, scenario.Id);
var failureTypes = data.Select(c => c.FailureType)
.Distinct()
.ToList();
DayOfWeek tenantStartDayOfWeek;
using (var internalScope = _repositoryFactory.BeginRepositoryScope())
{
reportData.Campaigns = internalScope.CreateRepository <ICampaignRepository>().GetAllFlat();
reportData.FaultTypes = internalScope.CreateRepository <IFunctionalAreaRepository>().FindFaultTypes(failureTypes);
tenantStartDayOfWeek = internalScope.CreateRepository <ITenantSettingsRepository>().GetStartDayOfWeek();
}
using (var reportStream = reportService.GenerateReport(data, reportData, tenantStartDayOfWeek))
{
_ = _cloudStorage.Upload(new S3UploadComment
{
BucketName = _awsSettings.S3Bucket,
DestinationFilePath = fileName,
FileStream = reportStream
});
}
}
catch (Exception e)
{
_auditEventRepository.Insert(
AuditEventFactory.CreateAuditEventForException(
0,
0,
$"Error while generating report for scenario campaign failures. ScenarioId: {scenario.Id}", e
)
);
throw;
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"End scenario campaign failures report generation. ScenarioId: {scenario.Id}"));
}
public TaskResult Execute(TaskInstance taskInstance)
{
var taskResult = new TaskResult();
string autoBookId = String.Empty;
try
{
StartActiveNotifier(taskInstance.Id);
using var scope = _repositoryFactory.BeginRepositoryScope();
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.InProgress, null);
// Read parameters
autoBookId = taskInstance.Parameters["AutoBookId"].ToString();
var autoBookRepository = scope.CreateRepository <IAutoBookRepository>();
var autoBook = autoBookRepository.Get(autoBookId);
if (autoBook == null)
{
throw new Exception($"AutoBook {autoBookId} does not exist");
}
else
{
_ = _runManager.NextScheduledScenarioStartRun(autoBook);
}
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedSuccess, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedSuccess;
}
catch (Exception exception)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, String.Format("Error executing task for starting next scenario (TaskInstanceID={0}, AutoBookID={1})", taskInstance.Id, autoBookId), exception));
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedError, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedError;
taskResult.Exception = exception;
}
finally
{
StopActiveNotifier();
}
return(taskResult);
}
public void Handle(Run run, Guid scenarioId)
{
bool cleanup = true;
try
{
// Check for scenario result, shouldn't exist
ScenarioResult scenarioResult = _scenarioResultRepository.Find(scenarioId);
if (scenarioResult is null)
{
scenarioResult = new ScenarioResult
{
Id = scenarioId,
TimeCompleted = DateTime.UtcNow
};
}
// Download output files from AWS
DownloadOutputFiles(run.Id, scenarioId, GetScenarioLocalFolder(scenarioId));
// Process output files
ProcessOutputFiles(run.Id, scenarioId, scenarioResult);
cleanup = false;
}
catch (Exception exception)
{
//adding the audit event to clear the warning of 'exception declared but never used' and preserves stack trace with the 'throw'
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, String.Format("Error handling output file for scenario ID: {0}", scenarioId), exception));
throw;
}
finally
{
// Delete all output data if it failed
if (cleanup)
{
try
{
DeleteOutputData(scenarioId);
}
catch { };
}
}
}
public TaskResult Execute(TaskInstance taskInstance)
{
var taskResult = new TaskResult();
try
{
StartActiveNotifier(taskInstance.Id);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.InProgress, null);
using (var scope = _repositoryFactory.BeginRepositoryScope())
{
// Test repository, confirms that we're able to pick up config settings
var campaignRepository = scope.CreateRepository <ICampaignRepository>();
var campaigns = campaignRepository.GetAll();
}
// Do work
int seconds = Convert.ToInt32(taskInstance.Parameters["Seconds"].ToString());
DoWork(seconds);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedSuccess, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedSuccess;
}
catch (Exception exception)
{
_auditEventRepository.Insert(
AuditEventFactory.CreateAuditEventForException(0, 0, $"Error executing task for test (TaskInstanceID={taskInstance.Id.ToString()})", exception)
);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedError, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedError;
taskResult.Exception = exception;
}
finally
{
StopActiveNotifier();
}
return(taskResult);
}
/// <summary>
/// Gets collection of valid autopilot rules for all needed rule categories
/// </summary>
/// <param name="flexibilityLevelId"></param>
/// <returns>ReadOnly collection of autopilot rules</returns>
private IReadOnlyDictionary <int, List <AutopilotRule> > GetAutopilotRules(int flexibilityLevelId)
{
var autopilotRules = _autopilotRuleRepository.GetByFlexibilityLevelId(flexibilityLevelId).ToList();
string exceptionMessage = null;
if (!autopilotRules.Any())
{
exceptionMessage = $"Autopilot rules missing for '{flexibilityLevelId}' flexibility level";
}
var rulesByType = autopilotRules
.Where(ar => ar.Enabled || ar.RuleTypeId == (int)RuleCategory.SlottingLimits)
.GroupBy(ar => ar.RuleTypeId)
.ToDictionary(g => g.Key, g => g.ToList());
if (!rulesByType.ContainsKey((int)RuleCategory.SlottingLimits) ||
rulesByType[(int)RuleCategory.SlottingLimits].Count != 1)
{
exceptionMessage = "Missing default SlottingLimits Autopilot rule";
}
if (exceptionMessage != null)
{
var exception = new Exception("Error while generating autopilot scenarios");
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, exceptionMessage, exception));
throw exception;
}
// default values for all rule categories
foreach (var ruleCategory in Enum.GetValues(typeof(RuleCategory)).Cast <RuleCategory>())
{
if (!rulesByType.ContainsKey((int)ruleCategory))
{
rulesByType[(int)ruleCategory] = new List <AutopilotRule>();
}
}
return(rulesByType);
}
