public AnalysisGroupKPIsCalculator(IKPICalculationContext kpiCalculationContext,
IAnalysisGroupRepository analysisGroupRepository,
IAnalysisGroupCampaignQuery analysisGroupCampaignQuery,
IAuditEventRepository auditEventRepository)
{
_kpiCalculationContext = kpiCalculationContext;
_analysisGroupRepository = analysisGroupRepository;
_analysisGroupCampaignQuery = analysisGroupCampaignQuery;
_auditEventRepository = auditEventRepository;
}
public RunTypesController(
IRunTypeRepository runTypeRepository,
IFeatureManager featureManager,
IMapper mapper,
IAnalysisGroupRepository analysisGroupRepository,
ILandmarkRunQueueRepository landmarkRunQueueRepository)
{
_mapper = mapper;
_analysisGroupRepository = analysisGroupRepository;
_runTypeRepository = runTypeRepository;
_featureManager = featureManager;
_landmarkRunQueueRepository = landmarkRunQueueRepository;
}
/// <summary>
/// Validates <see cref="CreateAnalysisGroupModel.Id"/> collection
/// </summary>
/// <param name="repository"></param>
/// <param name="ids"></param>
/// <param name="invalidList"></param>
/// <exception cref="System.ArgumentNullException">Thrown when repository is null</exception>
/// <returns></returns>
public static bool IsValid(this IAnalysisGroupRepository repository, ICollection <int> ids, out ICollection <int> invalidList)
{
invalidList = null;
if (ids is null || ids.Count == 0 || ids.Any(x => x <= 0))
{
return(false);
}
var existingEntities = (repository ?? throw new ArgumentNullException(nameof(repository))).GetByIds(ids, true);
invalidList = ids.Except(existingEntities.Select(s => s.Id)).ToList();
return(!invalidList.Any());
}
/// <summary>
/// Returns RunModel for run
/// </summary>
/// <param name="run"></param>
/// <param name="scenarioRepository"></param>
/// <param name="passRepository"></param>
/// <param name="tenantSettingsRepository"></param>
/// <param name="allCampaigns"></param>
/// <param name="functionalAreaRepository"></param>
/// <returns></returns>
public static RunModel MapToRunModel(Run run, IScenarioRepository scenarioRepository, IPassRepository passRepository,
ITenantSettingsRepository tenantSettingsRepository, IMapper mapper,
IAnalysisGroupRepository analysisGroupRepository,
IFunctionalAreaRepository functionalAreaRepository = null,
IScenarioCampaignMetricRepository scenarioCampaignMetricRepository = null,
List <CampaignWithProductFlatModel> allCampaigns = null,
List <Pass> passesFromDb = null, List <Scenario> scenariosFromDb = null)
{
// Get scenarios for run
var scenarios = scenariosFromDb ?? scenarioRepository.FindByIds(run.Scenarios.Select(s => s.Id)).ToList();
// Get passes for run
var passes = passesFromDb ?? passRepository.FindByIds(scenarios.SelectMany(s => s.Passes).Select(p => p.Id).Distinct()).ToList();
var analysisGroups = run.AnalysisGroupTargets.Any()
? analysisGroupRepository.GetByIds(run.AnalysisGroupTargets.Select(x => x.AnalysisGroupId).ToArray()).ToDictionary(x => x.Id)
: new Dictionary <int, AnalysisGroupNameModel>();
// Get default ScenarioId
var defaultScenarioId = tenantSettingsRepository.GetDefaultScenarioId();
if (run.RunStatus == RunStatus.NotStarted && allCampaigns != null && allCampaigns.Any())
{
// Since the run has not already started amend Run Scenarios
// with CampaignPassPriorities for new Campaigns and remove
// CampaignPassPriorities of deleted Campaigns
CampaignPassPrioritiesServiceMapper.AmendCampaignPassPriorities(
scenarios,
passes,
allCampaigns,
passRepository,
mapper);
}
var runModel = mapper.Map <RunModel>(Tuple.Create(run, scenarios, passes, analysisGroups, defaultScenarioId));
if (run.RunStatus == RunStatus.Complete)
{
ApplyFunctionalAreaFaultTypesToRunModel(runModel, run, functionalAreaRepository);
}
if (scenarioCampaignMetricRepository != null)
{
runModel.Scenarios.ForEach(s => ApplyKPIsToScenarioCampaigns(s, scenarioCampaignMetricRepository));
}
return(runModel);
}
public AnalysisGroupsController(IAnalysisGroupRepository analysisGroupRepository,
ICampaignRepository campaignRepository,
IClashRepository clashRepository,
IProductRepository productRepository,
IUsersRepository usersRepository,
IModelDataValidator <CreateAnalysisGroupModel> validator,
IAnalysisGroupCampaignQuery groupCampaignQuery,
IMapper mapper)
{
_analysisGroupRepository = analysisGroupRepository;
_campaignRepository = campaignRepository;
_clashRepository = clashRepository;
_productRepository = productRepository;
_usersRepository = usersRepository;
_validator = validator;
_groupCampaignQuery = groupCampaignQuery;
_mapper = mapper;
}
public CreateAnalysisGroupModelValidation(IAnalysisGroupRepository analysisGroupRepository,
ICampaignRepository campaignRepository,
IClashRepository clashRepository,
IProductRepository productRepository,
IMapper mapper)
{
RuleFor(x => x.Name).NotEmpty().WithMessage("Analysis group name must not be empty");
RuleFor(x => x).Must(x =>
{
var entity = analysisGroupRepository.GetByName(x.Name);
return(entity is null || entity.Id == x.Id);
}).WithMessage("Analysis group name must be unique");
RuleFor(x => x.Filter)
.Custom((filter, context) =>
{
if (filter is null)
{
context.AddFailure(nameof(AnalysisGroup.Filter), "Analysis group filter must not be null");
return;
}
if (!ValidateCriteriaPresence(filter))
{
context.AddFailure(nameof(AnalysisGroup.Filter), "At least one analysis group filter criteria must be specified");
return;
}
var filterLabels = Mappings.MapToAnalysisGroupFilterSearchModel(mapper.Map <AnalysisGroupFilter>(filter), campaignRepository, clashRepository, productRepository);
var invalidFilterValues = new Dictionary <string, List <string> >
{
{
nameof(filter.AdvertiserExternalIds),
filter.AdvertiserExternalIds?.Where(id => !filterLabels.Advertisers.ContainsKey(id)).ToList()
},
{
nameof(filter.AgencyExternalIds),
filter.AgencyExternalIds?.Where(id => !filterLabels.Agencies.ContainsKey(id)).ToList()
},
{
nameof(filter.AgencyGroupCodes),
filter.AgencyGroupCodes?.Where(id => !filterLabels.AgencyGroups.ContainsKey(id)).ToList()
},
{
nameof(filter.BusinessTypes),
filter.BusinessTypes?.Where(id => !filterLabels.BusinessTypes.Contains(id)).ToList()
},
{
nameof(filter.CampaignExternalIds),
filter.CampaignExternalIds?.Where(id => !filterLabels.Campaigns.ContainsKey(id)).ToList()
},
{
nameof(filter.ClashExternalRefs),
filter.ClashExternalRefs?.Where(id => !filterLabels.ClashCodes.ContainsKey(id)).ToList()
},
{
nameof(filter.ProductExternalIds),
filter.ProductExternalIds?.Where(id => !filterLabels.Products.ContainsKey(id)).ToList()
},
{
nameof(filter.ReportingCategories),
filter.ReportingCategories?.Where(id => !filterLabels.ReportingCategories.Contains(id)).ToList()
},
{
nameof(filter.SalesExecExternalIds),
filter.SalesExecExternalIds?.Where(id => !filterLabels.SalesExecs.ContainsKey(id)).Select(x => x.ToString()).ToList()
}
};
foreach (var invalidFilterValue in invalidFilterValues)
{
if (invalidFilterValue.Value?.Count > 0)
{
context.AddFailure(nameof(AnalysisGroup.Filter), $"Invalid {invalidFilterValue.Key}: {string.Join(",", invalidFilterValue.Value)}");
}
}
});
}
