public static List <AnalysisGroupModel> MapToAnalysisGroupModels(List <AnalysisGroup> analysisGroups,
ICampaignRepository campaignRepository,
IClashRepository clashRepository,
IProductRepository productRepository,
IUsersRepository usersRepository,
IMapper mapper)
{
var filterWithLabels = MapToAnalysisGroupFilterSearchModel(AnalysisGroupFilter.BuildFrom(analysisGroups), campaignRepository, clashRepository, productRepository);
var userIds = new HashSet <int>();
foreach (var analysisGroup in analysisGroups)
{
userIds.Add(analysisGroup.CreatedBy);
userIds.Add(analysisGroup.ModifiedBy);
}
var users = mapper.Map <List <UserReducedModel> >(usersRepository.GetByIds(userIds.ToList()));
return(mapper.Map <List <AnalysisGroupModel> >((analysisGroups, filterWithLabels, users.ToDictionary(x => x.Id))));
}
public IEnumerable <Guid> GetAnalysisGroupCampaigns(AnalysisGroupFilter filter)
{
var mapperFilter = new CampaignSearchQueryModel()
{
BusinessTypes = filter.BusinessTypes.ToList(),
ClashCodes = filter.ClashExternalRefs.ToList(),
CampaignIds = filter.CampaignExternalIds.ToList(),
ProductIds = filter.ProductExternalIds.ToList(),
AgencyIds = filter.AgencyExternalIds.ToList(),
AdvertiserIds = filter.AdvertiserExternalIds.ToList(),
ReportingCategories = filter.ReportingCategories.ToList(),
MediaSalesGroupIds = filter.AgencyGroupCodes.ToList(),
ProductAssigneeIds = filter.SalesExecExternalIds.Select(c => c.ToString()).ToList()
};
var campaigns = _campaignRepository.GetWithProduct(mapperFilter);
return(campaigns.Items.Select(c => c.Uid)
.Distinct()
.ToArray());
}
private static AnalysisGroupFilterModel MapToAnalysisGroupFilterModel(AnalysisGroupFilter filter, AnalysisGroupFilterSearchModel displayValues) =>
new AnalysisGroupFilterModel
{
Advertisers = ConstructFilterItem(filter.AdvertiserExternalIds, displayValues.Advertisers),
Agencies = ConstructFilterItem(filter.AgencyExternalIds, displayValues.Agencies),
MediaGroup = ConstructFilterItem(filter.AgencyGroupCodes, displayValues.AgencyGroups),
BusinessTypes = filter.BusinessTypes.Select(x => new AnalysisGroupFilterItem <string>
{
Key = x,
Label = displayValues.BusinessTypes.Contains(x) ? x : MissingMessage
}).ToList(),
Campaigns = ConstructFilterItem(filter.CampaignExternalIds, displayValues.Campaigns),
ClashCodes = ConstructFilterItem(filter.ClashExternalRefs, displayValues.ClashCodes),
Products = ConstructFilterItem(filter.ProductExternalIds, displayValues.Products),
ReportingCategories = filter.ReportingCategories.Select(x => new AnalysisGroupFilterItem <string>
{
Key = x,
Label = displayValues.ReportingCategories.Contains(x) ? x : MissingMessage
}).ToList(),
ProductAssigneeName = ConstructFilterItem(filter.SalesExecExternalIds, displayValues.SalesExecs)
};
public static AnalysisGroupFilterSearchModel MapToAnalysisGroupFilterSearchModel(AnalysisGroupFilter filter,
ICampaignRepository campaignRepository,
IClashRepository clashRepository,
IProductRepository productRepository)
{
if (filter is null)
{
throw new InvalidOperationException("AnalysisGroup filter can not be null");
}
return(new AnalysisGroupFilterSearchModel
{
Advertisers = productRepository.GetAdvertisers(filter.AdvertiserExternalIds)
.ToDictionary(x => x.AdvertiserIdentifier, x => x.AdvertiserName),
Agencies = productRepository.GetAgencies(filter.AgencyExternalIds)
.ToDictionary(x => x.AgencyIdentifier, x => x.AgencyName),
AgencyGroups = productRepository.GetAgencyGroups(filter.AgencyGroupCodes)
.ToDictionary(x => x.Code, x => x.ShortName),
BusinessTypes = filter.BusinessTypes.Any()
? new HashSet <string>(campaignRepository.GetBusinessTypes())
: filter.BusinessTypes,
Campaigns = campaignRepository.FindNameByRefs(filter.CampaignExternalIds)
.ToDictionary(x => x.ExternalId, x => x.Name),
ClashCodes = clashRepository.GetDescriptionByExternalRefs(filter.ClashExternalRefs)
.ToDictionary(x => x.Externalref, x => x.Description),
Products = productRepository.GetByExternalIds(filter.ProductExternalIds)
.ToDictionary(x => x.Externalidentifier, x => x.Name),
ReportingCategories = filter.ReportingCategories.Any()
? new HashSet <string>(productRepository.GetReportingCategories())
: filter.ReportingCategories,
SalesExecs = productRepository.GetSalesExecutives(filter.SalesExecExternalIds)
.ToDictionary(x => x.Identifier, x => x.Name)
});
}
public IEnumerable <Guid> GetAnalysisGroupCampaigns(AnalysisGroupFilter filter)
{
var initialQuery = _dbContext.Query <Campaign>()
.Join(
_dbContext.Specific.View <CampaignWithProductRelations>(),
c => c.Id,
s => s.CampaignId,
(campaign, relations) => new { relations, campaign }
)
.AsQueryable();
if (!(filter.CampaignExternalIds is null) && filter.CampaignExternalIds.Count > 0)
{
initialQuery = initialQuery.Where(c =>
filter.CampaignExternalIds.AsEnumerable().Contains(c.campaign.ExternalId)
);
}
if (!(filter.BusinessTypes is null) && filter.BusinessTypes.Count > 0)
{
initialQuery = initialQuery.Where(c =>
filter.BusinessTypes.AsEnumerable().Contains(c.campaign.BusinessType)
);
}
if (!(filter.AdvertiserExternalIds is null) && filter.AdvertiserExternalIds.Count > 0)
{
var advertiserQuery = _dbContext.Query <Advertiser>().Where(s =>
filter.AdvertiserExternalIds.AsEnumerable().Contains(s.ExternalIdentifier)
);
initialQuery = initialQuery.Join(advertiserQuery, c => c.relations.AdvertiserId, s => s.Id, (a, d) => a);
}
if (!(filter.AgencyGroupCodes is null) && filter.AgencyGroupCodes.Count > 0)
{
var agencyGroupQuery = _dbContext.Query <AgencyGroup>().Where(s =>
filter.AgencyGroupCodes.AsEnumerable().Contains(s.Code)
);
initialQuery = initialQuery.Join(agencyGroupQuery, c => c.relations.AgencyGroupId, s => s.Id, (a, d) => a);
}
if (!(filter.AgencyExternalIds is null) && filter.AgencyExternalIds.Count > 0)
{
var agencyQuery = _dbContext.Query <Agency>().Where(s =>
filter.AgencyExternalIds.AsEnumerable().Contains(s.ExternalIdentifier)
);
initialQuery = initialQuery.Join(agencyQuery, c => c.relations.AgencyId, s => s.Id, (a, d) => a);
}
bool hasClashFilter = !(filter.ClashExternalRefs is null) && filter.ClashExternalRefs.Count > 0;
bool hasProductFilter = !(filter.ProductExternalIds is null) && filter.ProductExternalIds.Count > 0;
bool hasReportingCategoriesFilter = !(filter.ReportingCategories is null) && filter.ReportingCategories.Count > 0;
if (hasProductFilter || hasClashFilter || hasReportingCategoriesFilter)
{
var productQuery = _dbContext.Query <Product>();
var intermediateQuery = initialQuery.Join(
productQuery,
c => c.relations.ProductId,
s => s.Uid,
(campaign, product) => new { campaign, product }
);
if (hasProductFilter)
{
intermediateQuery = intermediateQuery
.Where(s => filter.ProductExternalIds.AsEnumerable().Contains(s.product.Externalidentifier));
}
if (hasReportingCategoriesFilter)
{
intermediateQuery = intermediateQuery
.Where(s => filter.ReportingCategories.AsEnumerable().Contains(s.product.ReportingCategory));
}
if (hasClashFilter)
{
var clashQuery = _dbContext.Query <Clash>().Where(s =>
filter.ClashExternalRefs.AsEnumerable().Contains(s.Externalref)
);
intermediateQuery = intermediateQuery
.Join(
clashQuery,
c => c.product.ClashCode,
s => s.Externalref,
(campaign, clash) => campaign
);
}
initialQuery = intermediateQuery.Select(c => c.campaign);
}
if (!(filter.SalesExecExternalIds is null) && filter.SalesExecExternalIds.Count > 0)
{
var personQuery = _dbContext.Query <Person>()
.Where(c => filter.SalesExecExternalIds.AsEnumerable().Contains(c.ExternalIdentifier));
initialQuery = initialQuery
.Join(
personQuery,
c => c.relations.PersonId,
s => s.ExternalIdentifier,
(campaign, clash) => campaign
);
}
return(initialQuery.Select(c => c.campaign.Id)
.Distinct()
.ToArray());
}
