Пример #1
0
 public Task <T> GetAgreement <T>(IMarketingAgencyOwner marketingAgencyOwner, Guid providerOrganizationId) where T : MarketingAgreementOutput
 {
     return(Repository.Queryable().Where(x => x.ProviderOrganizationId == providerOrganizationId && x.MarketingOrganizationId == marketingAgencyOwner.OrganizationId)
            .Where(x => x.Status != AgreementStatus.Rejected)
            .ProjectTo <T>(ProjectionMapping)
            .FirstOrDefaultAsync());
 }
Пример #2
0
 public Task <T> GetLead <T>(IMarketingAgencyOwner agencyOwner, Guid leadId) where T : AgencyOwnerLeadOutput
 {
     return(Repository.Queryable()
            .Where(x => x.Id == leadId && x.MarketerOrganizationId == agencyOwner.OrganizationId && x.IsInternal == false)
            .ProjectTo <T>(ProjectionMapping)
            .FirstAsync());
 }
Пример #3
0
 public Task <T> GetMarketingContract <T>(IMarketingAgencyOwner ao, Guid contractId) where T : AgencyOwnerMarketingContractOutput
 {
     return(Repository.Queryable().ForAgencyOwner(ao)
            .FindById(contractId)
            .ProjectTo <T>(ProjectionMapping)
            .FirstOrDefaultAsync());
 }
Пример #4
0
 public Task <List <T> > GetAgreements <T>(IMarketingAgencyOwner marketingAgencyOwner) where T : MarketingAgreementOutput
 {
     return(Repository.Queryable().Where(x => x.MarketingOrganizationId == marketingAgencyOwner.OrganizationId)
            .Where(x => x.Status != AgreementStatus.Rejected)
            .ProjectTo <T>(ProjectionMapping)
            .ToListAsync());
 }
        public async Task <MarketingAgencyOwnerChartOutput> GetMarketingChartData(IMarketingAgencyOwner owner,
                                                                                  TimeMatrixFilters filters, ChartParams chartParams)
        {
            var result = await _matrixService.GetMarketingAgencyComposedOutput(owner, filters);

            var status = result.Matrix
                         .ToStatusData <MarketingAgencyOwnerTimeMatrixOutput, MarketingAgencyOwnerChartDataItem>()
                         .FillMissingDays(chartParams.DateBreakdown, filters).TopLevelGrouping(chartParams.DateBreakdown)
                         .SecondLevelGrouping(chartParams.DateBreakdown);


            var ma = result.Matrix.ToMaData <MarketingAgencyOwnerTimeMatrixOutput, AgencyOwnerOrganizationMarketerOutput, MarketingAgencyOwnerChartDataItem>(result.Marketers).
                     FillMissingDays(chartParams.DateBreakdown, filters).
                     TopLevelGrouping(chartParams.DateBreakdown).
                     SecondLevelGrouping(chartParams.DateBreakdown);

            return(new MarketingAgencyOwnerChartOutput
            {
                Ma = ma,
                Status = status,
                CurrentBreakdown = "ma",
                CurrentDateRange = chartParams.DateBreakdown == DateBreakdown.ByMonth ? "m0" : "w0",
                DateRanges = GetDateRange(chartParams.DateBreakdown, ma),
                Breakdowns = new Dictionary <string, string>
                {
                    { "ma", "By Marketer" },
                    { "status", "By Status" }
                }
            });
        }
Пример #6
0
 public Task <PackedList <T> > GetMarketingContracts <T>(IMarketingAgencyOwner ao, ContractFilters filters) where T : AgencyOwnerMarketingContractOutput
 {
     return(Repository.Queryable().ForAgencyOwner(ao)
            .ApplyWhereFilters(filters)
            .OrderByDescending(x => x.Updated)
            .PaginateProjection <Contract, T>(filters, ProjectionMapping));
 }
