public HospitalPartnerDashboardViewModel GetHospitalPartnerDashboardModel(long hospitalPartnerId)
{
var hospitalPartner = _hospitalPartnerRepository.GetHospitalPartnerforaVendor(hospitalPartnerId);
var eventIds = _hospitalPartnerRepository.GetEventIdsForHospitalPartner(hospitalPartnerId);
if (eventIds.IsNullOrEmpty())
{
return(new HospitalPartnerDashboardViewModel());
}
var reccentContactedEventId = _hospitalPartnerCustomerRepository.GetMostRecentContactedEvent(hospitalPartnerId);
var recentMailedEvents = _shippingDetailRepository.GetRecentMailedHospitalPartnerEvents(hospitalPartnerId).ToList();
var recentCriticalCustomers =
_eventCustomerResultRepository.GetRecentCriticalAndUrgentCustomersForHospitalPartner(hospitalPartnerId, 1, 8, hospitalPartner.CriticalResultValidityPeriod);
var getEventIds = recentMailedEvents.Count() > 0 ? recentMailedEvents.Select(me => me.FirstValue).ToList() : new List <long>();
if (reccentContactedEventId > 0)
{
getEventIds.Add(reccentContactedEventId);
}
IEnumerable <Customer> customers = null;
IEnumerable <Event> events = null;
IEnumerable <Host> hosts = null;
IEnumerable <CustomerResultStatusViewModel> customerResultStatusViewModels = null;
if (recentCriticalCustomers != null && recentCriticalCustomers.Count() > 0)
{
getEventIds.AddRange(recentCriticalCustomers.Select(rcc => rcc.EventId).ToArray());
customers = _customerRepository.GetCustomers(recentCriticalCustomers.Select(rcc => rcc.CustomerId).ToArray());
customerResultStatusViewModels = _eventCustomerResultRepository.GetTestResultStatus(recentCriticalCustomers.Select(rcc => rcc.Id).ToArray());
}
if (getEventIds.Count > 0)
{
events = _eventRepository.GetEventswithPodbyIds(getEventIds.ToArray());
hosts = _hostRepository.GetEventHosts(events.Select(e => e.Id).ToArray());
}
var totalCustomers = _eventRepository.GetCustomersWithAppointmentByHospitalPartnerId(hospitalPartnerId);
var customersAttended = _eventRepository.GetAttendedCustomersByHospitalPartnerId(hospitalPartnerId);
var normalCustomers = _eventCustomerResultRepository.GetResultSummaryEventIdCustomersCountForHospitalPartner(hospitalPartnerId, ResultInterpretation.Normal, true, hospitalPartner.NormalResultValidityPeriod);
var abnormalCustomers = _eventCustomerResultRepository.GetResultSummaryEventIdCustomersCountForHospitalPartner(hospitalPartnerId, ResultInterpretation.Abnormal, true, hospitalPartner.AbnormalResultValidityPeriod);
var criticalCustomers = _eventCustomerResultRepository.GetCriticalEventIdCustomersCountForHospitalPartner(hospitalPartnerId, ResultInterpretation.Critical, true, hospitalPartner.CriticalResultValidityPeriod);
var urgentCustomers = _eventCustomerResultRepository.GetResultSummaryEventIdCustomersCountForHospitalPartner(hospitalPartnerId, ResultInterpretation.Urgent, true, hospitalPartner.CriticalResultValidityPeriod);
var mailedDate = _shippingDetailRepository.MailedDateForEvent(reccentContactedEventId);
return(_hospitalPartnerViewModelFactory.Create(eventIds.Count(), totalCustomers, customersAttended,
criticalCustomers, normalCustomers, abnormalCustomers,
events, hosts,
reccentContactedEventId, recentMailedEvents, mailedDate,
recentCriticalCustomers, customers, customerResultStatusViewModels, urgentCustomers));
}
private void InsertEventZipProduct(ILogger logger)
{
var currentDate = DateTime.Today.AddDays(1);
var events = _eventRepository.GetEventsFutureDate(currentDate);
if (events.IsNullOrEmpty())
{
logger.Info("Future Events not found.");
return;
}
var eventIds = events.Select(e => e.Id).Distinct();
var hostList = _hostRepository.GetEventHosts(eventIds);
if (hostList.IsNullOrEmpty())
{
logger.Info("Host Data not found.");
return;
}
var eventProductList = _eventProductTypeRepository.GetByEventIds(eventIds);
if (eventProductList.IsNullOrEmpty())
{
logger.Info("event Product List not found.");
return;
}
if (!eventIds.IsNullOrEmpty())
{
try
{
foreach (var eventId in events)
{
var eventProduct = eventProductList.Where(x => x.EventID == eventId.Id);
var hostEvents = hostList.Where(x => x.Id == eventId.HostId).FirstOrDefault();
var zipId = hostEvents.Address.ZipCode.Id;
if (eventProduct != null)
{
foreach (var item in eventProduct)
{
var EventZipProductType = new EventZipProductType()
{
ProductTypeId = item.ProductTypeId,
ZipId = zipId
};
_eventZipProductTypeRepository.SaveEventZipProductType(EventZipProductType);
}
logger.Info("Successfully Saved Event Zip Product Type Data For Event ID: " + eventId.Id);
}
}
_eventZipProductTypeRepository.DeleteEventZipProductTypeSubstitute();
}
catch (Exception ex)
{
logger.Error(string.Format("Error Occurred While Saving event Data For" + ex.ToString()));
}
}
}
private List <EventHostDepositViewData> GetEventHostDepositViewDatas(long?eventId, DateTime?dueStartDate, DateTime?dueEndDate, HostPaymentStatus?hostPaymentStatus)
{
var hostDeposits = _hostDeositRepository.GetByFilters(eventId, dueStartDate, dueEndDate,
hostPaymentStatus);
var eventIds = hostDeposits.Select(hp => hp.EventId);
var events = _uniqueItemRepository.GetByIds(eventIds);
var hosts = _hostRepository.GetEventHosts(eventIds);
return(hostDeposits.HostDepositViewData(events, hosts));
}
public HealthPlanRevenueEventListModel GetEventListByHealthPlan(HealthPlanRevenueEventModelFilter filter, int pageNumber, int pageSize, out int totalRecords)
{
var firstCreatedHealthPlanRevenue = _healthPlanRevenueRepository.GetHealthPlanRevenueForEventListing(filter.HealthPlanId);
totalRecords = 0;
if (firstCreatedHealthPlanRevenue == null)
{
return(null);
}
filter.DateFrom = firstCreatedHealthPlanRevenue.DateFrom;
filter.DateTo = filter.DateTo ?? DateTime.Today.AddDays(1);
var events = _eventRepository.GetEventListByHealthPlanId(pageNumber, pageSize, filter, out totalRecords);
if (events == null || !events.Any())
{
return(null);
}
var eventIds = events.Select(e => e.Id).ToList();
var hosts = _hostRepository.GetEventHosts(eventIds);
var customersAttended = _eventRepository.GetAttendedCustomers(eventIds);
return(_healthplanRevenueListFactory.GetEventListByHealthPlan(events, hosts, customersAttended));
}
public EventCancellationListModel Create(IEnumerable <Event> events)
{
var eventIds = events.Select(x => x.Id);
var agentIds = events.Select(e => e.DataRecorderMetaData.DataRecorderModifier != null ? e.DataRecorderMetaData.DataRecorderModifier.Id : e.DataRecorderMetaData.DataRecorderCreator.Id).Distinct();
var agents = _organizationRoleUserRepository.GetNameIdPairofUsers(agentIds.ToArray());
var eventCancellationReasons = _lookupRepository.GetByLookupId((long)EventCancellationReason.DateChange);
var eventModels = new List <EventCancellationModel>();
var hosts = _hostRepository.GetEventHosts(eventIds);
foreach (var @event in events)
{
var eventModel = new EventCancellationModel();
eventModel.EventId = @event.Id;
eventModel.EventDate = @event.EventDate;
eventModel.Notes = @event.EventNotes;
if (@event.EventCancellationReasonId.HasValue)
{
eventModel.Reason = eventCancellationReasons.First(x => x.Id == @event.EventCancellationReasonId).DisplayName;
}
else
{
eventModel.Reason = "N/A";
}
eventModel.AgentName = agents.First(x => x.FirstValue == (@event.DataRecorderMetaData.DataRecorderModifier != null ? @event.DataRecorderMetaData.DataRecorderModifier.Id : @event.DataRecorderMetaData.DataRecorderCreator.Id)).SecondValue;
var host = hosts.First(h => h.Id == @event.HostId);
eventModel.HostName = host.OrganizationName;
eventModel.HostAddress = Mapper.Map <Address, AddressViewModel>(host.Address);
eventModels.Add(eventModel);
}
return(new EventCancellationListModel()
{
Collection = eventModels
});
}
public ListModelBase <RefundRequestBasicInfoModel, RefundRequestListModelFilter> GetPendingRequests(int pageNumber, int pageSize, ModelFilterBase filter, out int totalRecords)
{
var refundRequestFilter = filter as RefundRequestListModelFilter;
var requests = _refundRequestRepository.Get(pageNumber, pageSize, refundRequestFilter, out totalRecords);
if (requests == null || requests.Count() < 1)
{
return(null);
}
var customerIds = requests.Select(r => r.CustomerId).ToArray();
var customers = _customerRepository.GetCustomers(customerIds);
var eventIds = requests.Select(r => r.EventId).Distinct().ToArray();
var eventCustomers = _eventCustomerRepository.GetEventCustomersByEventIdsCustomerIds(eventIds, customerIds);
var appointmentCancellationLog = new List <EventAppointmentCancellationLog>();
if (!eventCustomers.IsNullOrEmpty())
{
var cancellationLog = _eventAppointmentCancellationLogRepository.GetByEventCustomerIds(eventCustomers.Select(x => x.Id));
if (!cancellationLog.IsNullOrEmpty())
{
appointmentCancellationLog.AddRange(cancellationLog);
}
}
var events = _eventRepository.GetEventswithPodbyIds(eventIds);
var hosts = _hostRepository.GetEventHosts(eventIds);
var orders = _orderRepository.GetOrderByOrderIds(requests.Select(r => r.OrderId));
var orgRoleUserIds = requests.Select(r => r.RequestedByOrgRoleUserId).Distinct().ToArray();
if (refundRequestFilter.RefundRequestStatus < 0 || refundRequestFilter.RefundRequestStatus == (int)RequestStatus.Resolved || refundRequestFilter.RefundRequestStatus == (int)RequestStatus.Reverted)
{
var processedbyOrgRoleUserIds = requests.Where(r => r.RefundRequestResult != null).Select(r => r.RefundRequestResult.ProcessedByOrgRoleUserId).Distinct().ToArray();
if (processedbyOrgRoleUserIds.Count() > 0)
{
orgRoleUserIds = orgRoleUserIds.Concat(processedbyOrgRoleUserIds).ToArray();
}
}
var bookedByOrgRoleUserIds = orders.Select(o => o.DataRecorderMetaData.DataRecorderCreator.Id).ToArray();
orgRoleUserIds = orgRoleUserIds.Concat(bookedByOrgRoleUserIds).ToArray();
var idNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds);
var organizationRoleUsers = _organizationRoleUserRepository.GetOrganizationRoleUsers(orgRoleUserIds);
var roles = _roleRepository.GetAll();
return(_refundRequestListFactory.Create(requests, customers, events, hosts, idNamePairs, organizationRoleUsers, roles, orders, eventCustomers, appointmentCancellationLog));
}
public ListModelBase <HospitalPartnerEventViewModel, HospitalPartnerEventListModelFilter> GetHospitalPartnerEvents(int pageNumber, int pageSize, ModelFilterBase filter, out int totalRecords)
{
using (var t = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions {
IsolationLevel = IsolationLevel.ReadUncommitted
}))
{
var normalValidityPeriod = 0;
var abnormalValidityPeriod = 0;
var criticalValidityPeriod = 0;
var eventFilter = (filter as HospitalPartnerEventListModelFilter);
if (eventFilter != null && eventFilter.HospitalPartnerId > 0)
{
var hospitalPartner = _hospitalPartnerRepository.GetHospitalPartnerforaVendor(eventFilter.HospitalPartnerId);
normalValidityPeriod = hospitalPartner.NormalResultValidityPeriod;
abnormalValidityPeriod = hospitalPartner.AbnormalResultValidityPeriod;
criticalValidityPeriod = hospitalPartner.CriticalResultValidityPeriod;
}
var events = _eventRepository.GetEventsForHospitalPartner(pageNumber, pageSize, filter as HospitalPartnerEventListModelFilter, out totalRecords, normalValidityPeriod, abnormalValidityPeriod, criticalValidityPeriod);
var eventIds = events.Select(e => e.Id).ToArray();
var hosts = _hostRepository.GetEventHosts(eventIds);
var customersAttended = _eventRepository.GetAttendedCustomers(eventIds);
var normalCustomers = _eventCustomerResultRepository.GetResultSummaryIEventIdCustomersCountForEventIds(eventIds, ResultInterpretation.Normal, true, normalValidityPeriod);
var abnormalCustomers = _eventCustomerResultRepository.GetResultSummaryIEventIdCustomersCountForEventIds(eventIds, ResultInterpretation.Abnormal, true, abnormalValidityPeriod);
var criticalCustomers = _eventCustomerResultRepository.GetCriticalEventIdCustomersCountForEventIds(eventIds, ResultInterpretation.Critical, true, criticalValidityPeriod);
var urgentCustomers = _eventCustomerResultRepository.GetResultSummaryIEventIdCustomersCountForEventIds(eventIds, ResultInterpretation.Urgent, true, criticalValidityPeriod);
var eventIdNotesIdPair = _hospitalPartnerRepository.GetEventIdNotesIdPair(eventIds);
var notes = _notesRepository.Get(eventIdNotesIdPair.Select(ec => ec.SecondValue));
var idNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(notes.Select(n => n.DataRecorderMetaData.DataRecorderCreator.Id).ToArray());
var model = new HospitalPartnerEventListModel();
model.Collection = _hospitalPartnerEventListFactory.Create(events, hosts, customersAttended, criticalCustomers, abnormalCustomers, eventIdNotesIdPair, notes, urgentCustomers, normalCustomers, idNamePairs);
t.Complete();
return(model);
}
}
private BiWeeklyMicroAlbuminFobtReportListModel GetBiWeeklyMicroAlbuminFobtReportModel(IReadOnlyCollection <EventCustomerResult> eventCustomerResultCollection)
{
if (eventCustomerResultCollection.IsNullOrEmpty())
{
_logger.Info("eventCustomerResultCollection provided is null or empty");
return(null);
}
var listModel = new BiWeeklyMicroAlbuminFobtReportListModel();
var collection = new List <BiWeeklyMicroAlbuminFobtReportViewModel>();
var customerIds = eventCustomerResultCollection.Select(x => x.CustomerId).ToArray();
var eventIds = eventCustomerResultCollection.Select(x => x.EventId).ToArray();
var eventCustomerResultIds = eventCustomerResultCollection.Select(x => x.Id).ToArray();
var events = _eventRepository.GetEventswithPodbyIds(eventIds);
var hosts = _hostRepository.GetEventHosts(eventIds);
var physicianLabTests = _physicianLabTestRepository.GetPhysicicanLabTestByStateIds(hosts.Select(x => x.Address.StateId));
var customers = _customerRepository.GetCustomers(customerIds);
var eventCustomerResultIdIfobtValuePair = _eventCustomerResultRepository.GetLabKitValueByEventCustomerResultId(eventCustomerResultIds, (long)TestType.IFOBT, (long)ReadingLabels.IFOBTSerialKey);
var eventCustomerResultIdMicroAlbuminValuePair = _eventCustomerResultRepository.GetLabKitValueByEventCustomerResultId(eventCustomerResultIds, (long)TestType.UrineMicroalbumin, (long)ReadingLabels.MicroalbuminSerialKey);
if (eventCustomerResultIdIfobtValuePair == null)
{
eventCustomerResultIdIfobtValuePair = new List <OrderedPair <long, string> >();
}
if (eventCustomerResultIdMicroAlbuminValuePair == null)
{
eventCustomerResultIdMicroAlbuminValuePair = new List <OrderedPair <long, string> >();
}
foreach (var eventCustomerResult in eventCustomerResultCollection)
{
var customer = customers.FirstOrDefault(x => x.CustomerId == eventCustomerResult.CustomerId);
var @event = events.FirstOrDefault(x => x.Id == eventCustomerResult.EventId);
var host = hosts.FirstOrDefault(x => x.Id == @event.HostId);
var fobtKit = eventCustomerResultIdIfobtValuePair.Any(x => x.FirstValue == eventCustomerResult.Id && !string.IsNullOrEmpty(x.SecondValue));
var microAlbuminKit = eventCustomerResultIdMicroAlbuminValuePair.Any(x => x.FirstValue == eventCustomerResult.Id && !string.IsNullOrEmpty(x.SecondValue));
var physicianLabTest = physicianLabTests.FirstOrDefault(x => x.StateId == host.Address.StateId);
var viewmodel = _biWeeklyMicroAlbuminFobtReportFactory.CreateModel(customer, @event.EventDate, fobtKit, microAlbuminKit, physicianLabTest);
collection.Add(viewmodel);
}
listModel.Collection = collection;
return(listModel);
}
//Should this method be part of IEventReportingService.
private EventVolumeListModel GetEventVolumeModel(IEnumerable <Event> events)
{
if (events.IsNullOrEmpty())
{
return(null);
}
var eventIds = events.Select(e => e.Id).ToList();
var hosts = _hostRepository.GetEventHosts(eventIds);
var eventAppointmentStatsModels = _eventAppointmentStatsService.Get(events);
var pods = _podRepository.GetPodsForEvents(eventIds);
var primaryPhysicians = _physicianEventAssignmentRepository.GetPrimaryPhysicianForEvents(eventIds);
var overReadPhysicians = _physicianEventAssignmentRepository.GetOverReadPhysicianForEvents(eventIds);
var eventIdHospitalPartnerIdPairs = _hospitalPartnerRepository.GetEventAndHospitalPartnerOrderedPair(eventIds);
//var eventIdCorporateAccountPairs = _corporateAccountRepository.GetEventIdCorporateAccountPairForSponsoredBy(eventIds);
var organizationIds = new List <long>();
organizationIds.AddRange(eventIdHospitalPartnerIdPairs.Select(ehp => ehp.SecondValue).Distinct().ToArray());
//organizationIds.AddRange(eventIdCorporateAccountPairs.Select(ehp => ehp.SecondValue).Distinct().ToArray());
var organizations = _organizationRepository.GetOrganizations(organizationIds.ToArray());
var eventIdHospitalPartnerNamePairs = (from ehp in eventIdHospitalPartnerIdPairs
join org in organizations on ehp.SecondValue equals org.Id
select new OrderedPair <long, string>(ehp.FirstValue, org.Name)).ToArray();
var eventIdCorporateNamePairs = _corporateAccountRepository.GetEventIdCorporateAccountNamePair(eventIds);
var customersAttended = _eventRepository.GetAttendedCustomers(eventIds);
var eventStaffCollection = _eventStaffAssignmentRepository.GetForEvents(eventIds);
IEnumerable <OrderedPair <long, string> > staffIdNamePairs = null;
if (eventStaffCollection != null && eventStaffCollection.Any())
{
var orgRoleUserIds = eventStaffCollection.Select(esc => (esc.ActualStaffOrgRoleUserId != null ? esc.ActualStaffOrgRoleUserId.Value : esc.ScheduledStaffOrgRoleUserId)).ToArray();
staffIdNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds);
}
return(_eventVolumeFactory.Create(events, hosts, pods, eventAppointmentStatsModels, primaryPhysicians, overReadPhysicians, eventIdHospitalPartnerNamePairs, customersAttended,
eventIdCorporateNamePairs, eventStaffCollection, staffIdNamePairs));
}
public TestsBookedListModel Create(IEnumerable <OrderedPair <long, long> > eventCustomerTestOrderedPairs, IEnumerable <EventCustomer> eventCustomers, IEnumerable <Event> events, IEnumerable <Customer> customers,
IEnumerable <Pod> pods, IEnumerable <Test> tests)
{
var model = new TestsBookedListModel();
var appointmentsBookedModels = new List <TestsBookedModel>();
var eventIds = eventCustomers.Select(ec => ec.EventId).Distinct().ToArray();
var hosts = _hostRepository.GetEventHosts(eventIds);
eventCustomerTestOrderedPairs.ToList().ForEach(ect =>
{
var ec = eventCustomers.FirstOrDefault(o => o.Id == ect.FirstValue);
var theEvent = events.FirstOrDefault(o => o.Id == ec.EventId);
var customer = customers.FirstOrDefault(c => c.CustomerId == ec.CustomerId);
var testNames = tests.Where(x => x.Id == ect.SecondValue).First().Name;
var podNames = (theEvent.PodIds != null && theEvent.PodIds.Count() > 0) ? string.Join(", ", pods.Where(p => theEvent.PodIds.Contains(p.Id)).Select(p => p.Name)) : string.Empty;
var host = hosts.First(h => h.Id == theEvent.HostId);
var testModel = new TestsBookedModel
{
CustomerId = ec.CustomerId,
CustomerName = customer.NameAsString,
EventName = host.OrganizationName,
EventDate = theEvent.EventDate,
EventId = ec.EventId,
TestName = testNames,
PodName = podNames
};
appointmentsBookedModels.Add(testModel);
});
model.Collection = appointmentsBookedModels;
return(model);
}
public OutboundCallQueueListModel GetOutboundCallQueueUpsellAndConfirmation(OutboundCallQueueFilter filter, CallQueue callQueue, int pageSize, long criteriaId, out int totalRecords)
{
var callQueueCustomers = _callQueueCustomerRepository.GetCallQueueCustomerForUpsellAndConfirmation(filter, filter.PageNumber, pageSize, callQueue, criteriaId, out totalRecords);
if (callQueueCustomers.IsNullOrEmpty())
{
return(null);
}
var eventIds = callQueueCustomers.Where(x => x.EventId.HasValue).Select(x => x.EventId.Value).Distinct();
var customerIds = callQueueCustomers.Where(cqc => cqc.CustomerId.HasValue && cqc.CustomerId.Value > 0).Select(cqc => cqc.CustomerId.Value).Distinct().ToArray();
var eventCustomers = _eventCustomerRepository.GetByEventIds(eventIds);
eventCustomers = eventCustomers.Where(ec => customerIds.Contains(ec.CustomerId));
var orgRoleUserIds = eventCustomers.Where(ec => ec.DataRecorderMetaData != null && ec.DataRecorderMetaData.DataRecorderCreator != null).Select(ec => ec.DataRecorderMetaData.DataRecorderCreator.Id).ToList();
var registeredbyAgent = _organizationRoleUserRepository.GetOrganizationRoleUsers(orgRoleUserIds);
var roles = _roleRepository.GetAll();
// var registeredbyAgentNameIdPair = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds.ToArray()).ToArray();
var appointment = _appointmentRepository.GetByIds(eventCustomers.Where(ec => ec.AppointmentId.HasValue).Select(ec => ec.AppointmentId.Value));
var events = _eventRepository.GetEventswithPodbyIds(eventIds).ToList();
var hosts = _hostRepository.GetEventHosts(eventIds).ToList();
var pods = _podRepository.GetPodsForEvents(eventIds);
IEnumerable <Customer> customers = _customerRepository.GetCustomers(customerIds);
var callQueueCustomerCalls = _callCenterCallRepository.GetCallForCallQueueCustomerList(customerIds, null);
IEnumerable <CallCenterNotes> callCenterNotes = null;
if (callQueueCustomerCalls != null && callQueueCustomerCalls.Any())
{
callCenterNotes = _callCenterNotesRepository.GetByCallIds(callQueueCustomerCalls.Select(s => s.CallId));
}
return(_outboundCallQueueListModelFactory.CallQueueCustomersForUpsellAndConfimration(callQueueCustomers, customers, callQueueCustomerCalls, callCenterNotes, events, hosts, pods, appointment, eventCustomers, registeredbyAgent, roles));
}
public EventBasicInfoListModel EventBasicInfoListForCallQueue(IEnumerable <Event> events)
{
var eventIds = events.Select(e => e.Id).ToArray();
var hosts = _hostRepository.GetEventHosts(eventIds);
var pods = _podRepository.GetPodsForEvents(eventIds);
var eventAppointmentStatsModels = _eventAppointmentStatsService.Get(eventIds);
var eventHpPairs = _hospitalPartnerRepository.GetEventAndHospitalPartnerOrderedPair(eventIds);
var organizationIds = new List <long>();
if (eventHpPairs != null && eventHpPairs.Any())
{
organizationIds.AddRange(eventHpPairs.Select(o => o.SecondValue).ToArray());
}
organizationIds.AddRange(
events.Where(e => e.AccountId.HasValue && e.AccountId.Value > 0).Select(e => e.AccountId.Value).ToArray());
var organizations = _organizationRepository.GetOrganizations(organizationIds.Distinct().ToArray());
var eventModels = new List <EventBasicInfoViewModel>();
foreach (var theEvent in events) // Should go inside a mapper
{
var eventModel = EventBasicInfoViewModel(hosts, theEvent, pods, eventAppointmentStatsModels, eventHpPairs, organizations);
eventModels.Add(eventModel);
}
return(new EventBasicInfoListModel()
{
Events = eventModels
});
}
private void InsertHealthplanEventZipCode(long accountId, string tag, ILogger logger)
{
var currentDate = DateTime.Today.AddDays(1);
var rangeInMiles = _settings.ZipRangeInMiles;
var events = _eventRepository.GetEventsByAccountIdAndDate(accountId, currentDate, null, true);
var eventIds = events.Select(e => e.Id);
if (!eventIds.IsNullOrEmpty())
{
try
{
var zipIds = new List <long>();
var hostList = _hostRepository.GetEventHosts(eventIds);
foreach (var host in hostList)
{
//var zipcodes = _zipCodeRepository.GetZipCodesInRadius(host.Address.ZipCode.Zip, rangeInMiles);
//var hostZipIds = zipcodes.Select(x => x.Id);
//if (!zipcodes.IsNullOrEmpty())
// zipIds.AddRange(hostZipIds);
//var hostEvents = events.Where(x => x.HostId == host.Id);
//foreach (var hostEvent in hostEvents)
//{
// _healthPlanFillEventCallQueueRepository.DeleteEventZipByEventId(hostEvent.Id);
// foreach (var zipId in hostZipIds)
// {
// _healthPlanFillEventCallQueueRepository.SaveEventZips(hostEvent.Id, zipId);
// }
//}
var zipcodes = _zipRadiusDistanceRepository.GetBySourceZipIdAndRadius(host.Address.ZipCode.Id, rangeInMiles);
if (!zipcodes.IsNullOrEmpty())
{
var hostZipIds = zipcodes.Select(x => x.DestinationZipId);
zipIds.AddRange(hostZipIds);
if (!hostZipIds.IsNullOrEmpty())
{
var hostEvents = events.Where(x => x.HostId == host.Id);
foreach (var hostEvent in hostEvents)
{
_healthPlanFillEventCallQueueRepository.DeleteEventZipByEventId(hostEvent.Id);
foreach (var zipId in hostZipIds)
{
_healthPlanFillEventCallQueueRepository.SaveEventZips(hostEvent.Id, zipId);
}
}
}
}
}
//var stringZipIds = string.Empty;
//if (!zipIds.IsNullOrEmpty())
//{
// stringZipIds = string.Join(",", zipIds.Distinct().ToArray());
//}
_accountEventZipReposiory.Save(accountId, zipIds.Distinct().ToArray());
logger.Info("Successfully Saved Healthplan Event Zip Data For Account ID: " + accountId);
}
catch (Exception ex)
{
logger.Error(string.Format("Error Occurred While Saving Account Zip Data For Account ID: {0}.\n Message {1} \n Stack Trace {2}", accountId, ex.Message, ex.StackTrace));
}
}
try
{
var healthPlanEventZip = new HealthPlanEventZip()
{
AccountID = accountId,
AccountTag = tag,
DateCreated = currentDate,
IsQueueGenerated = true
};
_healthPlanEventZipRepository.Save(healthPlanEventZip);
}
catch (Exception exception)
{
logger.Error("some error occurred while saving HealthPlanEventZip");
logger.Error("Message: " + exception.Message);
logger.Error("Stack trace: " + exception.StackTrace);
}
}
public IEnumerable <OnlineEventViewModel> GetEvents(OnlineSchedulingEventListModelFilter filter, int maxNumberofRecordstoFetch, int pageSize, out int totalRecords)
{
var events = _eventRepository.GetEventsbyFilters(filter, out totalRecords);
if (events == null || !events.Any())
{
return(null);
}
var todayEventIds = events.Where(e => e.EventDate < DateTime.Now.Date.AddDays(1)).Select(e => e.Id);
var todaySlots = _eventSchedulingSlotRepository.GetbyEventIds(todayEventIds);
var eventIds = events.Select(e => e.Id).Distinct().ToArray();
var hosts = _hostRepository.GetEventHosts(eventIds);
var eventAppointmentStatsModels = _eventAppointmentStatsService.Get(eventIds);
ZipCode zipCode = null;
try
{
if (!string.IsNullOrEmpty(filter.ZipCode))
{
zipCode = _zipCodeRepository.GetZipCode(filter.ZipCode).FirstOrDefault();
}
}
catch (ObjectNotFoundInPersistenceException <ZipCode> )
{
zipCode = null;
}
var eventCollection = _onlineEventListModelFactory.Create(events, hosts, eventAppointmentStatsModels, zipCode, todaySlots, filter.EventId, filter.CutOffHourstoMarkEventforOnlineSelection,
filter.OrderBy, filter.OrderType, maxNumberofRecordstoFetch, filter.PageNumber, pageSize, out totalRecords);
eventIds = eventCollection.Select(e => e.EventId).Distinct().ToArray();
foreach (var theEvent in eventCollection)
{
var eventTest = _eventTestRepository.GetByEventAndTestIds(theEvent.EventId, TestGroup.BreastCancer);
theEvent.HasBreastCancer = eventTest != null && eventTest.Any();
}
var eventHpPairs = _hospitalPartnerRepository.GetEventAndHospitalPartnerOrderedPair(eventIds);
var eventCorporateAccountPairs = _corporateAccountRepository.GetEventIdCorporateAccountPairForSponsoredBy(eventIds);
var organizations = eventCorporateAccountPairs == null || eventCorporateAccountPairs.Count() < 1 ? null : _organizationRepository.GetOrganizations(eventCorporateAccountPairs.Select(m => m.SecondValue).Distinct().ToArray());
var fileIds = organizations != null?organizations.Where(o => o.LogoImageId > 0).Select(o => o.LogoImageId).ToArray() : null;
var files = fileIds == null ? null : _fileRepository.GetByIds(fileIds);
if (files != null)
{
var location = _mediaRepository.GetOrganizationLogoImageFolderLocation();
files = files.Select(f =>
{
f.Path = location.Url + f.Path;
return(f);
}).ToArray();
eventCollection = _onlineEventListModelFactory.ManageSponsoredByLogo(eventCollection, eventCorporateAccountPairs, organizations, files);
}
organizations = eventHpPairs == null || eventHpPairs.Count() < 1 ? null : _organizationRepository.GetOrganizations(eventHpPairs.Select(m => m.SecondValue).Distinct().ToArray());
fileIds = organizations != null?organizations.Where(o => o.LogoImageId > 0).Select(o => o.LogoImageId).ToArray() : null;
files = fileIds == null ? null : _fileRepository.GetByIds(fileIds);
if (files != null)
{
var location = _mediaRepository.GetOrganizationLogoImageFolderLocation();
files = files.Select(f =>
{
f.Path = location.Url + f.Path;
return(f);
}).ToArray();
eventCollection = _onlineEventListModelFactory.ManageSponsoredByLogo(eventCollection, eventHpPairs, organizations, files);
}
return(eventCollection);
}
public CustomerEventDetailViewModel GetPatients(PatientSearchFilter filter, long technicianId)
{
var list = new List <ShortPatientInfoViewModel>();
var patientList = _customerRepository.GetPatientList(filter);
if (patientList.IsNullOrEmpty())
{
return(new CustomerEventDetailViewModel());
}
var customerIds = patientList.Select(x => x.CustomerId);
var eventCustomers = _eventCustomerRepository.GetByCustomerIdEventDate(customerIds, DateTime.Today, DateTime.Now.AddDays(-1), technicianId).Where(x => x.AppointmentId.HasValue).ToArray();
if (eventCustomers.IsNullOrEmpty())
{
return(new CustomerEventDetailViewModel());
}
customerIds = eventCustomers.Select(x => x.CustomerId).Distinct().ToList();
var appointmentIds = eventCustomers.Where(x => x.AppointmentId.HasValue).Select(x => x.AppointmentId.Value).ToArray();
var appointments = _appointmentRepository.GetByIds(appointmentIds);
var eventIds = eventCustomers.Select(x => x.EventId).Distinct().ToArray();
var events = _eventRepository.GetEventsByIds(eventIds);
var eventModels = _eventService.GetShortEventInfoList(events);
var hosts = _hostRepository.GetEventHosts(eventIds);
var eventCustomerIds = eventCustomers.Select(x => x.Id);
var orders = _orderRepository.GetAllOrdersByEventCustomerIds(eventCustomerIds);
var participationConsentSignatures = _participationConsentSignatureRepository.GetByEventCustomerIds(eventCustomerIds);
var fluConsentSignatures = _fluConsentSignatureRepository.GetByEventCustomerIds(eventCustomerIds);
var physicianRecordRequestSignatures = _physicianRecordRequestSignatureRepository.GetByEventCustomerIds(eventCustomerIds);
var primaryCarePhysicians = _primaryCarePhysicianRepository.GetByCustomerIds(customerIds);
foreach (var eventCustomer in eventCustomers)
{
var patient = patientList.First(x => x.CustomerId == eventCustomer.CustomerId);
var appointment = appointments.First(x => x.Id == eventCustomer.AppointmentId);
var theEvent = events.First(x => x.Id == eventCustomer.EventId);
var host = hosts.First(x => x.Id == theEvent.HostId);
var order = orders.Single(o => o.CustomerId == eventCustomer.CustomerId);
var eventPackages = _eventPackageRepository.GetPackagesForEvent(eventCustomer.EventId);
var eventTests = _eventTestRepository.GetTestsForEvent(eventCustomer.EventId);
var eventpackageId = order.OrderDetails.Where(od => od.OrderItemStatus.OrderStatusState == OrderStatusState.FinalSuccess && od.OrderItem.OrderItemType == OrderItemType.EventPackageItem)
.Select(od => od.OrderItem.ItemId).SingleOrDefault();
var eventPackage = eventPackages.SingleOrDefault(ep => eventpackageId == ep.Id);
var eventTestIds = order.OrderDetails.Where(od => od.OrderItemStatus.OrderStatusState == OrderStatusState.FinalSuccess && od.OrderItem.OrderItemType == OrderItemType.EventTestItem).Select(od => od.OrderItem.ItemId).ToArray();
var eventTestsonOrder = eventTests.Where(et => eventTestIds.Contains(et.Id)).ToArray();
var chaperoneSignature = _chaperoneSignatureRepository.GetByEventCustomerId(eventCustomer.Id);
var model = new ShortPatientInfoViewModel
{
CustomerId = patient.CustomerId,
EventCustomerId = eventCustomer.Id,
FirstName = patient.Name.FirstName,
MiddleName = patient.Name.MiddleName,
LastName = patient.Name.LastName,
Email = patient.Email.ToString(),
HomePhone = patient.HomePhoneNumber.FormatPhoneNumber,
MobileNumber = patient.MobilePhoneNumber.FormatPhoneNumber,
EventId = eventCustomer.EventId,
AppointmentTime = appointment.StartTime,
Packages = eventPackage != null ? eventPackage.Package.Name : "",
Tests = !eventTestsonOrder.IsNullOrEmpty() ? string.Join(", ", eventTestsonOrder.Select(t => t.Test.Name)) : "",
HipaaConsent = eventCustomer.HIPAAStatus,
CheckInTime = appointment.CheckInTime,
CheckOutTime = appointment.CheckOutTime,
MatrixConsent = participationConsentSignatures != null && participationConsentSignatures.SingleOrDefault(x => x.EventCustomerId == eventCustomer.Id) != null,
PhysicianRecordRequest = physicianRecordRequestSignatures != null && physicianRecordRequestSignatures.SingleOrDefault(x => x.EventCustomerId == eventCustomer.Id) != null,
FluVaccine = fluConsentSignatures != null && fluConsentSignatures.SingleOrDefault(x => x.EventCustomerId == eventCustomer.Id) != null,
NoShow = eventCustomer.AppointmentId.HasValue && eventCustomer.NoShow,
LeftWithoutScreening = eventCustomer.AppointmentId.HasValue && eventCustomer.LeftWithoutScreeningReasonId.HasValue,
ChaperoneConsent = chaperoneSignature != null?true: false
};
var pcp = primaryCarePhysicians != null?primaryCarePhysicians.FirstOrDefault(x => x.CustomerId == eventCustomer.CustomerId) : null;
if (pcp != null)
{
var pcpAddress = pcp.Address != null?Mapper.Map <Address, AddressViewModel>(pcp.Address) : null;
model.PrimaryCarePhysician = new PcpInfoViewModel
{
Name = pcp.Name.FullName,
Address = pcpAddress,
PhoneNumber = pcp.Primary != null ? pcp.Primary.FormatPhoneNumber : pcp.Secondary != null ? pcp.Secondary.FormatPhoneNumber : "",
Fax = pcp.Fax != null ? pcp.Fax.FormatPhoneNumber : ""
};
}
list.Add(model);
}
return(new CustomerEventDetailViewModel
{
Customers = list,
Events = eventModels
});
}
public IEnumerable <CallQueueCustomer> GetCallQueueCustomers(long callQueueId, SystemGeneratedCallQueueCriteria criteria)
{
var days = criteria.NoOfDays;
var percentage = criteria.Percentage;
var endDate = DateTime.Today.AddDays(days);
var eventList = _eventRepository.GetEventsForFillEventsCallQueue(endDate);
if (eventList == null || !eventList.Any())
{
return(null);
}
eventList = _fillEventsCallQueueHelper.GetAllTheEventFilledUnderPecentage(eventList, percentage);
if (eventList == null || !eventList.Any())
{
return(null);
}
var eventIds = eventList.Select(x => x.Id);
var eventZipPairList = new List <OrderedPair <long, string> >();
var hostList = _hostRepository.GetEventHosts(eventIds);
foreach (var theEvent in eventList)
{
var host = hostList.FirstOrDefault(h => h.Id == theEvent.HostId);
if (host != null)
{
eventZipPairList.Add(new OrderedPair <long, string>(theEvent.Id, host.Address.ZipCode.Zip));
}
}
var zipList = eventZipPairList.Select(x => x.SecondValue).Distinct().ToList();
var zipZipStringPairList = new List <OrderedPair <string, string> >();
foreach (var zip in zipList)
{
var zipCodesInRange = _zipCodeRepository.GetZipCodesInRadius(zip, 10) ??
new List <ZipCode>();
if (!zipCodesInRange.Any())
{
zipZipStringPairList.Add(new OrderedPair <string, string>(zip, "," + zip + ","));
}
else
{
var zipCodestring = "," + string.Join(",", zipCodesInRange) + ",";
zipZipStringPairList.Add(new OrderedPair <string, string>(zip, zipCodestring));
}
}
var customers = _customerRepository.GetCustomerForFillEventCallQueue(eventZipPairList, zipZipStringPairList);
var pcustomers = _prospectCustomerRepository.GetProspectCustomerForFillEventCallQueue(eventZipPairList, zipZipStringPairList);
if ((customers == null || !customers.Any()) && (pcustomers == null || !pcustomers.Any()))
{
return(null);
}
var callQueueCustomerList = new List <CallQueueCustomer>();
if (customers != null && customers.Any())
{
foreach (var customer in customers)
{
callQueueCustomerList.Add(new CallQueueCustomer {
CallQueueId = callQueueId, EventId = customer.FirstValue, CustomerId = customer.SecondValue
});
}
}
if (pcustomers != null && pcustomers.Any())
{
foreach (var pcustomer in pcustomers)
{
if (callQueueCustomerList.Any(cqcl => cqcl.CustomerId == pcustomer.CustomerId && cqcl.EventId == pcustomer.EventId))
{
continue;
}
callQueueCustomerList.Add(new CallQueueCustomer {
CallQueueId = callQueueId, ProspectCustomerId = pcustomer.ProspectCustomerId, CustomerId = pcustomer.CustomerId, EventId = pcustomer.EventId
});
}
}
return(callQueueCustomerList);
}
private void InsertAccountEventZip(long accountId, string tag, AccountEventZipSetting generationSetting)
{
var fromDate = DateTime.Today.AddDays(1);
var rangeInMiles = _settings.ZipRangeInMiles;
var events = _eventRepository.GetEventsByAccountIdAndDate(accountId, fromDate, null, true);
var eventAppointmentStatsModels = _eventAppointmentStatsService.GetStats(events);
var eventIds = !eventAppointmentStatsModels.IsNullOrEmpty() ? eventAppointmentStatsModels.Where(x => x.FreeSlots > 0 || x.IsDynamicScheduling).Select(x => x.EventId) : null;
if (eventIds.IsNullOrEmpty())
{
_logger.Info("No events found.");
return;
}
_logger.Info("Events found : " + eventIds.Count());
var zipIds = new List <long>();
var hostList = _hostRepository.GetEventHosts(eventIds);
foreach (var host in hostList)
{
var zipcodes = _zipRadiusDistanceRepository.GetBySourceZipIdAndRadius(host.Address.ZipCode.Id, rangeInMiles);
if (!zipcodes.IsNullOrEmpty())
{
var hostZipIds = zipcodes.Select(x => x.DestinationZipId);
zipIds.AddRange(hostZipIds);
var recentlyCreatedEvents = events.Where(x => x.HostId == host.Id && x.DataRecorderMetaData.DateCreated > generationSetting.LastGenerationDateTime);
_logger.Info("Generating event zip for recently created events. Count : " + recentlyCreatedEvents.Count());
foreach (var recentlyCreatedEvent in recentlyCreatedEvents)
{
if (_healthPlanFillEventCallQueueRepository.IsEventZipAlreadyGenerated(recentlyCreatedEvent.Id))
{
_logger.Info("Event Zip already generated for EventID : " + recentlyCreatedEvent.Id);
continue;
}
_healthPlanFillEventCallQueueRepository.DeleteEventZipByEventId(recentlyCreatedEvent.Id);
foreach (var zipId in hostZipIds)
{
_healthPlanFillEventCallQueueRepository.SaveEventZips(recentlyCreatedEvent.Id, zipId);
}
}
}
}
if (generationSetting.LastGeneratedTable == AccountEventZipGenerationType.AccountEventZipSubstitute.ToString())
{
_accountEventZipReposiory.Save(accountId, zipIds.Distinct().ToArray());
}
else
{
_accountEventZipReposiory.SaveSubstitute(accountId, zipIds.Distinct().ToArray());
}
//var healthPlanEventZip = new HealthPlanEventZip()
//{
// AccountID = accountId,
// AccountTag = tag,
// DateCreated = DateTime.Now,
// IsQueueGenerated = true
//};
//_healthPlanEventZipRepository.Save(healthPlanEventZip);
}
public ListModelBase <TestNotPerformedViewModel, TestNotPerformedListModelFilter> GetTestNotPerformed(int pageNumber, int pageSize, ModelFilterBase filter, out int totalRecords)
{
var testNotPerformFilter = filter as TestNotPerformedListModelFilter;
var testNotPerformed = _testNotPerformedRepository.GetTestNotPerformedForHealthPlan(testNotPerformFilter, pageNumber, pageSize, out totalRecords);
if (testNotPerformed == null || !testNotPerformed.Any())
{
return(null);
}
var customerEventScreeningTestIds = testNotPerformed.Select(x => x.CustomerEventScreeningTestId).ToArray();
var customerEventScreeningTests = _eventCustomerResultRepository.GetCustomerEventScreeningTestsByIds(customerEventScreeningTestIds);
var customerEventTestStates = _customerEventTestStateRepository.GetCustomerEventTestState(customerEventScreeningTestIds);
var orgRoleUserIds = customerEventTestStates.Where(cets => cets.ConductedByOrgRoleUserId.HasValue).Select(cets => cets.ConductedByOrgRoleUserId.Value).Distinct().ToArray();
var idNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds);
var eventCustomerResults = _eventCustomerResultRepository.GetByIds(customerEventScreeningTests.Select(ces => ces.EventCustomerResultId).Distinct().ToArray());
var eventIds = eventCustomerResults.Select(ecr => ecr.EventId).Distinct().ToArray();
var events = _eventRepository.GetEventswithPodbyIds(eventIds);
var hosts = _hostRepository.GetEventHosts(events.Select(x => x.Id));
IEnumerable <OrderedPair <long, long> > staffOrgRoleUserEventsPair = null;
IEnumerable <OrderedPair <long, string> > staffNamePair = null;
var npRoles = _eventRoleRepository.GetByName(_awvNpEventStaffRole);
if (npRoles != null && npRoles.Any())
{
var eventStaffs = _eventStaffAssignmentRepository.GetForEvents(eventIds);
var npRoleIds = npRoles.Select(x => x.Id);
if (eventStaffs != null && eventStaffs.Any())
{
eventStaffs = eventStaffs.Where(x => npRoleIds.Contains(x.StaffEventRoleId)).ToArray();
}
staffOrgRoleUserEventsPair = eventStaffs.Select(p => new OrderedPair <long, long>(p.ScheduledStaffOrgRoleUserId, p.EventId)).ToArray();
staffNamePair = _organizationRoleUserRepository.GetNameIdPairofUsers(staffOrgRoleUserEventsPair.Select(x => x.FirstValue).ToArray());
}
var customers = _customerRepository.GetCustomers(eventCustomerResults.Select(ecr => ecr.CustomerId).Distinct().ToArray());
//var tags = customers.Select(x => x.Tag).Distinct().ToArray();
//var corporateAccount = _corporateAccountRepository.GetByTags(tags);
var accountIds = events.Where(x => x.AccountId.HasValue && x.AccountId > 0).Select(x => x.AccountId.Value).Distinct().ToArray();
var corporateAccount = _corporateAccountRepository.GetByIds(accountIds);
if (corporateAccount != null && corporateAccount.Any())
{
corporateAccount = corporateAccount.Where(x => x.IsHealthPlan);
}
var tests = ((IUniqueItemRepository <Test>)_testRepository).GetByIds(customerEventScreeningTests.Select(ces => ces.TestId).Distinct().ToArray());
var customersPreApprovedTest = _preApprovedTestRepository.GetPreApprovedTestIdsByCustomerIds(eventCustomerResults.Select(x => x.Id));
var pods = _podRepository.GetByIds(events.SelectMany(e => e.PodIds).Distinct());
var eventCustomers = _eventCustomerRepository.GetByIds(customerEventScreeningTests.Select(ces => ces.EventCustomerResultId).Distinct().ToArray());
return(_testNotPerformedFactory.Create(testNotPerformed, customerEventScreeningTests, eventCustomerResults, events, customers, tests,
customersPreApprovedTest, corporateAccount, pods, customerEventTestStates, idNamePairs, staffOrgRoleUserEventsPair, staffNamePair, hosts, eventCustomers));
}
