Example #1
0
 public Task <T> GetRecruitingContract <T>(IRecruitingAgencyOwner ao, Guid contractId) where T : AgencyOwnerRecruitingContractOutput
 {
     return(Repository.Queryable().ForAgencyOwner(ao)
            .FindById(contractId)
            .ProjectTo <T>(ProjectionMapping)
            .FirstOrDefaultAsync());
 }
 public Task <T> GetAgreement <T>(IRecruitingAgencyOwner principal, Guid providerAgencyId) where T : RecruitingAgreementOutput
 {
     return(Repository.Queryable().Where(x => x.RecruitingOrganizationId == principal.OrganizationId && x.ProviderOrganizationId == providerAgencyId)
            .Where(x => x.Status != AgreementStatus.Rejected)
            .ProjectTo <T>(ProjectionMapping)
            .FirstOrDefaultAsync());
 }
Example #3
0
 public Task <PackedList <T> > GetRecruitingContracts <T>(IRecruitingAgencyOwner ao, ContractFilters filters) where T : AgencyOwnerRecruitingContractOutput
 {
     return(Repository.Queryable().ForAgencyOwner(ao)
            .ApplyWhereFilters(filters)
            .OrderByDescending(x => x.Updated)
            .PaginateProjection <Contract, T>(filters, ProjectionMapping));
 }
        public async Task <RecruitingAgencyOwnerChartOutput> GetRecruitingChartData(IRecruitingAgencyOwner owner,
                                                                                    TimeMatrixFilters filters, ChartParams chartParams)
        {
            var result = await _matrixService.GetRecruitingAgencyComposedOutput(owner, filters);

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



            var re = result.Matrix.ToReData <RecruitingAgencyOwnerTimeMatrixOutput, AgencyOwnerOrganizationRecruiterOutput, RecruitingAgencyOwnerChartDataItem>(result.Recruiters).
                     FillMissingDays(chartParams.DateBreakdown, filters).
                     TopLevelGrouping(chartParams.DateBreakdown).
                     SecondLevelGrouping(chartParams.DateBreakdown);


            return(new RecruitingAgencyOwnerChartOutput
            {
                Re = re,
                Status = status,
                CurrentBreakdown = "re",
                CurrentDateRange = chartParams.DateBreakdown == DateBreakdown.ByMonth ? "m0" : "w0",
                DateRanges = GetDateRange(chartParams.DateBreakdown, re),
                Breakdowns = new Dictionary <string, string>
                {
                    { "re", "By Recruiter" },
                    { "status", "By Status" }
                }
            });
        }
 public Task <List <T> > GetAgreements <T>(IRecruitingAgencyOwner principal) where T : RecruitingAgreementOutput
 {
     return(Repository.Queryable().Where(x => x.RecruitingOrganizationId == principal.OrganizationId)
            .Where(x => x.Status != AgreementStatus.Rejected)
            .ProjectTo <T>(ProjectionMapping)
            .ToListAsync());
 }
Example #6
0
        public async Task <List <T> > Discover <T>(IRecruitingAgencyOwner owner) where T : RecruitingAgencyOwnerProviderOrganizationOutput
        {
            var exclude = await _recruitingAgreement.Queryable()
                          .Where(x => x.RecruitingOrganizationId == 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());
        }
Example #7
0
        public async Task <OrganizationResult> UpdateOrganization(IRecruitingAgencyOwner agencyOwner, RecruitingOrganizationInput input)
        {
            _logger.LogInformation(GetLogMessage("Organization:{0}; input:{@input}"), agencyOwner.OrganizationId, input);

            var recruitingOrganization = await Repository.Queryable()

                                         .Include(x => x.RecruitingOrganization)
                                         .Include(x => x.Recruiters)

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

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

            return(await UpdateRecruitingOrganization(recruitingOrganization, input, organization));
        }