Пример #7
0
        public async Task <AgreementResult> CreateAgreement(IMarketingAgencyOwner marketingAgencyOwner,
                                                            Guid providerOrganizationId)
        {
            var retVal = new AgreementResult()
            {
                ProviderOrganizationId  = providerOrganizationId,
                MarketingOrganizationId = marketingAgencyOwner.OrganizationId
            };

            var marketingOrganization = await _marketingOrganizations.Queryable()
                                        .Where(x => x.Id == marketingAgencyOwner.OrganizationId)
                                        .FirstOrDefaultAsync();

            if (marketingOrganization == null)
            {
                retVal.ErrorMessage = "Organization is not configured correctly";
                return(retVal);
            }

            _logger.LogDebug(GetLogMessage("Marketing Organization Found: {0}"), marketingOrganization.Id);

            var providerOrganization = await _providerOrganization.Queryable()
                                       .Where(x => x.Id == providerOrganizationId)
                                       .FirstOrDefaultAsync();

            if (providerOrganization == null)
            {
                throw new ApplicationException("Provider organization was not found");
            }

            _logger.LogDebug(GetLogMessage("Provider Organization Found: {0}"), providerOrganization.Id);

            var agreement = new MarketingAgreement
            {
                MarketingStream         = marketingOrganization.MarketerStream,
                MarketingBonus          = marketingOrganization.MarketerBonus,
                MarketingAgencyBonus    = marketingOrganization.MarketingAgencyBonus,
                MarketingAgencyStream   = marketingOrganization.MarketingAgencyStream,
                MarketingOrganizationId = marketingAgencyOwner.OrganizationId,
                ProviderOrganizationId  = providerOrganizationId,
                Status              = AgreementStatus.AwaitingApproval,
                ObjectState         = ObjectState.Added,
                InitiatedByProvider = false,
                Created             = DateTimeOffset.UtcNow
            };

            _logger.LogDebug(GetLogMessage("Marketing Agreement: {@agreement}"), agreement);

            var result = Repository.InsertOrUpdateGraph(agreement, true);

            _logger.LogDebug(GetLogMessage("{0} Records updated in database"), result);

            return(await Task.FromResult(new AgreementResult()
            {
                Succeeded = result > 0,
                MarketingOrganizationId = agreement.MarketingOrganizationId,
                ProviderOrganizationId = agreement.ProviderOrganizationId
            }));
        }
 public MarketingAgreementController(
     IServiceProvider serviceProvider,
     IMarketingAgencyOwner marketingAgencyOwner,
     IMarketingAgreementService agreementService) : base(serviceProvider)
 {
     _marketingAgencyOwner = marketingAgencyOwner;
     _agreementService     = agreementService;
 }
Пример #9
0
 public Task <PackedList <T> > GetLeads <T>(IMarketingAgencyOwner ao, CommonFilters filters) where T : AgencyOwnerLeadOutput
 {
     return(Repository.Queryable()
            .ForMarketingAgencyOwner(ao)
            .Where(x => x.IsInternal == false)
            .OrderByDescending(x => x.Updated)
            .PaginateProjection <Lead, T>(filters, ProjectionMapping));
 }
Пример #10
0
        public async Task <List <T> > Discover <T>(IMarketingAgencyOwner owner) where T : MarketingAgencyOwnerProviderOrganizationOutput
        {
            var exclude = await _marketingAgreement.Queryable()
                          .Where(x => x.MarketingOrganizationId == owner.OrganizationId)
                          .Select(x => x.ProviderOrganizationId).ToListAsync();

            exclude.Add(owner.OrganizationId);

            return(await Repository.Queryable()
                   .Include(x => x.Organization)
                   .ThenInclude(x => x.OrganizationFinancialAccount)
                   .Where(x => !exclude.Contains(x.Id) && x.Organization.OrganizationFinancialAccount != null && x.Discoverable)
                   .ProjectTo <T>(ProjectionMapping).ToListAsync());
        }
Пример #11
0
        public async Task <OrganizationResult> UpdateOrganization(IMarketingAgencyOwner agencyOwner, MarketingOrganizationInput input)
        {
            _logger.LogInformation(GetLogMessage("Organization:{0}; input:{@input}"), agencyOwner.OrganizationId, input);

            var marketingOrganization = await Repository.Queryable()

                                        .Include(x => x.MarketingOrganization)
                                        .Include(x => x.Marketers)

                                        .Where(x => x.Id == agencyOwner.OrganizationId)
                                        .Select(x => x.MarketingOrganization)
                                        .FirstAsync();

            var organization = await Repository.Queryable()
                               .Where(x => x.Id == agencyOwner.OrganizationId)
                               .FirstOrDefaultAsync();

            return(await UpdateMarketingOrganization(marketingOrganization, input, organization));
        }
