public EventCustomersFindingEditModel GetforanEvent(long eventId)
{
var selectedEvent = _eventRepository.GetById(eventId);
var eventCustomers = _eventCustomerRepository.GetbyEventId(eventId);
var tests = _testRepository.GetTestsForEvent(eventId);
var pod = _podRepository.GetPodsForEvent(selectedEvent.Id);
var customerRecieptModels = new List <CustomerItemizedReceiptModel>();
if (eventCustomers.IsNullOrEmpty())
{
return(_eventCustomerFindingFactory.Create(selectedEvent, customerRecieptModels, tests, null, null, null, pod));
}
eventCustomers = eventCustomers.Where(ec => ec.AppointmentId.HasValue && !ec.NoShow).ToArray();
var customers = _customerRepository.GetCustomers(eventCustomers.Select(crm => crm.CustomerId).ToArray());
customerRecieptModels.AddRange(from eventCustomer in eventCustomers
where eventCustomer.AppointmentId != null
select _service.GetItemizedRecieptModel(eventCustomer.CustomerId, eventId));
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var linqMetaData = new LinqMetaData(adapter);
var eventCustomerFindingEntities =
linqMetaData.CustomerEventTestFinding.Where(ce => ce.EventId == eventId).ToArray();
var physicianNoteEntities = linqMetaData.CustomerEventTestPhysicianNote.Where(ce => ce.EventId == eventId).ToArray();
return(_eventCustomerFindingFactory.Create(selectedEvent, customerRecieptModels, tests,
eventCustomerFindingEntities, physicianNoteEntities, customers, pod));
}
}
public IEnumerable <ClinicalTestQualificationViewModel> RecommendTestToCustomer(string guid, long customerId, long eventId)
{
var customerProfile = _customerRepository.GetCustomer(customerId);
var disqualifiedTestIds = new List <long>();
var recommendedtestIds = GetTestIdsToRecommend(guid, customerId, customerProfile.Gender, customerProfile.DateOfBirth, disqualifiedTestIds);
var recommendedTestNames = new List <ClinicalTestQualificationViewModel>();
var eventTests = _eventTestRepository.GetTestsForEvent(eventId);
if (!recommendedtestIds.IsNullOrEmpty())
{
var recommendedtests = eventTests.Where(x => recommendedtestIds.Contains(x.TestId));
if (recommendedtests.Any())
{
recommendedTestNames = recommendedtests.Select(x => new ClinicalTestQualificationViewModel(x.Test.Id, x.Test.Name, false)).ToList();
}
}
if (!disqualifiedTestIds.IsNullOrEmpty())
{
var disqualifiedTest = eventTests.Where(x => disqualifiedTestIds.Contains(x.TestId));
if (disqualifiedTest.Any())
{
recommendedTestNames.AddRange(disqualifiedTest.Select(x => new ClinicalTestQualificationViewModel(x.Test.Id, x.Test.Name, true)));;
}
}
return(recommendedTestNames);
}
public CustomerOrderDetail GetCustomerOrderDetails(long customerId, long eventId)
{
var order = _orderRepository.GetOrder(customerId, eventId);
var customerProfile = _customerRepository.GetCustomer(customerId);
if (customerProfile == null)
{
return(null);
}
var eventPackages = _eventPackageRepository.GetPackagesForEvent(eventId);
var eventTests = _eventTestRepository.GetTestsForEvent(eventId);
var customerOrder = new CustomerOrderDetail
{
OrderId = order.Id,
EventId = eventId,
CustomerId = customerId
};
var orderPackage = order.OrderDetails.FirstOrDefault(o => o.DetailType == OrderItemType.EventPackageItem && o.OrderItemStatus.OrderStatusState == OrderStatusState.FinalSuccess);
if (orderPackage != null)
{
var eventPackage = eventPackages.SingleOrDefault(x => x.Id == orderPackage.OrderItem.ItemId);
customerOrder.PackageModel = GetEventPackage(eventPackage);
}
var orderTests = order.OrderDetails.Where(o => o.DetailType == OrderItemType.EventTestItem && o.OrderItemStatus.OrderStatusState == OrderStatusState.FinalSuccess).ToList();
if (orderTests != null)
{
var testIds = orderTests.Select(s => s.OrderItem.ItemId).ToArray();
var evemtTest = eventTests.Where(et => testIds.Contains(et.Id));
customerOrder.AlaCarteTests = GetTestModels(evemtTest);
}
var product = order.OrderDetails.Where(od => od.OrderItemStatus.OrderStatusState == OrderStatusState.FinalSuccess && od.OrderItem.OrderItemType == OrderItemType.ProductItem).Select(od => od.OrderItem.ItemId).FirstOrDefault();
customerOrder.ProductId = product;
var shippingDetailIds = order.OrderDetails.SelectMany(od => od.ShippingDetailOrderDetails.Where(sdod => sdod.IsActive).Select(sdod => sdod.ShippingDetailId)).ToArray();
if (shippingDetailIds.Any())
{
var shipingDetails = _shippingDetailRepository.GetByIds(shippingDetailIds).ToList();
customerOrder.ShippingOptions = shipingDetails.Select(x => new ShippingOptionDetail {
Id = x.Id
}).ToArray();
}
return(customerOrder);
}
private PhysicianEventAssignmentEditModel Get(PhysicianEventAssignmentEditModel model)
{
if (model != null && model.IsEvaluationRestricted)
{
var eventTests = _eventTestRepository.GetTestsForEvent(model.EventId);
var tests = eventTests.Where(et => et.Test.IsReviewable).Select(et => et.Test).ToArray();
//model.EventTests = _testRepository.GetReviewableTests();
model.EventTests = tests;
}
return(model);
}
public EventScreeningAuthorizationEditModel GetCustomersForAuthorization(long physicianId)
{
var eventData = _eventRepository.GetEventForAuthorization(physicianId);
if (eventData == null)
{
return(null);
}
var host = _hostRepository.GetHostForEvent(eventData.Id);
var eventTests = _eventTestRepository.GetTestsForEvent(eventData.Id);
var eventPackages = _eventPackageRepository.GetPackagesForEvent(eventData.Id);
var eventCustomers = _eventCustomerRepository.GetEventCustomersForAuthorization(eventData.Id);
if (eventCustomers == null || eventCustomers.Count() < 1)
{
return(null);
}
var eventCustomerIds = eventCustomers.Select(ec => ec.Id).ToArray();
var assignments = _physicianAssignmentService.GetPhysicianAssignmentsByEventcustomerIds(eventCustomerIds);
if (!assignments.Any(a => a.Primary.PhysicianId == physicianId))
{
return(null);
}
eventCustomerIds = assignments.Where(a => a.Primary.PhysicianId == physicianId).Select(a => a.EventCustomerId).ToArray();
eventCustomers = eventCustomers.Where(ec => eventCustomerIds.Contains(ec.Id)).ToArray();
var orderIdEventCustomerIdPairs = _orderRepository.GetOrderEventCustomerIdPairforEventCustomerIds(eventCustomerIds);
var orderIds = orderIdEventCustomerIdPairs.Select(p => p.FirstValue).ToArray();
var orderIdTestIdPairs = _eventTestRepository.GetEventTestIdForOrders(orderIds);
var orderIdpackageIdPairs = _eventPackageRepository.GetEventPackageIdsForOrder(orderIds);
var ecIdTestIdPairs = (from ec in orderIdEventCustomerIdPairs join ot in orderIdTestIdPairs on ec.FirstValue equals ot.FirstValue select new OrderedPair <long, long>(ec.SecondValue, ot.SecondValue)).ToArray();
var ecIdpackageIdPairs = (from ec in orderIdEventCustomerIdPairs join op in orderIdpackageIdPairs on ec.FirstValue equals op.FirstValue select new OrderedPair <long, long>(ec.SecondValue, op.SecondValue)).ToArray();
var customers = _customerRepository.GetCustomers(eventCustomers.Select(ec => ec.CustomerId).ToArray());
return(_eventScreeningAuthorizationEditModelFactory.Create(eventData, eventTests, eventCustomers, customers, eventPackages, ecIdpackageIdPairs, ecIdTestIdPairs, host));
}
public EventMetricsViewData GetEventMetricsViewData(long eventId, long orgRoleUserId)
{
// TODO: This method really needs refactoring,
// TODO: probably every different part of the view data needs to be handled in different factory.
// TODO: Will revisit this after shopping cart is complete.
var orders = _orderRepository.GetAllOrdersForEvent(eventId);
var eventPackages = _eventPackageRepository.GetPackagesForEvent(eventId);
var eventTests = _eventTestRepository.GetTestsForEvent(eventId);
var eventCustomers = _eventCustomerRepository.GetEventCustomersbyEventId(eventId);
IOrganizationRoleUserRepository organizationRoleUserRepository = new OrganizationRoleUserRepository();
var organizationRoleUser = organizationRoleUserRepository.GetOrganizationRoleUser(orgRoleUserId);
var eventMetricsViewData = _revenueStatisticsViewDataFactory.CreateEventMetricsViewData(orders, eventPackages, eventTests, organizationRoleUser, eventCustomers);
eventMetricsViewData = _eventCustomerRepository.GetEventCustomerFlagMetrics(eventMetricsViewData, eventId);
return(eventMetricsViewData);
}
public void GetTestForEvent_ValidId_Tester()
{
var eventTests = _eventTestRepository.GetTestsForEvent(24762);
Assert.IsNotNull(eventTests);
Assert.IsNotEmpty(eventTests.ToArray());
var eventIds = eventTests.Select(et => et.EventId);
var testIds = eventTests.Select(et => et.TestId);
var eventTestIds = eventTests.Select(et => et.Id);
Assert.IsTrue(eventIds.Contains(24762));
Assert.IsTrue(eventTestIds.Contains(196415));
Assert.IsTrue(eventTestIds.Contains(196414));
Assert.IsTrue(testIds.Contains(1));
Assert.IsTrue(testIds.Contains(3));
}
public bool AddMissingTestToEvent(long eventId, IEnumerable <long> testIds)
{
var eventtests = _eventTestRepository.GetTestsForEvent(eventId);
var existingtestIds = eventtests.Select(x => x.TestId).ToList();
var toBeAddedTests = testIds.Where(testId => !existingtestIds.Contains(testId)).ToList();
if (toBeAddedTests.Any())
{
foreach (var tobeAddedTest in toBeAddedTests)
{
_eventTestRepository.Save(new EventTest
{
TestId = tobeAddedTest,
EventId = eventId,
WithPackagePrice = (decimal)0.0,
Price = (decimal)0.0,
RefundPrice = (decimal)0.0,
ReimbursementRate = 0,
ShowInAlaCarte = true,
Gender = (long)Gender.Unspecified,
GroupId = (long)TestGroupType.None,
DateCreated = System.DateTime.Now,
DateModified = System.DateTime.Now
});
}
var theEvent = _eventRepository.GetById(eventId);
if (theEvent.IsDynamicScheduling)
{
var eventPods = _eventPodRepository.GetByEventId(eventId);
var eventPodIds = eventPods.Select(x => x.Id);
var eventPodRooms = _eventPodRoomRepository.GetByEventPodIds(eventPodIds);
foreach (var eventPodRoom in eventPodRooms)
{
_eventPodRoomRepository.SaveEventPodRoomTests(toBeAddedTests, eventPodRoom.Id);
}
}
}
return(true);
}
public void PollForTestUpsell()
{
var notificationTypes = _notificationTypeRepository.GetAll();
var notificationIsActive = notificationTypes.Any(nt => (nt.NotificationTypeAlias == NotificationTypeAlias.TestUpsellNotification) && nt.IsActive);
if (!notificationIsActive)
{
return;
}
var eventCustomers = _eventCustomerRepository.GetEventCustomersForTestUpsellNotification(1).ToArray();
if (!eventCustomers.Any())
{
return;
}
eventCustomers = eventCustomers.OrderBy(ec => ec.EventId).ToArray();
long eventId = 0;
IEnumerable <EventTest> eventTests = null;
foreach (var eventCustomer in eventCustomers)
{
try
{
if (eventId != eventCustomer.EventId)
{
eventId = eventCustomer.EventId;
eventTests = _eventTestRepository.GetTestsForEvent(eventId);
if (eventTests != null && eventTests.Any())
{
eventTests = eventTests.Where(et => et.Test.ShowInAlaCarte).Select(et => et).ToArray();
}
}
if (!eventTests.Any())
{
return;
}
var order = _orderRepository.GetOrder(eventCustomer.CustomerId, eventId);
var purchasedEventTestIds = new List <long>();
var packagePurchased = _eventPackageRepository.GetPackageForOrder(order.Id);
if (packagePurchased != null)
{
purchasedEventTestIds.AddRange(packagePurchased.Tests.Select(t => t.Id).ToList());
}
var testPurchased = _eventTestRepository.GetTestsForOrder(order.Id);
if (testPurchased != null && testPurchased.Any())
{
purchasedEventTestIds.AddRange(testPurchased.Select(t => t.Id));
}
var sendNotification = false;
IEnumerable <EventTest> notpurchasedEventTests = null;
if (purchasedEventTestIds == null || !purchasedEventTestIds.Any())
{
notpurchasedEventTests = eventTests;
sendNotification = true;
}
else
{
notpurchasedEventTests = eventTests.Where(et => !purchasedEventTestIds.Contains(et.Id)).Select(et => et).ToArray();
if (notpurchasedEventTests != null && notpurchasedEventTests.Any())
{
sendNotification = true;
}
}
if (sendNotification)
{
var customer = _customerRepository.GetCustomer(eventCustomer.CustomerId);
var tests = notpurchasedEventTests.Select(et => et.Test).ToArray();
var testUpsellNotificationModel = _emailNotificationModelsFactory.GetTestUpsellNotificationModel(customer, tests);
_notifier.NotifySubscribersViaEmail(NotificationTypeAlias.TestUpsellNotification, EmailTemplateAlias.TestUpsellNotification, testUpsellNotificationModel, customer.Id, customer.CustomerId, "TestUpsellNotification");
}
}
catch (Exception ex)
{
_logger.Error(string.Format("Test Upsell Notification Error For Customer Id : {0} and Event Id {1} \nMessage:{2} \nStackTrace: {3}", eventCustomer.CustomerId, eventCustomer.EventId, ex.Message, ex.StackTrace));
}
}
}
public JsonResult CheckPackageAndTestHafTemplate(long eventId, long customerId, long packageId, IEnumerable <long> testIds)
{
string message = string.Empty;
var currentOrder = _orderRepository.GetOrder(customerId, eventId);
var packageOrderItem = currentOrder.OrderDetails.FirstOrDefault(od => od.DetailType == OrderItemType.EventPackageItem && od.IsCompleted);
var testOrderItems = currentOrder.OrderDetails.Where(od => od.DetailType == OrderItemType.EventTestItem && od.IsCompleted);
var currentEventPackageId = (packageOrderItem != null) ? packageOrderItem.OrderItem.ItemId : 0;
long currentPackageId = 0;
EventPackage currentEventPackage = null;
EventPackage eventPackage = null;
if (currentEventPackageId > 0)
{
currentEventPackage = _eventPackageRepository.GetById(currentEventPackageId);
currentPackageId = currentEventPackage.PackageId;
}
eventPackage = packageId > 0 ? _eventPackageRepository.GetByEventAndPackageIds(eventId, packageId) : currentEventPackage;
var eventTests = _eventTestRepository.GetTestsForEvent(eventId);
var testPackageName = new List <string>();
if (packageId != currentPackageId)
{
if (eventPackage != null && eventPackage.HealthAssessmentTemplateId.HasValue)
{
testPackageName.Add(eventPackage.Package.Name);
}
}
var currentTestIds = new List <long>();
if (currentEventPackage != null)
{
currentTestIds.AddRange(currentEventPackage.Tests.Select(x => x.TestId));
}
if (!testOrderItems.IsNullOrEmpty())
{
var orderIds = testOrderItems.Select(x => x.OrderItem.ItemId);
var customerTests = eventTests.Where(x => orderIds.Contains(x.Id));
currentTestIds.AddRange(customerTests.Select(x => x.TestId));
}
var missingTest = currentTestIds.Where(x => !testIds.Contains(x));
if (!missingTest.IsNullOrEmpty())
{
var testNames = eventTests.Where(m => missingTest.Contains(m.TestId) && m.HealthAssessmentTemplateId.HasValue).Select(m => m.Test.Name);
if (!testNames.IsNullOrEmpty())
{
testPackageName.AddRange(testNames);
}
}
var newTestIds = testIds.Where(x => !currentTestIds.Contains(x));
if (!newTestIds.IsNullOrEmpty())
{
var testNames = eventTests.Where(m => newTestIds.Contains(m.TestId) && m.HealthAssessmentTemplateId.HasValue)
.Select(m => m.Test.Name);
if (!testNames.IsNullOrEmpty())
{
testPackageName.AddRange(testNames);
}
}
return(Json(testPackageName, JsonRequestBehavior.AllowGet));
}
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
});
}
