public override void Handle(ISalesAreaUpdated command)
{
var salesArea = _salesAreaRepository.FindByCustomId(command.CustomId);
if (salesArea is null)
{
throw new DataSyncException(DataSyncErrorCode.SalesAreaNotFound, "no sales area found");
}
_demographicRepository.ValidateDemographics(new List <string> {
command.BaseDemographic1, command.BaseDemographic2
});
ValidateSalesAreaDemographics(command);
var newSalesArea = _mapper.Map <SalesArea>(command);
UpdateSalesAreaModel(salesArea, newSalesArea);
_salesAreaRepository.Update(salesArea);
var demographics = _mapper.Map <IEnumerable <SalesAreaDemographic> >(command.Demographics).ToList();
demographics.ForEach(x => x.SalesArea = salesArea.Name);
UpdateSalesAreaDemographics(salesArea, demographics);
_salesAreaRepository.SaveChanges();
}
public void Handle(IBulkTotalRatingCreated command)
{
var totalRatings = _mapper.Map <List <TotalRating> >(command.Data);
_demographicRepository.ValidateDemographics(totalRatings.Select(c => c.Demograph).ToList());
_salesAreaRepository.ValidateSalesArea(totalRatings.Select(c => c.SalesArea).ToList());
_totalRatingRepository.AddRange(totalRatings);
_totalRatingRepository.SaveChanges();
}
private void ValidateSalesAreaDemographics(IBulkSalesAreaCreatedOrUpdated command)
{
var baseDemographicExternalRefs = command.Data
.Select(x => new[] { x.BaseDemographic1, x.BaseDemographic2 })
.SelectMany(x => x).Distinct().ToList();
_demographicRepository.ValidateDemographics(baseDemographicExternalRefs);
foreach (var salesArea in command.Data)
{
var commandDemographics = salesArea.Demographics;
var externalRefs = commandDemographics.Select(x => x.ExternalRef).Distinct().ToArray();
if (externalRefs.Length != commandDemographics.Count)
{
throw new DataSyncException(DataSyncErrorCode.DuplicateExternalReference, "Duplicated demographic externalRefs");
}
_demographicRepository.ValidateDemographics(externalRefs);
}
}
private void Validate(params string[] demographic)
{
if (_demographicRepository.ValidateDemographics(demographic.ToList(), out List <string> invaliddemographic))
{
return;
}
var msg = string.Concat("Invalid demographic number: ", string.Join(",", invaliddemographic));
throw new InvalidDataException(msg);
}
public void Handle(IBulkStandardDayPartGroupCreated command)
{
var daypartGroups = _mapper.Map <List <StandardDayPartGroup> >(command.Data);
_standardDayPartRepository.ValidateDayParts(command.Data.Where(c => c.Splits != null && c.Splits.Any()).SelectMany(c => c.Splits.Select(d => d.DayPartId)).ToList());
_salesAreaRepository.ValidateSalesArea(daypartGroups.Select(c => c.SalesArea).ToList());
_demographicRepository.ValidateDemographics(daypartGroups.Select(c => c.Demographic).ToList());
_standardDayPartGroupRepository.AddRange(daypartGroups);
_standardDayPartGroupRepository.SaveChanges();
}
public override void Handle(IBulkUniverseCreated command)
{
_salesAreaRepository.ValidateSalesArea(command.Data.Select(x => x.SalesArea).ToList());
_demographicRepository.ValidateDemographics(command.Data.Select(x => x.Demographic).ToList());
var universes = _universeRepository.Search(command.Data.Select(x => x.Demographic).Distinct().ToList(),
command.Data.Select(x => x.SalesArea).Distinct().ToList(),
DateTime.MinValue, DateTime.MinValue).ToList();
SaveUniverse(command.Data.ToList(), universes);
_universeRepository.SaveChanges();
}
public void ValidateUniverse(List <CreateUniverse> commands)
{
commands.ForEach(command => Validate(command.SalesArea, command.Demographic, command.StartDate,
command.EndDate, command.UniverseValue));
_salesAreaRepository.ValidateSaleArea(commands.Select(_ => _.SalesArea).ToList());
if (!_demographicRepository.ValidateDemographics(commands.Select(u => u.Demographic).ToList(),
out List <string> invalidDemographics))
{
var msg = string.Concat("Invalid Demographics: ",
invalidDemographics != null ? string.Join(",", invalidDemographics) : string.Empty);
throw new InvalidDataException(msg);
}
}
/// <summary>Validates the campaigns to create have valid data.</summary>
/// <param name="campaigns">The campaigns to validate.</param>
/// <param name="validateCampaignPassPriority">If set to <c>true</c>
/// validate campaign pass priority.</param>
private void ValidateCampaigns(List <CreateCampaign> campaigns, bool validateCampaignPassPriority = true)
{
var validateDeliveryType = _featureManager.IsEnabled(nameof(ProductFeature.CampaignDeliveryType));
// Required and Regex Validation
campaigns.ForEach(c =>
{
if (c?.ProgrammesList != null)
{
_mapper.Map <List <CampaignProgramme> >(c.ProgrammesList);
}
List <CampaignProgramme> campaignProgrammesPlacebo = null;
Validation(c.ExternalId, c.Name, c.DemoGraphic, c.StartDateTime, c.EndDateTime, c.Product, c.DeliveryType,
c.TargetRatings, c.SalesAreaCampaignTarget, c.TimeRestrictions, c.ProgrammeRestrictions, campaignProgrammesPlacebo, c.CampaignGroup,
c.IncludeRightSizer, c.IncludeOptimisation, c.CampaignPassPriority, c.CampaignSpotMaxRatings, validateCampaignPassPriority,
validateDeliveryType);
});
if (!_demographicRepository.ValidateDemographics(
campaigns.Select(c => c.DemoGraphic).ToList(),
out List <string> invalidDemographic)
)
{
var msg = String.Concat(
"Invalid Demographic in Campaigns: ",
invalidDemographic is null ?
String.Empty :
String.Join(",", invalidDemographic));
throw new InvalidDataException(msg);
}
_productRepository.ValidateProductExternalIds(campaigns.Select(c => c.Product).ToList());
var salesAreaCampaignTargets = campaigns
.Where(p => p.SalesAreaCampaignTarget != null && p.SalesAreaCampaignTarget.Count > 0)
.SelectMany(b => b.SalesAreaCampaignTarget)
.ToList();
if (salesAreaCampaignTargets.Any())
{
var salesAreas = salesAreaCampaignTargets
.Where(s => s.SalesAreaGroup != null && s.SalesAreaGroup.SalesAreas != null &&
s.SalesAreaGroup.SalesAreas.Any())
.SelectMany(s => s.SalesAreaGroup.SalesAreas)
.ToList();
_salesAreaRepository.ValidateSaleArea(salesAreas);
}
var programmeRestrictions = campaigns
.Where(c => c.ProgrammeRestrictions != null && c.ProgrammeRestrictions.Count > 0)
.SelectMany(c => c.ProgrammeRestrictions)
.ToList();
if (programmeRestrictions.Any())
{
var saleAreas = programmeRestrictions.Where(p => p.SalesAreas != null && p.SalesAreas.Any())
.SelectMany(p => p.SalesAreas)
.ToList();
if (saleAreas.Any())
{
_salesAreaRepository.ValidateSaleArea(saleAreas);
}
var categoryNames = programmeRestrictions
.Where(p => p.IsCategoryOrProgramme.Equals(CategoryOrProgramme.C.ToString(), StringComparison.OrdinalIgnoreCase))
?.SelectMany(p => p.CategoryOrProgramme)
?.ToList();
if (categoryNames.Any() && !_programmeCategoryRepository.IsValid(categoryNames, out List <string> invalidCategory))
{
var msg = String.Concat(
"Invalid Category Name: ",
invalidCategory is null ?
String.Empty
: String.Join(",", invalidCategory)
);
throw new InvalidDataException(msg);
}
}
var timeRestrictions = campaigns
.Where(c => c.TimeRestrictions != null && c.TimeRestrictions.Count > 0)
.SelectMany(c => c.TimeRestrictions)
.ToList();
if (timeRestrictions.Any())
{
var saleAreas = timeRestrictions.Where(p => p.SalesAreas != null && p.SalesAreas.Any())
.SelectMany(p => p.SalesAreas)
.ToList();
if (saleAreas.Any())
{
_salesAreaRepository.ValidateSaleArea(saleAreas);
}
}
}
/// <summary>
/// Validates for saving run
/// </summary>
/// <param name="run"></param>
/// <param name="allScenarios"></param>
/// <param name="allPassesByScenario"></param>
public void ValidateForSave(
Run run,
List <Scenario> allScenarios,
List <List <Pass> > allPassesByScenario,
List <SalesArea> allSalesAreas)
{
// Basic validation
Run.ValidateForSave(run);
ValidateAnalysisGroupTargets(run.AnalysisGroupTargets);
if (run.RunTypeId != 0)
{
if (_featureManager.IsEnabled(nameof(ProductFeature.RunType)))
{
var runType = _runTypeRepository.Get(run.RunTypeId);
if (runType is null || runType.Hidden)
{
throw new Exception("Run type not found");
}
}
else
{
run.RunTypeId = 0;
}
}
if (run.Scenarios.Count > 1 && !_brsConfigurationTemplateRepository.Exists(run.BRSConfigurationTemplateId))
{
throw new Exception("BRS template not found");
}
RunsValidations.ValidateScenarios(allScenarios);
// validate all passes
for (int index = 0; index < allPassesByScenario.Count; index++)
{
allPassesByScenario[index]?.ForEach(pass =>
{
Pass.ValidateForSave(pass);
Pass.ValidateScenarioNamingUniqueness(pass, new List <Scenario>()
{
allScenarios[index]
});
});
}
// Check that run doesn't contain default scenario, can only contain
// a copy
TenantSettings tenantSettings = _tenantSettingsRepository.Get();
if (tenantSettings.DefaultScenarioId != Guid.Empty && run.Scenarios.Where(s => s.Id == tenantSettings.DefaultScenarioId).Any())
{
throw new Exception("Run cannot contain the default scenario. It must contain a copy");
}
if (string.IsNullOrWhiteSpace(tenantSettings.PeakStartTime) ||
string.IsNullOrWhiteSpace(tenantSettings.PeakEndTime))
{
throw new ArgumentNullException(nameof(tenantSettings), "Peak daypart is not set. Please check the tenant settings.");
}
if (string.IsNullOrWhiteSpace(tenantSettings.MidnightStartTime) ||
string.IsNullOrWhiteSpace(tenantSettings.MidnightEndTime))
{
throw new ArgumentNullException(nameof(tenantSettings), "Midnight daypart is not set. Please check the tenant settings.");
}
// Check sales areas priorities
if (run.SalesAreaPriorities != null && run.SalesAreaPriorities.Any())
{
var existingSalesAreaNames = new HashSet <string>(allSalesAreas.Select(s => s.Name));
var runSalesAreaNames = new HashSet <string>();
var unknownSalesAreas = new List <string>();
var duplicatedSalesAreas = new List <string>();
bool areAllExcluded = true;
foreach (var priority in run.SalesAreaPriorities)
{
if (!existingSalesAreaNames.Contains(priority.SalesArea))
{
unknownSalesAreas.Add(priority.SalesArea);
}
if (runSalesAreaNames.Contains(priority.SalesArea))
{
duplicatedSalesAreas.Add(priority.SalesArea);
}
if (priority.Priority != SalesAreaPriorityType.Exclude)
{
areAllExcluded = false;
}
runSalesAreaNames.Add(priority.SalesArea);
}
if (unknownSalesAreas.Any())
{
throw new Exception(string.Format("Sales area {0} is not valid", unknownSalesAreas[0]));
}
if (areAllExcluded)
{
throw new Exception("All Sales area priorities are set to Exclude");
}
if (duplicatedSalesAreas.Any())
{
throw new Exception(string.Format("Run Sales area priorities contains duplicate {0}", duplicatedSalesAreas[0]));
}
}
// Get runs & scenarios
var runsWithScenarioId = _runRepository.GetRunsWithScenarioId();
// Get scenarios & passes
var scenariosWithPassId = _scenarioRepository.GetScenariosWithPassId();
if (run.Scenarios != null && run.Scenarios.Any())
{
var runSalesAreas = run.SalesAreaPriorities?.Where(sa => sa.Priority != SalesAreaPriorityType.Exclude).Select(x => x.SalesArea).ToList();
var salesAreasToValidate = new List <string>();
for (int scenarioIndex = 0; scenarioIndex < run.Scenarios.Count; scenarioIndex++)
{
var scenario = run.Scenarios[scenarioIndex];
var passes = allPassesByScenario[scenarioIndex];
// Check that scenario isn't linked to another run
var otherRunIdsForScenarioId = runsWithScenarioId.Where(rws => rws.ScenarioId == scenario.Id && rws.RunId != run.Id).Select(rws => rws.RunId).ToList();
if (otherRunIdsForScenarioId.Any())
{
var otherRun = _runRepository.Find(otherRunIdsForScenarioId.First());
throw new Exception(string.Format("Scenario is already linked to Run {0}", otherRun.Description));
}
if (passes != null && passes.Any())
{
foreach (var pass in passes)
{
// Check that passes aren't linked to other scenarios
var otherScenarioIdsForPassId = scenariosWithPassId.Where(swp => swp.PassId == pass.Id && swp.ScenarioId != scenario.Id).Select(swp => swp.ScenarioId).ToList();
if (otherScenarioIdsForPassId.Any())
{
var otherScenario = _scenarioRepository.Get(otherScenarioIdsForPassId.First());
throw new Exception(string.Format("Pass is already linked to Scenario {0}", otherScenario.Name));
}
// Check that passes aren't linked to other
// scenarios in this run
if (pass.Id > 0)
{
if (passes.Where(p => p.Id == pass.Id).ToList().Count > 1)
{
throw new Exception("Scenario cannot contain multiple instances of the same PassID");
}
for (int scenarioIndex2 = 0; scenarioIndex2 < run.Scenarios.Count; scenarioIndex2++)
{
if (scenarioIndex != scenarioIndex2)
{
if (allPassesByScenario[scenarioIndex2].Select(p => p.Id).Contains(pass.Id))
{
throw new Exception("Pass is already linked to another Scenario for this run");
}
}
}
}
var errorMsg = RunsValidations.ValidatePassSalesAreaPriorities(run, pass, tenantSettings, runSalesAreas);
if (!string.IsNullOrWhiteSpace(errorMsg))
{
throw new Exception(errorMsg);
}
}
}
// Check break exclusions
if (passes != null && passes.Any() && passes.Any(p => p.BreakExclusions != null && p.BreakExclusions.Any()))
{
var breakExclusions = passes
.Where(p => p?.BreakExclusions != null && p.BreakExclusions.Any())
.SelectMany(p => p.BreakExclusions)
.Select(b => b.SalesArea);
salesAreasToValidate.AddRange(breakExclusions);
}
}
if (salesAreasToValidate.Any())
{
_salesAreaRepository.ValidateSaleArea(salesAreasToValidate);
}
}
// Check campaigns
if (run.Campaigns != null && run.Campaigns.Count > 0)
{
var existingCampaigns = new HashSet <string>(_campaignRepository.GetAllFlat().Select(x => x.ExternalId));
var unknownCampaigns = run.Campaigns.Select(ca => ca.ExternalId)
.Where(externalId => !existingCampaigns.Contains(externalId)).ToList();
if (unknownCampaigns.Any())
{
throw new Exception(string.Format("Campaign {0} is not valid", unknownCampaigns[0]));
}
}
// Validation for slotting control by Demograph
if (run.Scenarios != null && run.Scenarios.Any())
{
var demographicsToValidate = new List <string>();
for (int scenarioIndex = 0; scenarioIndex < run.Scenarios.Count; scenarioIndex++)
{
var passes = allPassesByScenario[scenarioIndex];
if (passes != null && passes.Any() && passes.Any(p => p.SlottingLimits != null && p.SlottingLimits.Any()))
{
var slottingLimits = passes
.Where(p => p?.SlottingLimits != null && p.SlottingLimits.Any())
.SelectMany(p => p.SlottingLimits)
.Select(b => b.Demographs);
demographicsToValidate.AddRange(slottingLimits);
}
}
demographicsToValidate = demographicsToValidate.Where(x => x != null).Distinct().ToList();
if (demographicsToValidate.Any() && !_demographicRepository.ValidateDemographics(demographicsToValidate,
out List <string> invalidDemographics))
{
var msg = string.Concat(
"Invalid Demographic in slotting control by Demograph: ",
invalidDemographics != null
? string.Join(",", invalidDemographics)
: string.Empty);
throw new InvalidDataException(msg);
}
}
ValidateDeliveryCappingGroupIds(_mapper.Map <IEnumerable <CampaignRunProcessesSettingsModel> >(run.CampaignsProcessesSettings));
}
