示例#1
0
        public Task <AgreementResult> CreateAgreement(IProviderAgencyOwner providerAgencyOwner, Guid recruitingOrganizationId)
        {
            _logger.LogInformation(GetLogMessage("Creating agreement between provider {0} and recruiter {1}"), providerAgencyOwner.OrganizationId, recruitingOrganizationId);

            var recruitingOrganization = UnitOfWork
                                         .RepositoryAsync <RecruitingOrganization>().Queryable()
                                         .Include(x => x.RecruitingAgreements)
                                         .FirstOrDefault(x => x.Id == recruitingOrganizationId);

            if (recruitingOrganization == null)
            {
                throw new ApplicationException("Recruiting organization not found");
            }

            _logger.LogDebug(GetLogMessage("Recruiting organization found: {0}"), recruitingOrganization.Id);

            if (recruitingOrganization.Discoverable == false)
            {
                throw new ApplicationException("Recruiting organization is not accepting offers");
            }

            if (recruitingOrganization.RecruitingAgreements.Any(x => x.ProviderOrganizationId == providerAgencyOwner.OrganizationId))
            {
                throw new ApplicationException("An existing offer already exists");
            }

            var agreement = new RecruitingAgreement()
            {
                ProviderOrganizationId   = providerAgencyOwner.OrganizationId,
                RecruitingOrganizationId = recruitingOrganizationId,
                Status                 = AgreementStatus.AwaitingApproval,
                Created                = DateTimeOffset.UtcNow,
                ObjectState            = ObjectState.Added,
                InitiatedByProvider    = true,
                RecruitingAgencyStream = recruitingOrganization.RecruitingAgencyStream,
                RecruitingAgencyBonus  = recruitingOrganization.RecruitingAgencyBonus,
                RecruiterBonus         = recruitingOrganization.RecruiterBonus,
                RecruiterStream        = recruitingOrganization.RecruiterStream
            };

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

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

            return(Task.FromResult(new AgreementResult()
            {
                Succeeded = result > 0,

                RecruitingOrganizationId = agreement.RecruitingOrganizationId,
                ProviderOrganizationId = agreement.ProviderOrganizationId
            }));
        }
        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
            }));
        }