/// <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> /// 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 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); }
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 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> /// 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); }
/// <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 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); }
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})")); } } }
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 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 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 IHttpActionResult Post([FromBody] CreateAuditEventModel command) { if (command == null || !ModelState.IsValid) { return(this.Error().InvalidParameters("Audit event body parameters missing")); } List <AuditEventValueType> valueTypes = new AuditEventValueTypeRepository().GetAll(); var auditEvent = new AuditEvent() { ID = Guid.NewGuid().ToString(), TimeCreated = (command.TimeCreated == null ? DateTime.UtcNow : (DateTime)command.TimeCreated), EventTypeID = command.EventTypeID, TenantID = 0, UserID = 0, }; command.Values.ForEach(item => auditEvent.Values.Add(new AuditEventValue() { TypeID = item.TypeID, Value = AuditEventValue.ConvertValue(item.TypeID, item.Value, valueTypes.Find(vt => vt.ID == item.TypeID)) })); _auditEventRepository.Insert(auditEvent); return(Ok()); }
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 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); }
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); }
/// <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); }
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 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); }
/// <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); } }
/// <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; } }
public ScenarioCampaignResult ProcessFile(Guid scenarioId, string folder) { string pathToFile = FileHelpers.GetPathToFileIfExists(folder, FileName); var result = new ScenarioCampaignResult { 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(ScenarioCampaignResultHeaderMap), typeof(ScenarioCampaignResultIndexMap)); IScenarioCampaignResultsImportRepository repository = new CSVScenarioCampaignResultsImportRepository(importSettings); var data = repository.GetAll(); var salesAreaIndex = _dataSnapshot.AllSalesAreas.Value.ToDictionary(c => c.CustomId); foreach (var importItem in data) { salesAreaIndex.TryGetValue(importItem.SalesAreaNo, out var salesArea); result.Items.Add(MapImportItem(importItem, salesArea)); } _audit.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, $"Processed output file {pathToFile}")); return(result); }
//public static void TestSimpleEmail(IAuditEventRepository auditEventRepository) //{ // Email email = new Email() // { // Subject = "Test email", // Body = "<html><head></head><body>Test email from xG Gameplan</body></html>", // Sender = "*****@*****.**", // SenderDisplay = "NextGen", // RecipientList = { "*****@*****.**" } // }; // AuditEvent auditEvent = AuditEventFactory.CreateAuditEventForSimpleEmail(0, 0, email); // auditEventRepository.Insert(auditEvent); //} public static void TestException(IAuditEventRepository auditEventRepository) { try { // Generate exception int divisor = 0; int result = 10 / divisor; } catch (System.Exception exception) { // Create new exception with other exception as inner exception System.Exception exception2 = new System.IO.FileNotFoundException("Test exception", exception); exception2.Data.Add("Data1", 10); exception2.Data.Add("Data2", DateTime.UtcNow); exception2.Data.Add("Data3", "ABC"); AuditEvent auditEvent2 = AuditEventFactory.CreateAuditEventForException(0, 0, "Test", exception2); auditEventRepository.Insert(auditEvent2); } }
/// <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 SystemLogicalDateService(ITenantSettingsRepository tenantSettingsRepository, IFeatureManager featureManager, IClock clock, IAuditEventRepository auditEventRepository) { _clock = clock; var tenantSettings = tenantSettingsRepository.Get(); var useSystemLogicalDate = featureManager.IsEnabled(nameof(ProductFeature.UseSystemLogicalDate)); if (useSystemLogicalDate) { var isDateValid = DateTime.TryParseExact(tenantSettings.SystemLogicalDate, SystemLogicalDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var systemLogicalDate); if (isDateValid) { _isSystemLogicalDateUsed = true; _systemLogicalDate = systemLogicalDate.Add(_clock.GetCurrentInstant().ToDateTimeUtc().TimeOfDay); } else { auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, $"System Logical Date is not it valid format. " + $"Date set: '{tenantSettings.SystemLogicalDate}', but valid format is: '{SystemLogicalDateFormat}'. Using current Date instead.")); } } }