Exemplo n.º 1
0
        public void PollForHealthPlanUncontactedCustomer()
        {
            try
            {
                _logger.Info("Entering Health Plan Uncontacted Customers Polling Agent For 24 hrs");
                var callQueue   = _callQueueRepository.GetCallQueueByCategory(HealthPlanCallQueueCategory.UncontactedCustomers);
                var healthPlans = _corporateAccountRepository.GetAllHealthPlan();

                if (callQueue != null)
                {
                    // _callQueueCustomerRepository.DeleteCallQueueCustomersHasNotBeenCalled(callQueue.Id);

                    var criteria = _healthPlanCallQueueCriteria.GetQueueCriteriasByQueueId(callQueue.Id);

                    criteria = criteria.Where(x => x.IsQueueGenerated);

                    foreach (var queueCriteria in criteria)
                    {
                        try
                        {
                            _healthPlanCallQueueAssignmentRepository.DeleteByCriteriaId(queueCriteria.Id);
                            //if (queueCriteria.IsDefault)
                            //{
                            //    foreach (var corporateAccount in healthPlans)
                            //    {
                            //        _healthPlanCallRoundService.SaveHealthPlanUncontactedCustomerCallQueue(corporateAccount, queueCriteria, callQueue, _logger);
                            //    }
                            //}
                            //else
                            if (queueCriteria.HealthPlanId.HasValue && !healthPlans.IsNullOrEmpty())
                            {
                                var corporateAccount = healthPlans.First(x => x.Id == queueCriteria.HealthPlanId.Value);
                                _healthPlanCallRoundService.SaveHealthPlanUncontactedCustomerCallQueue(corporateAccount, queueCriteria, callQueue, _logger);
                            }

                            queueCriteria.IsQueueGenerated       = true;
                            queueCriteria.LastQueueGeneratedDate = DateTime.Now;
                            _healthPlanCallQueueCriteria.Save(queueCriteria);
                        }
                        catch (Exception exception)
                        {
                            _logger.Error("call Queue Id " + callQueue.Id);
                            _logger.Error("criteria Id " + queueCriteria.Id);
                            _logger.Error("Message " + exception.Message);
                            _logger.Error("Stack Trace " + exception.StackTrace);
                        }
                    }
                }
            }
            catch (Exception exception)
            {
                _logger.Error(string.Format("Message {0} stack trace: {1} ", exception.Message, exception.StackTrace));
            }
        }
