public async Task <MarketerTimeMatrixComposedOutput> GetComposedOutput(IOrganizationMarketer ma, TimeMatrixFilters filters)
{
filters.MarketerId = ma.MarketerId;
filters.MarketerOrganizationId = ma.OrganizationId;
var matrix = await _context.TimeMatrix.ApplyWhereFilters(filters)
.ProjectTo <MarketerTimeMatrixOutput>(_mapperConfiguration)
.ToListAsync();
var uniqueContractIds = matrix.Select(x => x.ContractId).Distinct().ToArray();
var uniqueCustomerIds = matrix.Select(x => x.CustomerId).Distinct().ToArray();
var contractsTask = _contractService.GetContracts <MarketerContractOutput>(ma, uniqueContractIds);
var customers =
_customerService.GetForOrganization <MarketerOrganizationCustomerOutput>(ma.OrganizationId,
uniqueCustomerIds);
var contractors =
_contractorService.GetForOrganization <MarketerOrganizationContractorOutput>(ma.OrganizationId,
uniqueCustomerIds);
Task.WaitAll(contractsTask, customers, contractors);
return(new MarketerTimeMatrixComposedOutput()
{
Matrix = matrix,
Contracts = contractsTask.Result,
Contractors = contractors.Result,
Customers = customers.Result
});
}
public ContractController(IContractService contractService,
IOrganizationMarketer marketer,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_marketer = marketer;
_contractService = contractService;
}
public async Task <T> GetTimeEntry <T>(IOrganizationMarketer ma, Guid entryId) where T : MarketerTimeEntryOutput
{
return(await Repository.Queryable()
.FindById(entryId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <bool> CreateLeadComment(IOrganizationMarketer marketer, Guid leadId, CommentInput input)
{
var lead = await _leadRepository.Queryable().ForOrganizationMarketer(marketer)
.Where(x => x.Id == leadId)
.FirstAsync();
return(await CreateLeadComment(lead, input, marketer.OrganizationId));
}
public Task <PackedList <T> > GetContracts <T>(IOrganizationMarketer ma, ContractFilters filters)
where T : MarketerContractOutput
{
return(Repository.Queryable().ForOrganizationMarketer(ma)
.ApplyWhereFilters(filters)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Contract, T>(filters, ProjectionMapping));
}
public Task <T> GetContract <T>(IOrganizationMarketer ma, Guid id) where T : MarketerContractOutput
{
return(Repository.Queryable()
.ForOrganizationMarketer(ma)
.FindById(id)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <LeadResult> CreateInternalLead(
IOrganizationMarketer ma,
LeadInput model)
{
_logger.LogInformation(GetLogMessage("MA: {0}"), ma.OrganizationId);
return(CreateLead(ma, ma.OrganizationId, model));
}
public TimeController(ITimeMatrixService timeMatrix,
IOrganizationMarketer marketer,
IServiceProvider serviceProvider,
IChartService chartService) : base(serviceProvider)
{
_marketer = marketer;
_timeMatrix = timeMatrix;
_chartService = chartService;
}
public Task <List <T> > GetTimeEntries <T>(IOrganizationMarketer ma, TimeMatrixFilters filters)
where T : MarketerTimeEntryOutput
{
return(Repository.Queryable()
.ForOrganizationMarketer(ma)
.ApplyWhereFilters(filters)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <List <T> > GetContracts <T>(IOrganizationMarketer ma, Guid[] uniqueContractIds) where T : MarketerContractOutput
{
return(Repository
.Queryable()
.ForOrganizationMarketer(ma)
.Where(x => uniqueContractIds.Contains(x.Id))
.OrderByDescending(x => x.Updated)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public LeadController(ILeadService leadService,
ILeadMatrixService leadMatrixService,
IOrganizationMarketer marketer,
ICommentService commentService,
IServiceProvider provider) : base(provider)
{
_marketer = marketer;
_commentService = commentService;
_leadService = leadService;
_leadMatrixService = leadMatrixService;
}
public async Task <LeadResult> DeleteLead(IOrganizationMarketer ma, Guid leadId)
{
var lead = await Repository.Queryable()
.ForOrganizationMarketer(ma)
.Where(x => x.Id == leadId).FirstAsync();
if (lead.Status != LeadStatus.New)
{
throw new InvalidOperationException("You cannot delete a lead in this state");
}
return(await DeleteLead(lead.Id));
}
public async Task <MarketerChartOutput> GetProviderChartData(IOrganizationMarketer marketer, TimeMatrixFilters filters, ChartParams chartParams)
{
var result = await _matrixService.GetComposedOutput(marketer, filters);
var co = result.Matrix.ToCoData <MarketerTimeMatrixOutput, MarketerOrganizationContractorOutput, MarketerChartDataItem>(result.Contractors).
FillMissingDays(chartParams.DateBreakdown, filters).
TopLevelGrouping(chartParams.DateBreakdown).
SecondLevelGrouping(chartParams.DateBreakdown);
return(new MarketerChartOutput
{
Co = co,
CurrentBreakdown = "co",
CurrentDateRange = chartParams.DateBreakdown == DateBreakdown.ByMonth ? "m0" : "w0",
DateRanges = GetDateRange(chartParams.DateBreakdown, co),
Breakdowns = new Dictionary <string, string> {
{ "co", "By Contractor" }
}
});
}
private async Task <LeadResult> CreateLead(IOrganizationMarketer ma, Guid providerOrganizationId, LeadInput input)
{
_logger.LogInformation(GetLogMessage("MA: {0}"), ma.OrganizationId);
var retVal = new LeadResult();
if (await CountLeadsPerProviderByEmail(providerOrganizationId, input.EmailAddress) > 0)
{
retVal.ErrorMessage = "Email has already been used as a lead for this organization";
retVal.Succeeded = false;
return(retVal);
}
_logger.LogDebug(GetLogMessage("Email hasn't been used by this organization"));
var isExternal = providerOrganizationId != ma.OrganizationId;
_logger.LogDebug(GetLogMessage("External Lead: {0}"), isExternal);
var marketer = await _marketerService.Repository.Queryable()
.Include(x => x.Marketer)
.ThenInclude(x => x.Person)
.Where(x => x.MarketerId == ma.MarketerId && x.OrganizationId == ma.OrganizationId)
.FirstAsync();
var marketerBonus = marketer.MarketerBonus;
var marketerAgencyBonus = 0m;
var marketerAgencyStream = 0m;
var marketerStream = marketer.MarketerStream;
_logger.LogTrace(
GetLogMessage(
$@"Marketer Found: {marketer.MarketerId}"));
if (isExternal)
{
var marketingAgreement = await _marketingAgreements.Queryable()
.Where(x => x.ProviderOrganizationId == providerOrganizationId &&
x.MarketingOrganizationId == ma.OrganizationId)
.FirstOrDefaultAsync();
if (marketingAgreement == null)
{
retVal.ErrorMessage =
"Marketing agreement doesn't exist between marketing and provider organization";
return(retVal);
}
if (marketingAgreement.Status != AgreementStatus.Approved)
{
retVal.ErrorMessage = "Marketing agreement is not approved";
return(retVal);
}
_logger.LogDebug(
GetLogMessage(
$@"Marketing Agreement found to be valid"));
marketerBonus = marketingAgreement.MarketerBonus;
marketerAgencyBonus = marketingAgreement.MarketingAgencyBonus;
marketerAgencyStream = marketingAgreement.MarketingAgencyStream;
marketerStream = marketingAgreement.MarketerStream;
}
var lead = new Lead
{
Iso2 = input.Iso2,
ProvinceState = input.ProvinceState,
MarketerId = marketer.MarketerId,
MarketerOrganizationId = marketer.OrganizationId,
MarketerStream = marketerStream,
MarketerBonus = marketerBonus,
MarketingAgencyBonus = marketerAgencyBonus,
MarketingAgencyStream = marketerAgencyStream,
ProviderOrganizationId = providerOrganizationId,
UpdatedById = marketer.MarketerId,
CreatedById = marketer.MarketerId, // cant be _userInfo.UserId
ObjectState = ObjectState.Added,
Status = LeadStatus.New
};
lead.StatusTransitions.Add(new LeadStatusTransition()
{
Status = LeadStatus.New,
ObjectState = ObjectState.Added
});
lead.InjectFrom(input);
var records = Repository.Insert(lead, true);
_logger.LogDebug(GetLogMessage("{0} records updated in db"), records);
if (records > 0)
{
retVal.LeadId = lead.Id;
retVal.Succeeded = true;
await Task.Run(() => RaiseEvent(new LeadCreatedEvent
{
LeadId = lead.Id
}));
}
return(retVal);
}
public async Task <LeadResult> CreateExternalLead(IOrganizationMarketer ma, Guid providerOrganizationId, LeadInput model)
{
_logger.LogInformation(GetLogMessage("MA: {0}"), ma.OrganizationId);
return(await CreateLead(ma, providerOrganizationId, model));
}