Example #8
0
        public async Task <ContractResult> UpdateContract(IRecruitingAgencyOwner ao, Guid contractId, UpdateRecruitingContractInput input)
        {
            var co = await Repository.Queryable().ForAgencyOwner(ao)
                     .FirstAsync(x => x.Id == contractId);

            co.InjectFrom <NullableInjection>(input);

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

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


            return(await UpdateContract(co));
        }
        public async Task <AgreementResult> AcceptAgreement(IRecruitingAgencyOwner principal,
                                                            Guid providerOrganizationId)
        {
            _logger
            .LogInformation(GetLogMessage("Accepting Agreement: Recruiting Agency {1}, Provider Agency {2}"), principal.OrganizationId, providerOrganizationId);

            var agreement = await Repository.Queryable()
                            .FirstOrDefaultAsync(x =>
                                                 x.RecruitingOrganizationId == principal.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);

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

            return(new AgreementResult()
            {
                Succeeded = result > 0,
                RecruitingOrganizationId = agreement.RecruitingOrganizationId,
                ProviderOrganizationId = agreement.ProviderOrganizationId
            });
        }
        public async Task <RecruitingAgencyOwnerTimeMatrixComposedOutput> GetRecruitingAgencyComposedOutput(IRecruitingAgencyOwner owner,
                                                                                                            TimeMatrixFilters filters)
        {
            // this is essentially the provider organization id
            filters.RecruiterOrganizationId = owner.OrganizationId;

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

            var uniqueRecruiterIds = matrix.Select(x => x.RecruiterId).Distinct().ToArray();

            var recruiters =
                _recruiterService.GetForOrganization <AgencyOwnerOrganizationRecruiterOutput>(owner.OrganizationId,
                                                                                              uniqueRecruiterIds);

            Task.WaitAll(recruiters);

            return(new RecruitingAgencyOwnerTimeMatrixComposedOutput
            {
                Matrix = matrix,

                Recruiters = recruiters.Result
            });
        }
        public async Task <AgreementResult> CreateAgreement(IRecruitingAgencyOwner principal,
                                                            Guid providerOrganizationId, RecruitingAgreementInput input)
        {
            _logger.LogInformation(GetLogMessage("Agency Owner creating recruiting agreement {@agreement}"), input);

            var retVal = new AgreementResult()
            {
                ProviderOrganizationId   = providerOrganizationId,
                RecruitingOrganizationId = principal.OrganizationId
            };

            var recruiterOrganization = await _recruitingOrganizations.Queryable()
                                        .Where(x => x.Id == principal.OrganizationId)
                                        .FirstOrDefaultAsync();

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

                return(retVal);
            }

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

            var providerOrganization = await _providerOrganizations.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 RecruitingAgreement()
            {
                RecruiterStream          = recruiterOrganization.RecruiterStream,
                RecruiterBonus           = recruiterOrganization.RecruiterBonus,
                RecruitingAgencyBonus    = recruiterOrganization.RecruitingAgencyBonus,
                RecruitingAgencyStream   = recruiterOrganization.RecruitingAgencyStream,
                RecruitingOrganizationId = principal.OrganizationId,
                ProviderOrganizationId   = providerOrganizationId,
                Status              = AgreementStatus.AwaitingApproval,
                ObjectState         = ObjectState.Added,
                InitiatedByProvider = false
            };

            _logger.LogDebug(GetLogMessage("Recruiting 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,
                ProviderOrganizationId = agreement.ProviderOrganizationId,
                RecruitingOrganizationId = agreement.RecruitingOrganizationId
            }));
        }
 public Task <AgencyOwnerRecruitingOrganizationDetailsOutput> GetRecruitingDetails(IRecruitingAgencyOwner agencyOwner)
 {
     return(Repository.Queryable()
            .Include(x => x.RecruitingOrganization)
            .Where(x => x.RecruitingOrganization != null && x.Id == agencyOwner.OrganizationId)
            .Select(x => x.RecruitingOrganization)
            .ProjectTo <AgencyOwnerRecruitingOrganizationDetailsOutput>(ProjectionMapping)
            .FirstOrDefaultAsync());
 }
 public static IQueryable <Contract> ForAgencyOwner(this IQueryable <Contract> entities,
                                                    IRecruitingAgencyOwner ao)
 {
     return(entities.Where(x => x.RecruiterOrganizationId == ao.OrganizationId));
 }
 public RecruitingAgreementController(IServiceProvider serviceProvider,
                                      IRecruitingAgencyOwner recruitingAgencyOwner, IRecruitingAgreementService agreementService) : base(serviceProvider)
 {
     _recruitingAgencyOwner = recruitingAgencyOwner;
     _agreementService      = agreementService;
 }