private async Task <bool> UploadEmployment(Person person, SSG_SearchRequest request, SSG_Person ssg_person, int?providerDynamicsID, CancellationToken concellationToken)
        {
            if (person.Employments == null)
            {
                return(true);
            }
            try
            {
                foreach (var employment in person.Employments)
                {
                    EmploymentEntity e = _mapper.Map <EmploymentEntity>(employment);
                    e.SearchRequest     = request;
                    e.InformationSource = providerDynamicsID;
                    e.Person            = ssg_person;
                    SSG_Employment ssg_employment = await _searchRequestService.CreateEmployment(e, concellationToken);

                    if (employment.Employer != null)
                    {
                        foreach (var phone in employment.Employer.Phones)
                        {
                            SSG_EmploymentContact p = _mapper.Map <SSG_EmploymentContact>(phone);
                            p.Employment = ssg_employment;
                            await _searchRequestService.CreateEmploymentContact(p, concellationToken);
                        }
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);
                return(false);
            }
        }
Beispiel #2
0
        private async Task <bool> UploadEmployment(bool inUpdateProcess = false)
        {
            if (_personSought.Employments == null)
            {
                return(true);
            }

            _logger.LogDebug($"Attempting to create employment records for PersonSought.");

            foreach (var employment in _personSought.Employments)
            {
                EmploymentEntity e = _mapper.Map <EmploymentEntity>(employment);
                e.SearchRequest     = _uploadedSearchRequest;
                e.InformationSource = InformationSourceType.Request.Value;
                e.Person            = _uploadedPerson;
                e.IsCreatedByAgency = true;
                if (inUpdateProcess)
                {
                    e.UpdateDetails = "New Employment";
                }
                SSG_Employment ssg_employment = await _searchRequestService.CreateEmployment(e, _cancellationToken);

                if (employment.Employer != null)
                {
                    foreach (var phone in employment.Employer.Phones)
                    {
                        EmploymentContactEntity p = _mapper.Map <EmploymentContactEntity>(phone);
                        p.Employment = ssg_employment;
                        if (inUpdateProcess)
                        {
                            e.UpdateDetails = "New EmploymentContact";
                        }
                        await _searchRequestService.CreateEmploymentContact(p, _cancellationToken);
                    }
                }
            }

            _logger.LogInformation("Create employment records for SearchRequest successfully");
            return(true);
        }
Beispiel #3
0
        private async Task <bool> UploadEmployment( )
        {
            if (_foundPerson.Employments == null)
            {
                return(true);
            }
            try
            {
                _logger.LogDebug($"Attempting to create found employment records for SearchRequest[{_searchRequest.SearchRequestId}]");

                foreach (var employment in _foundPerson.Employments)
                {
                    EmploymentEntity e = _mapper.Map <EmploymentEntity>(employment);
                    e.SearchRequest     = _searchRequest;
                    e.InformationSource = _providerDynamicsID;
                    e.Person            = _returnedPerson;
                    SSG_Employment ssg_employment = await _searchRequestService.CreateEmployment(e, _cancellationToken);

                    if (employment.Employer != null)
                    {
                        foreach (var phone in employment.Employer.Phones)
                        {
                            EmploymentContactEntity p = _mapper.Map <EmploymentContactEntity>(phone);
                            p.Employment = ssg_employment;
                            await _searchRequestService.CreateEmploymentContact(p, _cancellationToken);
                        }
                    }

                    await CreateResultTransaction(ssg_employment);
                }
                return(true);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);
                return(false);
            }
        }
Beispiel #4
0
        //this function is never been used.
        private async Task <bool> UpdateEmployment()
        {
            if (_personSought.Employments == null)
            {
                return(true);
            }

            _logger.LogDebug($"Attempting to update employment records for PersonSought.");

            SSG_Employment originalEmployment = _uploadedPerson.SSG_Employments?.FirstOrDefault(
                m => m.InformationSource == InformationSourceType.Request.Value &&
                m.IsCreatedByAgency);

            if (_personSought.Employments.Count() > 0)
            {
                EmploymentEntity employ = _mapper.Map <EmploymentEntity>(_personSought.Employments.ElementAt(0));
                if (originalEmployment == null)
                {
                    await UploadEmployment();
                }
                else
                {
                    IDictionary <string, object> updatedFields = originalEmployment.Clone().GetUpdateEntries(employ);
                    if (updatedFields.ContainsKey("ssg_countrytext")) //country changed
                    {
                        SSG_Country country = await _searchRequestService.GetEmploymentCountry(employ.CountryText, _cancellationToken);

                        updatedFields.Add("ssg_LocationCountry", country);
                    }

                    if (updatedFields.ContainsKey("ssg_countrysubdivision_text")) //subdivision changed
                    {
                        SSG_CountrySubdivision subdivision = await _searchRequestService.GetEmploymentSubdivision(employ.CountrySubdivisionText, _cancellationToken);

                        updatedFields.Add("ssg_CountrySubDivision", subdivision);
                    }

                    if (updatedFields.Count > 0)
                    {
                        await _searchRequestService.UpdateEmployment(originalEmployment.EmploymentId, updatedFields, _cancellationToken);

                        _logger.LogInformation("Update Employment records for SearchRequest successfully");
                    }

                    Employer employer = _personSought.Employments.ElementAt(0).Employer;
                    if (employer != null && employer.Phones != null && employer.Phones.Count() > 0)
                    {
                        SSG_Employment existedEmployment = await _searchRequestService.GetEmployment(originalEmployment.EmploymentId, _cancellationToken);

                        existedEmployment.IsDuplicated = true;
                        foreach (var phone in employer.Phones)
                        {
                            EmploymentContactEntity p = _mapper.Map <EmploymentContactEntity>(phone);
                            p.Employment = existedEmployment;
                            await _searchRequestService.CreateEmploymentContact(p, _cancellationToken);
                        }
                    }
                }
            }
            return(true);
        }