Пример #1
0
        public Customer RegisterCorporateCustomer(Customer customer, CorporateCustomerEditModel model, string tag, OrganizationRoleUser createdByOrgRoleUser, IEnumerable <Language> languages,
                                                  IEnumerable <Lab> labs, StringBuilder sb, long activityTypeId, long?source, out bool isNewCustomer)
        {
            //if (customerWithAcesId != null && customer == null)
            //{
            //    throw new Exception("Aces Id can not be duplicate, Aces Id : " + model.AcesId + " already assigned.");
            //}

            //if (customerWithAcesId != null && customer != null && customerWithAcesId.CustomerId != customer.CustomerId)
            //{
            //    throw new Exception("Aces Id can not be duplicate, Aces Id : " + model.AcesId + " already assigned.");
            //}

            //if (customer == null && (sb != null && sb.ToString() != ""))
            //{
            //    throw new Exception("");
            //}
            //else
            //{
            //    sb = new StringBuilder();
            //}

            var language = GetLanguage(model, createdByOrgRoleUser, languages);
            var lab      = GetLab(model, createdByOrgRoleUser, labs);

            var previousIncorrectPhoneNumberStatus = customer != null && customer.IsIncorrectPhoneNumber;

            var customerOldCellNumber = (customer != null && customer.MobilePhoneNumber != null) ? PhoneNumber.Create(PhoneNumber.ToNumber(customer.MobilePhoneNumber.ToString()), PhoneNumberType.Mobile).ToString() : string.Empty;
            var customerOldHomeNumber = (customer != null && customer.HomePhoneNumber != null) ? PhoneNumber.Create(PhoneNumber.ToNumber(customer.HomePhoneNumber.ToString()), PhoneNumberType.Home).ToString() : string.Empty;

            customer = _massRegistrationEditModelFactory.CreateCustomer(model, tag, createdByOrgRoleUser, customer, language, lab, activityTypeId, source);

            var oldCustomerId = customer.CustomerId;

            var currentIncorrectPhoneNumberStatus = customer.IsIncorrectPhoneNumber;

            _customerService.SaveCustomer(customer, createdByOrgRoleUser.Id);

            isNewCustomer = customer.CustomerId > 0 && oldCustomerId != customer.CustomerId;

            var customerNewCellNumber = (customer.MobilePhoneNumber != null) ? PhoneNumber.Create(PhoneNumber.ToNumber(customer.MobilePhoneNumber.ToString()), PhoneNumberType.Mobile).ToString() : string.Empty;
            var customerNewHomeNumber = (customer.HomePhoneNumber != null) ? PhoneNumber.Create(PhoneNumber.ToNumber(customer.HomePhoneNumber.ToString()), PhoneNumberType.Home).ToString() : string.Empty;

            if (previousIncorrectPhoneNumberStatus && !currentIncorrectPhoneNumberStatus)
            {
                _logger.Info("customer Id: " + customer.CustomerId + " and Old Cell Number: " + customerOldCellNumber + "  New Cell Number: " + customerNewCellNumber);
                _logger.Info("customer Id: " + customer.CustomerId + " and Old Home Number: " + customerOldHomeNumber + "  New Home Number: " + customerNewHomeNumber);

                _customerNotesService.SavePhoneNumberUpdatedMessage(customer.CustomerId, createdByOrgRoleUser.Id);
            }


            //always save eligibility after saving customer , because history is maintained by SaveCustomer/SaveCustomerOnly function.
            //Here Eligibility is updated within function coded below
            _corporateCustomerUploadService.UpdateCustomerData(model, createdByOrgRoleUser, customer, _logger);

            return(customer);
        }
        public bool UpdateCustomerData(CallQueueCustomerEditModel model, long createdByOrgRoleUserId)
        {
            if (model.CustomerId > 0)
            {
                var customer = _customerRepository.GetCustomer(model.CustomerId);
                var previousIncorrectPhoneNumberStatus = customer.IsIncorrectPhoneNumber;

                customer.Name.FirstName = model.FirstName;
                customer.Name.LastName  = model.LastName;
                var address = _addressService.SaveAfterSanitizing(Mapper.Map <AddressEditModel, Address>(model.Address));

                if (customer.Address != null && customer.Address.Id > 0)
                {
                    address.Id = customer.Address.Id;
                }
                customer.Address = address;

                string officePhoneNumber = PhoneNumber.Create(model.OfficePhoneNumber, PhoneNumberType.Office).ToString();
                string mobilePhoneNumber = PhoneNumber.Create(model.MobilePhoneNumber, PhoneNumberType.Mobile).ToString();
                string homePhoneNumber   = PhoneNumber.Create(model.CallBackPhoneNumber, PhoneNumberType.Home).ToString();

                if ((customer.OfficePhoneNumber != null && customer.OfficePhoneNumber.ToString() != officePhoneNumber) ||
                    (customer.MobilePhoneNumber != null && customer.MobilePhoneNumber.ToString() != mobilePhoneNumber) ||
                    (customer.HomePhoneNumber != null && customer.HomePhoneNumber.ToString() != homePhoneNumber))
                {
                    customer.IsIncorrectPhoneNumber         = false;
                    customer.IncorrectPhoneNumberMarkedDate = null;
                }

                var currentIncorrectPhoneNumberStatus = customer.IsIncorrectPhoneNumber;

                customer.OfficePhoneNumber = PhoneNumber.Create(model.OfficePhoneNumber, PhoneNumberType.Office);
                customer.MobilePhoneNumber = PhoneNumber.Create(model.MobilePhoneNumber, PhoneNumberType.Mobile);
                customer.HomePhoneNumber   = PhoneNumber.Create(model.CallBackPhoneNumber, PhoneNumberType.Home);

                customer.Hicn = model.Hicn;
                customer.Mbi  = model.Mbi;

                customer.InsuranceId = model.MemberId;
                //customer.IsEligible = model.EligibleStatus;
                customer.ActivityId = model.ActivityId > 0 ? model.ActivityId : (long?)null;

                customer.Email = null;
                if (!string.IsNullOrEmpty(model.Email))
                {
                    customer.Email = new Email(model.Email);
                }

                //else if (!string.IsNullOrEmpty(customer.Email.ToString()) && string.IsNullOrEmpty(model.Email))
                //{
                //    customer.Email = null;
                //}

                customer.AlternateEmail = null;

                if (!string.IsNullOrEmpty(model.AlternateEmail))
                {
                    customer.AlternateEmail = new Email(model.AlternateEmail);
                }


                customer.DateOfBirth = model.DateOfBirth;

                customer.Gender      = (Gender)model.Gender;
                customer.EnableEmail = model.EnableEmail;

                _customerService.SaveCustomer(customer, createdByOrgRoleUserId);

                if (previousIncorrectPhoneNumberStatus && !currentIncorrectPhoneNumberStatus)
                {
                    _customerNotesService.SavePhoneNumberUpdatedMessage(customer.CustomerId, createdByOrgRoleUserId);
                }
            }

            ProspectCustomer prospectCustomer = null;

            if (model.ProspectCustomerId > 0)
            {
                prospectCustomer = _prospectCustomerRepository.GetProspectCustomer(model.ProspectCustomerId);
            }
            else if (model.CustomerId > 0)
            {
                prospectCustomer = _prospectCustomerRepository.GetProspectCustomerByCustomerId(model.CustomerId);
            }

            if (prospectCustomer == null)
            {
                return(true);
            }

            prospectCustomer.FirstName = model.FirstName;
            prospectCustomer.LastName  = model.LastName;

            if (model.Gender > 0)
            {
                prospectCustomer.Gender = (Gender)model.Gender;
            }
            prospectCustomer.BirthDate = model.DateOfBirth;

            prospectCustomer.Email = string.IsNullOrEmpty(model.Email) ? null : new Email(model.Email);

            prospectCustomer.CallBackPhoneNumber = PhoneNumber.Create(model.CallBackPhoneNumber, PhoneNumberType.Home);

            if (model.Address != null)
            {
                prospectCustomer.Address.StreetAddressLine1 = model.Address.StreetAddressLine1;
                prospectCustomer.Address.StreetAddressLine2 = model.Address.StreetAddressLine2;
                if (model.Address.StateId > 0)
                {
                    var state = _stateRepository.GetState(model.Address.StateId);
                    prospectCustomer.Address.State = state.Name;
                }

                if (!string.IsNullOrEmpty(model.Address.City))
                {
                    prospectCustomer.Address.City = model.Address.City;
                }
                prospectCustomer.Address.ZipCode = new ZipCode(model.Address.ZipCode);
            }

            ((IUniqueItemRepository <ProspectCustomer>)_prospectCustomerRepository).Save(prospectCustomer);

            return(true);
        }
