Example #1
0
        public ActionResult ProspectCustomerAbandonedReport(int pageNumber = 1, ProspectCustomerListModelFilter filter = null)
        {
            var filterValidator = IoC.Resolve <ProspectCustomerListModelFilterValidator>();
            var result          = filterValidator.Validate(filter);

            if (result.IsValid)
            {
                if (_sessionContext.UserSession.CurrentOrganizationRole.GetSystemRoleId == (long)Roles.CallCenterRep)
                {
                    filter.AgentOrganizationId = _sessionContext.UserSession.CurrentOrganizationRole.OrganizationId;
                }

                int totalRecords;
                var model = _prospectCustomerService.GetAbandonedCustomers(pageNumber, _pageSize, filter, out totalRecords);
                if (model == null)
                {
                    model = new ProspectCustomerListModel();
                }
                model.Filter = filter;

                var currentAction = ControllerContext.RouteData.Values["action"].ToString();
                //Func<int, string> urlFunc = pn => Url.Action(currentAction, new
                //                                                                {
                //                                                                    pageNumber = pn,
                //                                                                    filter.FromDate,
                //                                                                    filter.ToDate,
                //                                                                    filter.DateType,
                //                                                                    filter.Source,
                //                                                                    filter.Tag,
                //                                                                    filter.Miles,
                //                                                                    filter.Zipcode,
                //                                                                    filter.PhoneNumber,
                //                                                                    filter.StateId,
                //                                                                    filter.City,
                //                                                                    filter.CorporateTag,
                //                                                                    CustomTags = filter.CustomTags.IsNullOrEmpty() ? "" : string.Join("&CustomTags=", filter.CustomTags)
                //                                                                });

                var routeValueDictionary = GetProspectCustomerAbandonedReport(filter);

                Func <int, string> urlFunc = pn => Url.Action(currentAction, AddRouteValueDictionary(routeValueDictionary, pn));


                model.PagingModel = new PagingModel(pageNumber, _pageSize, totalRecords, urlFunc);

                return(View(model));
            }
            var propertyNames = result.Errors.Select(e => e.PropertyName).Distinct();
            var htmlString    = propertyNames.Aggregate("", (current, property) => current + (result.Errors.Where(e => e.PropertyName == property).FirstOrDefault().ErrorMessage + "<br />"));

            return(View(new ProspectCustomerListModel {
                Filter = filter, FeedbackMessage = FeedbackMessageModel.CreateFailureMessage(htmlString)
            }));
        }
        public ActionResult ProspectCustomerAbandonedReportCompleted(string id, ProspectCustomerListModel model)
        {
            if (id == null)
            {
                return(Content("Model can't be null."));
            }

            if (model == null || model.Collection == null || model.Collection.Count() < 1)
            {
                return(Content("Model can't be null."));
            }

            RemoveProcess(id);
            //var exporter = ExportableDataGeneratorProcessManager<ViewModelBase, ModelFilterBase>.GetCsvExporter<ProspectCustomerBasicInfoModel>();
            var message = WriteCsvProspectCustomer("AbandonedProspectCustomer.csv", model.Collection);

            return(Content(message));
        }
        public ListModelBase <ProspectCustomerBasicInfoModel, ProspectCustomerListModelFilter> GetAbandonedCustomers(int pageNumber, int pageSize, ModelFilterBase filter, out int totalRecords)
        {
            var modelFilter = filter as ProspectCustomerListModelFilter;

            if (modelFilter.AgentOrganizationId > 0 && !modelFilter.FromDate.HasValue && !modelFilter.ToDate.HasValue)
            {
                modelFilter.FromDate = DateTime.Today.AddDays(-90);
                modelFilter.DateType = (int)ProspectCustomerDateTypeFilter.CreatedDate;
            }

            var prospectCustomers = _prospectCustomerRepository.GetAbandonedProspectCustomer(pageNumber, pageSize, modelFilter, out totalRecords);
            var model             = new ProspectCustomerListModel();

            if (prospectCustomers != null && prospectCustomers.Any())
            {
                var prospectCustomerNotes = _customerCallNotesRepository.GetProspectCustomerNotes(prospectCustomers.Select(pc => pc.Id).ToArray());

                var orgRoleUserIds = prospectCustomers.Where(pc => pc.ContactedBy.HasValue).Select(pc => pc.ContactedBy.Value).ToList();

                if (prospectCustomerNotes != null && prospectCustomerNotes.Any())
                {
                    orgRoleUserIds.AddRange(prospectCustomerNotes.Select(pcn => pcn.DataRecorderMetaData.DataRecorderCreator.Id));
                }

                orgRoleUserIds = orgRoleUserIds.Distinct().ToList();
                var idNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds.ToArray());

                var customerIds = prospectCustomers.Where(x => x.CustomerId.HasValue && x.CustomerId.Value > 0).Select(x => x.CustomerId.Value);
                var customers   = new List <Customer>();

                if (!customerIds.IsNullOrEmpty())
                {
                    customers = _customerRepository.GetCustomers(customerIds.ToArray());
                }

                var customTags = _corporateCustomerCustomTagRepository.GetByCustomerIds(customerIds);

                var corportateAccounts = new List <CorporateAccount>();

                if (!customers.IsNullOrEmpty())
                {
                    var cutomerTags = customers.Where(x => !string.IsNullOrEmpty(x.Tag) && x.Tag.Trim().Length > 1).Select(x => x.Tag);

                    if (customTags.Any())
                    {
                        corportateAccounts.AddRange(_corporateAccountRepository.GetByTags(cutomerTags.ToArray()));
                    }
                }

                var pcBasicmodels = new ProspectCustomerBasicInfoModel[prospectCustomers.Count()];
                int index         = 0;
                foreach (var prospectCustomer in prospectCustomers)
                {
                    SourceCode sourceCode = null;
                    if (prospectCustomer.SourceCodeId.HasValue)
                    {
                        sourceCode = _sourceCodeRepository.GetSourceCodeById(prospectCustomer.SourceCodeId.Value);
                    }

                    pcBasicmodels[index] = Mapper.Map <ProspectCustomer, ProspectCustomerBasicInfoModel>(prospectCustomer);

                    if (prospectCustomer.CustomerId.HasValue)
                    {
                        if (customers.Any())
                        {
                            var customer = customers.First(x => x.CustomerId == prospectCustomer.CustomerId);

                            pcBasicmodels[index].CorporateTag = string.IsNullOrEmpty(customer.Tag) ? "" : customer.Tag;
                            pcBasicmodels[index].MemberId     = string.IsNullOrEmpty(customer.InsuranceId) ? "" : customer.InsuranceId;


                            if (corportateAccounts.Any() && !string.IsNullOrEmpty(customer.Tag))
                            {
                                var corportateAccount = corportateAccounts.First(x => x.Tag == customer.Tag);
                                pcBasicmodels[index].CorporateSponsor = corportateAccount.Name;
                            }
                        }

                        var corporateCustomTags = string.Empty;
                        if (customTags != null && customTags.Any())
                        {
                            var customerCustomTags =
                                customTags.Where(ct => ct.CustomerId == prospectCustomer.CustomerId).Select(ct => ct.Tag).ToArray();

                            if (customerCustomTags.Any())
                            {
                                corporateCustomTags = string.Join(",", customerCustomTags);
                            }
                        }

                        pcBasicmodels[index].CustomTags = corporateCustomTags;
                        if (!string.IsNullOrEmpty(pcBasicmodels[index].CorporateTag) && string.IsNullOrEmpty(pcBasicmodels[index].CustomTags))
                        {
                            pcBasicmodels[index].CustomTags = "None";
                        }
                    }

                    var notesVieModel = new List <NotesViewModel>();

                    var prospectNotes = _notesViewModelFactory.GetProspectCustomerNotes(prospectCustomer.Id, prospectCustomerNotes, idNamePairs);

                    if (prospectNotes != null)
                    {
                        notesVieModel.AddRange(prospectNotes);
                    }

                    if (prospectCustomer.Tag == ProspectCustomerTag.Cancellation && prospectCustomer.CustomerId.HasValue && _settings.IsRefundQueueEnabled)
                    {
                        var eventCustomers = _eventCustomerRepository.GetbyCustomerId(prospectCustomer.CustomerId.Value);
                        eventCustomers = eventCustomers.Where(ec => !ec.AppointmentId.HasValue);

                        if (eventCustomers.Any())
                        {
                            var eventCustomerId = eventCustomers.Select(ec => ec.Id).Max();
                            if (eventCustomerId > 0)
                            {
                                var orderId        = _orderRepository.GetOrderIdByEventCustomerId(eventCustomerId);
                                var refundRequests = _refundRequestRepository.GetbyOrderId(orderId, true);
                                if (refundRequests != null && refundRequests.Any() && refundRequests.Count(rr => rr.RefundRequestType == RefundRequestType.CustomerCancellation) > 0)
                                {
                                    var refundRequest = refundRequests.LastOrDefault(rr => rr.RefundRequestType == RefundRequestType.CustomerCancellation && rr.RefundRequestResult != null &&
                                                                                     (rr.RefundRequestResult.RequestResultType == RequestResultType.IssueRefund || rr.RefundRequestResult.RequestResultType == RequestResultType.IssueGiftCertificate));

                                    if (refundRequest != null)
                                    {
                                        notesVieModel.Add(new NotesViewModel()
                                        {
                                            Note = refundRequest.RefundRequestResult.Notes
                                        });
                                    }
                                }
                            }
                        }
                    }

                    pcBasicmodels[index].Notes = notesVieModel;

                    if (sourceCode != null)
                    {
                        pcBasicmodels[index].SourceCode = sourceCode.CouponCode;
                    }

                    if (prospectCustomer.ContactedBy.HasValue)
                    {
                        pcBasicmodels[index].ContactedBy =
                            idNamePairs.Where(nip => nip.FirstValue == prospectCustomer.ContactedBy.Value).Select(nip => nip.SecondValue).SingleOrDefault();
                    }
                    index++;
                }
                model.Collection = pcBasicmodels;
            }
            return(model);
        }