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);
}
/// <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;
}
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 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);
}
/// <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);
}
/// <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
{
}
}
}
}
/// <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);
}
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}"));
}
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));
}
}
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>());
}
}
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}"));
}
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>
/// 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)));
}
}
}
/// <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 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));
}
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})"));
}
}
}
/// <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}"));
}
/// <summary>
/// Processes the concrete AutoBook output data type.
/// </summary>
/// <typeparam name="TData">The type of the data.</typeparam>
/// <param name="scope">Current KPI calculation scope.</param>
/// <param name="featureManager">The feature manager.</param>
/// <param name="audit">The audit.</param>
/// <param name="folder">The folder.</param>
/// <returns></returns>
private static void ProcessData <TData>(IKPICalculationScope scope, IFeatureManager featureManager,
IAuditEventRepository audit, string folder) where TData : class
{
var context = scope.Resolve <IKPICalculationContext>();
var fileProcessor = scope.Resolve <IOutputFileProcessor <TData> >();
if (!featureManager.IsServiceEnabled(fileProcessor.GetType()))
{
audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Skipping disabled file processor. ScenarioId: {context.ScenarioId}, FileName: {fileProcessor.FileName}"));
return;
}
var data = fileProcessor.ProcessFile(context.ScenarioId, folder);
context.SetContextData(data);
if (scope.TryResolve <IOutputDataHandler <TData> >(out var handler))
{
handler.ProcessData(data, context.Snapshot.Run.Value, context.Snapshot.Scenario.Value);
}
}
public void ProcessData(ScenarioCampaignResult data, Run run, Scenario scenario)
{
var scenarioId = data.Id;
if (!_saveData)
{
const string campaignLevelReportFacility = "XGSCRC";
var facility = _facilityRepository.GetByCode(campaignLevelReportFacility);
if (facility is null || facility.Enabled == false)
{
PreGenerateReport(data.Items, run, scenario);
}
return;
}
try
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Start insert of scenario campaigns. ScenarioId: {scenarioId} Count: {data.Items.Count}"));
using (var innerScope = _repositoryFactory.BeginRepositoryScope())
{
var scenarioCampaignResultRepository = innerScope.CreateRepository <IScenarioCampaignResultRepository>();
scenarioCampaignResultRepository.AddOrUpdate(data);
scenarioCampaignResultRepository.SaveChanges();
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"End insert of scenario campaigns. ScenarioId: {scenarioId} Count: {data.Items.Count}"));
}
catch (Exception e)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error while processing scenario campaign results. ScenarioId: {scenarioId}", e));
throw;
}
PreGenerateReport(data.Items, run, scenario);
}
/// <summary>
/// It is called dynamically.
/// </summary>
public async Task Execute(CancellationToken cancellationToken, AutoBook autoBook)
{
try
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Deleting AutoBook (AutoBookID={autoBook.Id})"));
var autobookDeleted = false;
try
{
_autoBooks.Delete(autoBook);
autobookDeleted = true;
}
catch (Exception ex)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0,
$"Error deleting AutoBook (AutoBookID={autoBook.Id})", ex));
}
if (autobookDeleted)
{
_auditEventRepository.Insert(
AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, "Deleted AutoBook"));
}
}
finally
{
foreach (var dbContext in _tenantDbContexts)
{
try
{
await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
}
catch //ignore exception
{
}
}
}
}
public void ProcessData(Failures data, Run run, Scenario scenario)
{
try
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Failures has been generated. ScenarioId: {data.Id}, Count: {data.Items.Count}"));
using (var innerScope = _repositoryFactory.BeginRepositoryScope())
{
var failuresRepository = innerScope.CreateRepository <IFailuresRepository>();
failuresRepository.Add(data);
failuresRepository.SaveChanges();
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Failures has been saved to the db. ScenarioId: {data.Id}"));
}
catch (Exception e)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, "Error while processing failures", e));
throw;
}
}
public BaseRatingsOutput ProcessFile(Guid scenarioId, string folder)
{
string pathToFile = FileHelpers.GetPathToFileIfExists(folder, FileName);
var result = new BaseRatingsOutput();
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}"));
try
{
var importSettings = CSVImportSettings.GetImportSettings(pathToFile, typeof(BaseRatingsHeaderMap), typeof(BaseRatingsIndexMap));
var baseRatingsImportRepository = new CSVBaseRatingsImportRepository(importSettings);
var data = baseRatingsImportRepository.GetAll();
result.Data = _mapper.Map <IEnumerable <BaseRatings> >(data);
_audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0,
0, $"Processed output file {pathToFile}"));
return(result);
}
catch (Exception exception)
{
_audit.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, "Error processing base ratings file", exception));
return(result);
}
}
public TaskResult Execute(TaskInstance taskInstance)
{
var taskResult = new TaskResult();
Guid runId = Guid.Empty;
try
{
StartActiveNotifier(taskInstance.Id);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.InProgress, null);
// Read parameters
runId = new Guid(taskInstance.Parameters["RunId"].ToString());
var runInstances = _runManager.AllScenariosStartRun(runId);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedSuccess, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedSuccess;
}
catch (Exception exception)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, $"{exception.StackTrace}"));///testing
_auditEventRepository.Insert(
AuditEventFactory.CreateAuditEventForException(0, 0, $"Error executing task for start run (TaskInstanceID={taskInstance.Id.ToString()}, RunID={runId.ToString()})",
exception)
);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedError, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedError;
taskResult.Exception = exception;
}
finally
{
StopActiveNotifier();
}
return(taskResult);
}
private List <ScenarioCampaignMetricItem> GenerateCampaignKPIs(Guid runId, Guid scenarioId, IEnumerable <Recommendation> scenarioRecommendations)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, String.Format("Executing Campaign KPI processing (RunID={0}, ScenarioID={1})", runId, scenarioId)));
var kpis = new List <ScenarioCampaignMetricItem>();
var calculator = new ScenarioCampaignKPIsCalculator();
var recommendations = scenarioRecommendations
.GroupBy(x => x.ExternalCampaignNumber)
.ToDictionary(x => x.Key, x => x.ToList());
foreach (var campaign in _campaignRepository.GetAllFlat())
{
var nominalPrice = _spotRepository.GetNominalPriceByCampaign(campaign.ExternalId);
var campaignRecommendations = recommendations.ContainsKey(campaign.ExternalId)
? recommendations[campaign.ExternalId]
: Enumerable.Empty <Recommendation>();
kpis.Add(calculator.CalculateCampaignKPIs(campaign, campaignRecommendations, nominalPrice));
}
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, String.Format("Executed Campaign KPI processing (RunID={0}, ScenarioID={1})", runId, scenarioId)));
return(kpis);
}
/// <summary>
/// Requests an autobookRequest model
/// </summary>
/// <param name="autoBookRequest"></param>
public string AutoBookRequestRun(AutoBookRequestModel autoBookRequest)
{
string url = $"{_apibaseUrl}/run";
byte[] contentBody = SerializeContentBody(autoBookRequest);
int len = 0;
len = contentBody.Length;
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Creating WebRequest for {nameof(AutoBookRequestRun)}, content body len after serialization: {len.ToString()}, url: {url}, autoBookRequest.mock: {autoBookRequest.mock}"));
try
{
var webRequest = CreateHttpWebRequest(url, "POST", GetAuthHeaders(AuthType, _accessToken), ContentTypeJSON, contentBody);
using var webResponse = (HttpWebResponse)webRequest.GetResponse();
ThrowExceptionIfNotSuccess(webResponse, new List <HttpStatusCode>()
{
HttpStatusCode.OK
});
using var reader = new StreamReader(webResponse.GetResponseStream());
{
var data = reader.ReadToEnd();
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Created WebRequest for {nameof(AutoBookRequestRun)}, url: {url}, data: {data})"));
return(data);
}
}
catch (WebException ex)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0,
$"Error thrown Creating WebRequest for {nameof(AutoBookRequestRun)}, url: {url}, ex: {ex})"));
throw ex;
}
}