Пример #3
0
        public void PollForPhoneNumberUpdate()
        {
            _logger.Info("Starting Customer Phone Number Update Service : DateTime :" + DateTime.Now);
            var uploadedFilesInfo = _customerPhoneNumberUpdateUploadRepository.GetUploadedFilesInfo();

            var phoneNumberUpdateFilesLocation = _mediaRepository.GetCustomerPhoneNumberUploadLocation();

            if (uploadedFilesInfo.IsNullOrEmpty())
            {
                _logger.Info("No new Files Uploaded");
                return;
            }

            foreach (var uploadFileInfo in uploadedFilesInfo)    //parsing all Uploaded Status Files
            {
                var failedRecords = new StringBuilder();
                failedRecords.Append(LogHeader + Environment.NewLine);
                var successCount = 0L;

                try
                {
                    var fileInfo = GetFile(uploadFileInfo.FileId);
                    if (!System.IO.File.Exists(phoneNumberUpdateFilesLocation.PhysicalPath + fileInfo.Path))
                    {
                        uploadFileInfo.StatusId = (long)PhoneNumberUploadStatus.FileNotFound;
                        _customerPhoneNumberUpdateUploadRepository.Save(uploadFileInfo);

                        _logger.Info("File not found : " + phoneNumberUpdateFilesLocation.PhysicalPath + fileInfo.Path);
                        continue;
                    }
                    _logger.Info("Importing File : " + fileInfo.Path);

                    uploadFileInfo.StatusId       = (long)PhoneNumberUploadStatus.Parsing;
                    uploadFileInfo.ParseStartTime = DateTime.Now;
                    _customerPhoneNumberUpdateUploadRepository.Save(uploadFileInfo);

                    DataTable table = _csvReader.CsvToDataTable(phoneNumberUpdateFilesLocation.PhysicalPath + fileInfo.Path, true);

                    if (table.Rows.Count <= 0)
                    {
                        _logger.Info("No rows found in File : " + fileInfo.Path + " having FileId :" + uploadFileInfo.FileId);
                        uploadFileInfo.ParseEndTime = DateTime.Now;

                        uploadFileInfo.StatusId = (long)PhoneNumberUploadStatus.ParseFailed;
                        _customerPhoneNumberUpdateUploadRepository.Save(uploadFileInfo);
                        continue;
                    }

                    foreach (DataRow row in table.Rows)         //Parsing Records in File
                    {
                        var errorRow             = "";
                        var phoneNumberUploadLog = new CustomerPhoneNumberUpdateUploadLog();
                        try
                        {
                            var  customerId           = 0L;
                            var  phoneNumber          = "";
                            var  phoneNumberType      = "";
                            var  phoneNumberDomain    = new PhoneNumber();
                            var  customer             = new Customer();
                            bool isCustomerIdProvided = false;

                            var model = GetPhoneNumberUpdateLogModel(row);
                            errorRow = model.CustomerId + "," +
                                       model.FirstName + "," +
                                       model.LastName + "," +
                                       model.DOB + "," +
                                       model.MemberId + "," +
                                       model.PhoneNumber + "," +
                                       model.PhoneType;

                            GetFileRowForLog(phoneNumberUploadLog, model, uploadFileInfo.Id);

                            #region CustomerId
                            try                 //CustomerId
                            {
                                if (!string.IsNullOrEmpty(model.CustomerId))
                                {
                                    Int64.TryParse(model.CustomerId, out customerId);
                                    if (customerId == 0)
                                    {
                                        const string errorMessage = "Invalid Customer Id";
                                        SaveUploadLogToDb(phoneNumberUploadLog, errorMessage);

                                        failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                        continue;
                                    }
                                    isCustomerIdProvided = true;
                                }
                            }
                            catch (Exception ex)
                            {
                                const string errorMessage = "Error importing CustomerId";
                                SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                _logger.Error(errorMessage);
                                _logger.Error("Message: " + ex.Message + "\nStack Trace; " + ex.StackTrace);
                                failedRecords.Append(errorRow + "," + "CustomerId Invalid" + Environment.NewLine);
                                continue;
                            }
                            #endregion

                            if (!isCustomerIdProvided)
                            {
                                if (string.IsNullOrEmpty(model.FirstName) || string.IsNullOrEmpty(model.LastName) ||
                                    string.IsNullOrEmpty(model.DOB) || string.IsNullOrEmpty(model.MemberId))
                                {
                                    const string errorMessage = "Incomplete customer data.";
                                    SaveUploadLogToDb(phoneNumberUploadLog, errorMessage);

                                    failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                    continue;
                                }
                            }

                            #region PhoneNumber
                            try                 //PhoneNumber
                            {
                                phoneNumber = ToNumber(model.PhoneNumber);
                                if (string.IsNullOrEmpty(phoneNumber))
                                {
                                    const string errorMessage = "Invalid phone number";
                                    SaveUploadLogToDb(phoneNumberUploadLog, errorMessage);

                                    failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                    continue;
                                }
                            }
                            catch (Exception ex)
                            {
                                const string errorMessage = "Error importing PhoneNumber";
                                SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                failedRecords.Append(errorRow + "," + "Invalid Phone Number" + Environment.NewLine);

                                _logger.Error(errorMessage);
                                _logger.Error("Message: " + ex.Message + "\nStack Trace; " + ex.StackTrace);
                                continue;
                            }

                            #endregion

                            #region PhoneNumberType
                            try                 //Phone Type (requirement was for only Home and Cell phone numbers)
                            {
                                phoneNumberType = model.PhoneType;
                                if (string.IsNullOrEmpty(phoneNumberType))
                                {
                                    const string errorMessage = "Phone type should be Home or Cell";
                                    SaveUploadLogToDb(phoneNumberUploadLog, errorMessage);

                                    failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                    continue;
                                }

                                if (phoneNumberType.ToLower() != _phoneTypeHome.ToLower() && phoneNumberType.ToLower() != _phoneTypeCell.ToLower())
                                {
                                    const string errorMessage = "Phone type should be Home or Cell";
                                    SaveUploadLogToDb(phoneNumberUploadLog, errorMessage);

                                    failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                    continue;
                                }
                            }
                            catch (Exception ex)
                            {
                                const string errorMessage = "Error importing PhoneType";
                                SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                failedRecords.Append(errorRow + "," + "Phone type should be Home or Cell" + Environment.NewLine);

                                _logger.Error(errorMessage);
                                _logger.Error("Message: " + ex.Message + "\nStack Trace; " + ex.StackTrace);
                                continue;
                            }

                            #endregion

                            #region CreatePhoneNumber
                            // Creating Phone Number
                            try
                            {
                                var phoneNumberTypeEnumValue = (phoneNumberType.ToLower() == _phoneTypeHome.ToLower()) ? PhoneNumberType.Home : PhoneNumberType.Mobile;
                                phoneNumberDomain = _phoneNumberFactory.CreatePhoneNumber(phoneNumber, phoneNumberTypeEnumValue);

                                if (phoneNumberDomain.PhoneNumberType == PhoneNumberType.Unknown)
                                {
                                    const string errorMessage = "Phone number not valid";
                                    SaveUploadLogToDb(phoneNumberUploadLog, errorMessage);

                                    failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                    continue;
                                }
                            }
                            catch (Exception ex)
                            {
                                const string errorMessage = "Error while Creating PhoneNumberDomain";
                                SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                failedRecords.Append(errorRow + "," + "Phone number not valid" + Environment.NewLine);

                                _logger.Error(errorMessage);
                                _logger.Error("Message: " + ex.Message + "\nStack Trace; " + ex.StackTrace);
                                continue;
                            }

                            #endregion

                            #region Get Customer
                            try
                            {
                                var dob = new DateTime();
                                if (isCustomerIdProvided)
                                {
                                    customer = _customerRepository.GetCustomer(customerId);
                                }
                                else
                                {
                                    try
                                    {
                                        dob = Convert.ToDateTime(model.DOB);
                                    }
                                    catch (Exception ex)
                                    {
                                        const string errorMessage = "Invalid date format";
                                        SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                        failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                        continue;
                                    }

                                    try
                                    {
                                        customer = _customerRepository.GetCustomerForPhoneNumberUpdate(model.FirstName, model.LastName, dob, model.MemberId);
                                    }
                                    catch (Exception ex)
                                    {
                                        const string errorMessage = "No record present for this data.";
                                        SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                        failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                        continue;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                const string errorMessage = "No record present for this CustomerId";
                                SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                failedRecords.Append(errorRow + "," + errorMessage + Environment.NewLine);
                                continue;
                            }
                            #endregion

                            #region Saving Data
                            try
                            {
                                var shouldSaveNotes = customer.IsIncorrectPhoneNumber;
                                if (phoneNumberType.ToLower() == _phoneTypeHome.ToLower())
                                {
                                    customer.HomePhoneNumber = phoneNumberDomain;
                                }
                                else
                                {
                                    customer.MobilePhoneNumber = phoneNumberDomain;
                                }
                                customer.IsIncorrectPhoneNumber         = false;
                                customer.IncorrectPhoneNumberMarkedDate = null;

                                //saves CustomerProfile and Creates History and Updates CallQueueCustomer
                                _customerService.SaveCustomer(customer, uploadFileInfo.UploadedByOrgRoleUserId);

                                if (shouldSaveNotes)
                                {
                                    _customerNotesService.SavePhoneNumberUpdatedMessage(customer.CustomerId, uploadFileInfo.UploadedByOrgRoleUserId);
                                }

                                SaveUploadLogToDb(phoneNumberUploadLog, "");        //Log Success
                                successCount++;
                            }
                            catch (Exception ex)
                            {
                                const string errorMessage = "Error while saving Details";
                                SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                                failedRecords.Append(errorRow + "," + "Save Failed" + Environment.NewLine);

                                _logger.Error(errorMessage);
                                _logger.Error("Message: " + ex.Message + "\nStack Trace; " + ex.StackTrace);
                                continue;
                            }
                            #endregion
                        }
                        catch (Exception ex)
                        {
                            const string errorMessage = "Some Error Occurred";
                            SaveUploadLogToDb(phoneNumberUploadLog, errorMessage + " Exception Message: " + ex.Message);

                            failedRecords.Append(errorRow + "," + "Save Failed" + Environment.NewLine);

                            _logger.Error(errorMessage);
                            _logger.Error("Message: " + ex.Message + "\nStack Trace; " + ex.StackTrace);
                            continue;
                        }
                    }

                    if (successCount < table.Rows.Count)
                    {
                        var logFileName = "FailRecords_" + fileInfo.Path;
                        var logFile     = SaveLogFile(phoneNumberUpdateFilesLocation.PhysicalPath + logFileName, failedRecords);
                        uploadFileInfo.LogFileId = logFile.Id;
                    }

                    uploadFileInfo.SuccessUploadCount = successCount;
                    uploadFileInfo.FailedUploadCount  = table.Rows.Count - successCount;
                    uploadFileInfo.ParseEndTime       = DateTime.Now;
                    uploadFileInfo.StatusId           = successCount > 0 ? (long)PhoneNumberUploadStatus.Parsed : (long)PhoneNumberUploadStatus.ParseFailed;
                    _customerPhoneNumberUpdateUploadRepository.Save(uploadFileInfo);
                }
                catch (Exception ex)
                {
                    uploadFileInfo.StatusId = (long)PhoneNumberUploadStatus.ParseFailed;
                    _customerPhoneNumberUpdateUploadRepository.Save(uploadFileInfo);
                    _logger.Error("Parse Failed while parsing File , FileId:" + uploadFileInfo.FileId);
                    _logger.Error("Ex Message" + ex.Message);
                    _logger.Error("Ex Stack Trace " + ex.StackTrace);
                }
            }
        }