Exemplo n.º 2
0
        public void PollForQueueGeneration()
        {
            try
            {
                _logger.Info("Entering Health Plan Confirmation Queue Polling Agent For 24 hrs.");
                var callQueue   = _callQueueRepository.GetCallQueueByCategory(HealthPlanCallQueueCategory.AppointmentConfirmation);
                var criterias   = _healthPlanCallQueueCriteriaRepository.GetQueueCriteriasByQueueId(callQueue.Id);
                var healthPlans = _corporateAccountRepository.GetAllHealthPlan();

                foreach (var criteria in criterias)
                {
                    try
                    {
                        _healthPlanCallQueueAssignmentRepository.DeleteByCriteriaId(criteria.Id);

                        if (criteria.HealthPlanId.HasValue)
                        {
                            var healthPlan = healthPlans.FirstOrDefault(x => x.Id == criteria.HealthPlanId);

                            if (healthPlan != null)
                            {
                                _healthPlanCallRoundService.SaveHealthPlanConfirmationCustomerCallQueue(healthPlan, criteria, callQueue, _logger);
                            }

                            criteria.IsQueueGenerated       = true;
                            criteria.LastQueueGeneratedDate = DateTime.Now;
                            _healthPlanCallQueueCriteriaRepository.Save(criteria);
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Error(string.Format("Error generating confirmation queue for HealthPlanId: {0} CallQueueId: {1} CriteriaId : {2}", criteria.HealthPlanId, callQueue.Id, criteria.Id));
                        _logger.Error(string.Format("Message : {0} \nStack Trace : {1}", ex.Message, ex.StackTrace));
                    }
                }

                _logger.Info("Completed Health Plan Confirmation Queue Polling Agent For 24 hrs.");
            }
            catch (Exception ex)
            {
                _logger.Error(string.Format("Message {0} stack trace: {1} ", ex.Message, ex.StackTrace));
            }
        }
Exemplo n.º 3
0
        public void PollforRegenerateLanguageBarrierCallQueue()
        {
            try
            {
                _logger.Info("Entering Single Health Plan Language Barrier Polling Agent");

                var callQueue   = _callQueueRepository.GetCallQueueByCategory(HealthPlanCallQueueCategory.LanguageBarrier);
                var healthPlans = _corporateAccountRepository.GetAllHealthPlan();

                if (callQueue != null)
                {
                    var criteria = _healthPlanCallQueueCriteria.GetQueueCriteriasByQueueId(callQueue.Id);

                    criteria = criteria.Where(x => !x.IsQueueGenerated && !x.IsDefault);

                    foreach (var queueCriteria in criteria)
                    {
                        _healthPlanCallQueueAssignmentRepository.DeleteByCriteriaId(queueCriteria.Id);

                        if (queueCriteria.HealthPlanId.HasValue && !healthPlans.IsNullOrEmpty())
                        {
                            var corporateAccount = healthPlans.First(x => x.Id == queueCriteria.HealthPlanId.Value);
                            _healthPlanCallRoundService.SaveHealthPlanLanguageBarrierCustomerCallQueue(corporateAccount, queueCriteria, callQueue, _logger);
                        }

                        queueCriteria.IsQueueGenerated       = true;
                        queueCriteria.LastQueueGeneratedDate = DateTime.Now;
                        _healthPlanCallQueueCriteria.Save(queueCriteria);
                    }
                }

                _logger.Info("Completing Single Health Plan Language Barrier Polling Agent");
            }
            catch (Exception exception)
            {
                _logger.Error("Error while regenration");
                _logger.Error(string.Format("Message {0} stack trace: {1} ", exception.Message, exception.StackTrace));
            }
        }
        public void PollForHealthPlanCallQueue()
        {
            try
            {
                var callQueue = _callQueueRepository.GetCallQueueByCategory(HealthPlanCallQueueCategory.FillEventsHealthPlan);

                var healthPlans = _corporateAccountRepository.GetAllHealthPlan();
                _logger.Info("Started Healthfair Fill Event call Queue For Generated Call Queues For 24 hrs");

                if (callQueue != null)
                {
                    try
                    {
                        var criteria = _healthPlanCallQueueCriteria.GetQueueCriteriasByQueueId(callQueue.Id);
                        criteria = criteria.Where(x => x.IsQueueGenerated).OrderByDescending(x => x.Id);

                        foreach (var queueCriteria in criteria)
                        {
                            try
                            {
                                _healthPlanCallQueueAssignment.DeleteByCriteriaId(queueCriteria.Id);
                                _healthPlanFillEventCallQueueRepository.DeleteByCriteriaId(queueCriteria.Id);

                                //if (queueCriteria.IsDefault)
                                //{
                                //    foreach (var corporateAccount in healthPlans)
                                //    {
                                //        _healthPlanCallRoundService.SaveHealthPlanFillEventCallQueueCustomers(corporateAccount, queueCriteria, callQueue, _logger);
                                //    }
                                //}
                                //else

                                if (queueCriteria.HealthPlanId.HasValue && !healthPlans.IsNullOrEmpty())
                                {
                                    var corporateAccount = healthPlans.First(x => x.Id == queueCriteria.HealthPlanId.Value);

                                    _healthPlanCallRoundService.SaveHealthPlanFillEventCallQueueCustomers(corporateAccount, queueCriteria, callQueue, _logger);
                                }

                                queueCriteria.IsQueueGenerated       = true;
                                queueCriteria.LastQueueGeneratedDate = DateTime.Now;
                                _healthPlanCallQueueCriteria.Save(queueCriteria);
                            }
                            catch (Exception ex)
                            {
                                _logger.Error(string.Format("error health plan call queue. callQueueId: {0} CriteriaId {1} ", callQueue.Id, queueCriteria.Id));
                                _logger.Error(string.Format("Message {0} stack trace: {1} ", ex.Message, ex.StackTrace));
                            }
                        }
                    }
                    catch (Exception exception)
                    {
                        _logger.Error(string.Format("error health plan call queue. callQueueId: {0} ", callQueue.Id));
                        _logger.Error(string.Format("Message {0} stack trace: {1} ", exception.Message, exception.StackTrace));
                    }
                    callQueue.IsQueueGenerated       = true;
                    callQueue.LastQueueGeneratedDate = DateTime.Now;
                    _callQueueRepository.Save(callQueue);
                }
            }
            catch (Exception exception)
            {
                _logger.Error(string.Format("error health plan call queue."));
                _logger.Error(string.Format("Message {0} stack trace: {1} ", exception.Message, exception.StackTrace));
            }
        }
        public void PollForHealthPlanCallQueue()
        {
            try
            {
                _logger.Info("Entering Health Plan Polling Agent To Generate Call Queue For CallRound, NoShows and ZipRadius");

                var callQueues  = _callQueueRepository.GetAll(false, true);
                var healthPlans = _corporateAccountRepository.GetAllHealthPlan();

                if (!callQueues.IsNullOrEmpty())
                {
                    callQueues = callQueues.Where(x => x.Category != HealthPlanCallQueueCategory.FillEventsHealthPlan && x.Category != HealthPlanCallQueueCategory.UncontactedCustomers &&
                                                  x.Category != HealthPlanCallQueueCategory.MailRound);

                    foreach (var callQueue in callQueues)
                    {
                        try
                        {
                            var criteria = _healthPlanCallQueueCriteria.GetQueueCriteriasByQueueId(callQueue.Id);
                            criteria = criteria.Where(x => x.IsQueueGenerated);

                            switch (callQueue.Category)
                            {
                            case HealthPlanCallQueueCategory.CallRound:
                            {
                                foreach (var queueCriteria in criteria)
                                {
                                    try
                                    {
                                        _healthPlanCallQueueAssignment.DeleteByCriteriaId(queueCriteria.Id);

                                        if (queueCriteria.HealthPlanId.HasValue && !healthPlans.IsNullOrEmpty())
                                        {
                                            var corporateAccount = healthPlans.First(x => x.Id == queueCriteria.HealthPlanId.Value);
                                            _healthPlanCallRoundService.SaveCallRoundCallQueueCustomers(corporateAccount, queueCriteria, callQueue, _logger);
                                        }
                                        queueCriteria.IsQueueGenerated       = true;
                                        queueCriteria.LastQueueGeneratedDate = DateTime.Now;
                                        _healthPlanCallQueueCriteria.Save(queueCriteria);
                                    }
                                    catch (Exception exception)
                                    {
                                        _logger.Error("call Queue Id " + callQueue.Id);
                                        _logger.Error("criteria Id " + queueCriteria.Id);
                                        _logger.Error("Message " + exception.Message);
                                        _logger.Error("Stack Trace " + exception.StackTrace);
                                    }
                                }
                            }
                            break;

                                //case HealthPlanCallQueueCategory.NoShows:
                                //    {
                                //        foreach (var queueCriteria in criteria)
                                //        {
                                //            try
                                //            {
                                //                _healthPlanCallQueueAssignment.DeleteByCriteriaId(queueCriteria.Id);

                                //                if (queueCriteria.HealthPlanId.HasValue && !healthPlans.IsNullOrEmpty())
                                //                {
                                //                    var corporateAccount = healthPlans.First(x => x.Id == queueCriteria.HealthPlanId.Value);
                                //                    _healthPlanCallRoundService.SaveNoShowCallQueueCustomers(corporateAccount, queueCriteria, callQueue, _logger);
                                //                }
                                //                queueCriteria.IsQueueGenerated = true;
                                //                queueCriteria.LastQueueGeneratedDate = DateTime.Now;
                                //                _healthPlanCallQueueCriteria.Save(queueCriteria);
                                //            }
                                //            catch (Exception exception)
                                //            {
                                //                _logger.Error("call Queue Id " + callQueue.Id);
                                //                _logger.Error("criteira Id " + queueCriteria.Id);
                                //                _logger.Error("Message " + exception.Message);
                                //                _logger.Error("Stack Trace " + exception.StackTrace);
                                //            }

                                //        }
                                //    }
                                //    break;
                                //case HealthPlanCallQueueCategory.ZipRadius:
                                //    {
                                //        foreach (var queueCriteria in criteria)
                                //        {
                                //            _healthPlanCallQueueAssignment.DeleteByCriteriaId(queueCriteria.Id);

                                //            if (queueCriteria.IsDefault)
                                //            {
                                //                foreach (var corporateAccount in healthPlans)
                                //                {
                                //                    _healthPlanCallRoundService.SaveHealthPlanZipRadiusCallQueueCustomers(corporateAccount, queueCriteria, callQueue, _logger);
                                //                }
                                //            }
                                //            else if (queueCriteria.HealthPlanId.HasValue && !healthPlans.IsNullOrEmpty())
                                //            {
                                //                var corporateAccount = healthPlans.First(x => x.Id == queueCriteria.HealthPlanId.Value);
                                //                _healthPlanCallRoundService.SaveHealthPlanZipRadiusCallQueueCustomers(corporateAccount, queueCriteria, callQueue, _logger);
                                //            }
                                //            queueCriteria.IsQueueGenerated = true;
                                //            queueCriteria.LastQueueGeneratedDate = DateTime.Now;
                                //            _healthPlanCallQueueCriteria.Save(queueCriteria);
                                //        }
                                //    }
                                //    break;
                            }
                        }
                        catch (Exception exception)
                        {
                            _logger.Error(string.Format("error health plan call queue. callQueueId: {0} ", callQueue.Id));
                            _logger.Error(string.Format("Message {0} stack trace: {1} ", exception.Message, exception.StackTrace));
                        }
                        callQueue.IsQueueGenerated       = true;
                        callQueue.LastQueueGeneratedDate = DateTime.Now;
                        _callQueueRepository.Save(callQueue);
                    }
                }
            }
            catch (Exception exception)
            {
                _logger.Error(string.Format("error health plan call queue."));
                _logger.Error(string.Format("Message {0} stack trace: {1} ", exception.Message, exception.StackTrace));
            }
        }