Пример #12
0
        public async Task <ContractResult> UpdateContract(IMarketingAgencyOwner ao, Guid contractId, UpdateMarketingContractInput input)
        {
            var co = await Repository.Queryable().ForAgencyOwner(ao)
                     .FirstAsync(x => x.Id == contractId);

            co.InjectFrom <NullableInjection>(input);

            if (input.MarketerStream.HasValue)
            {
                co.MarketerStream = input.MarketerStream.Value;
            }

            if (input.MarketingAgencyStream.HasValue)
            {
                co.MarketingAgencyStream = input.MarketingAgencyStream.Value;
            }

            return(await UpdateContract(co));
        }
Пример #13
0
        public async Task <AgreementResult> AcceptAgreement(
            IMarketingAgencyOwner marketingAgencyOwner, Guid providerOrganizationId)
        {
            var agreement = await Repository.Queryable()
                            .FirstOrDefaultAsync(x =>
                                                 x.MarketingOrganizationId == marketingAgencyOwner.OrganizationId &&
                                                 x.ProviderOrganizationId == providerOrganizationId);

            if (agreement == null)
            {
                throw new ApplicationException("Agreement not found.");
            }

            if (agreement.Status != AgreementStatus.AwaitingApproval)
            {
                return new AgreementResult()
                       {
                           Succeeded = false
                       }
            }
            ;

            agreement.Status      = AgreementStatus.Approved;
            agreement.ObjectState = ObjectState.Modified;
            agreement.Updated     = DateTimeOffset.UtcNow;

            var result = await Repository.UpdateAsync(agreement, true);

            return(new AgreementResult()
            {
                Succeeded = result > 0,
                MarketingOrganizationId = agreement.MarketingOrganizationId,
                ProviderOrganizationId = agreement.ProviderOrganizationId
            });
        }
    }
Пример #14
0
 public static IQueryable <Lead> ForMarketingAgencyOwner(this IQueryable <Lead> entities,
                                                         IMarketingAgencyOwner ao)
 {
     return(entities.Where(x => x.MarketerOrganizationId == ao.OrganizationId));
 }
        public async Task <MarketingAgencyOwnerTimeMatrixComposedOutput> GetMarketingAgencyComposedOutput(IMarketingAgencyOwner owner,
                                                                                                          TimeMatrixFilters filters)
        {
            // this is essentially the provider organization id
            filters.MarketerOrganizationId = owner.OrganizationId;

            var matrix = await _context.TimeMatrix.ApplyWhereFilters(filters)
                         .ProjectTo <MarketingAgencyOwnerTimeMatrixOutput>(_mapperConfiguration)
                         .ToListAsync();

            var uniqueMarketerIds = matrix.Select(x => x.MarketerId).Distinct().ToArray();

            var marketers =
                _marketerService.GetForOrganization <AgencyOwnerOrganizationMarketerOutput>(owner.OrganizationId,
                                                                                            uniqueMarketerIds);

            Task.WaitAll(marketers);

            return(new MarketingAgencyOwnerTimeMatrixComposedOutput
            {
                Matrix = matrix,
                Marketers = marketers.Result
            });
        }
Пример #16
0
 public Task <AgencyOwnerMarketingOrganizationDetailsOutput> GetMarketingDetails(IMarketingAgencyOwner agencyOwner)
 {
     return(Repository.Queryable()
            .Include(x => x.MarketingOrganization)
            .Where(x => x.MarketingOrganization != null && x.Id == agencyOwner.OrganizationId)
            .Select(x => x.MarketingOrganization)
            .ProjectTo <AgencyOwnerMarketingOrganizationDetailsOutput>(ProjectionMapping)
            .FirstOrDefaultAsync());
 }