public List <App.Hours.Models.ScrubOverviewItem> GetScrubOverviewItems(DateTime startDate, DateTime endDate)
{
var data = new Data.Services.CaseService().GetCaseTimeScrubOverviewItems(startDate, endDate);
var items = new List <App.Hours.Models.ScrubOverviewItem>();
foreach (var dataItem in data)
{
var item = new App.Hours.Models.ScrubOverviewItem();
item.ID = dataItem.ID;
item.FirstName = dataItem.FirstName;
item.LastName = dataItem.LastName;
item.ActiveProviders = dataItem.ActiveProviders;
item.ProvidersFinalized = dataItem.ProvidersFinalized;
item.ProvidersWithHours = dataItem.ProvidersWithHours;
item.ScrubbedRecords = dataItem.ScrubbedRecords;
item.UnscrubbedRecords = dataItem.UnscrubbedRecords;
item.CommittedRecords = dataItem.CommitedRecords;
item.BilledRecords = dataItem.BilledRecords;
item.PaidRecords = dataItem.PaidRecords;
item.TotalPayable = dataItem.TotalPayable;
item.TotalBillable = dataItem.TotalBillable;
item.BCBABillable = dataItem.BCBABillable;
item.AideBillable = dataItem.AideBillable;
item.BCBAPercent = dataItem.BCBAPercent;
items.Add(item);
}
return(items);
}
public AddParentContactLogVM CreateParentContactLogVM(int caseId)
{
var caseService = new Data.Services.CaseService();
var relationships = caseService.GetGuardianRelationships();
var model = new AddParentContactLogVM
{
CaseId = caseId,
Relationships = relationships
};
return(model);
}
public IEnumerable <CaseHoursListItemVM> GetProviderHours(int providerID, DateTime selectedDate)
{
var hours = new Data.Services.CaseService()
.GetCaseHoursByProvider(providerID, selectedDate)
.Where(
x => (
x.Status == AuthorizationHoursStatus.FinalizedByProvider ||
x.Status == AuthorizationHoursStatus.ScrubbedByAdmin ||
x.Status == AuthorizationHoursStatus.ProcessedComplete
) &&
(x.Date >= selectedDate) &&
(x.Date < selectedDate.AddMonths(1))
)
.OrderBy(x => x.Case.Patient.FirstName)
.ThenBy(x => x.Case.Patient.LastName)
.ThenBy(x => x.Date)
.ThenBy(x => x.TimeIn)
.ToList();
var items = hours.Select(hour => new CaseHoursListItemVM
{
AuthCode = hour.Authorization?.Code,
Billable = hour.BillableHours,
CaseAuthID = hour.Authorization?.ID,
Date = hour.Date,
Hours = hour.HoursTotal,
HoursID = hour.ID.Value,
Notes = hour.Notes,
Payable = hour.PayableHours,
PatientName = hour.Case.Patient.CommonName,
StatusCode = GetTimeBillStatusCodeDisplay(hour.Status),
StatusID = hour.Status,
Service = hour.Service,
TimeIn = hour.TimeIn,
TimeOut = hour.TimeOut,
Paid = hour.PayableRef == null ? false : true,
Billed = hour.BillingRef == null ? false : true,
HasCatalystData = hour.HasCatalystData,
CaseAuth = hour.Authorization != null ? new TimeBillGridAuthItemVM
{
ID = hour.Authorization.CaseAuthorizationID,
Code = hour.Authorization.Code
} : null
});
return(items);
}
public static System.Collections.IEnumerable GetAppointments(int caseID, int providerID)
{
var cutoffDate = GetCurrentHoursHistoryCutoff();
var caseHours = new Data.Services.CaseService().GetCaseHoursByCaseByProvider(caseID, providerID, cutoffDate)
.Where(m => m.Status != Domain.Cases.AuthorizationHoursStatus.PreCheckedOnApp)
.ToList();
// return appointments
var appts = AppointmentDTO.MapFromDomainAppointments(caseHours).ToList();
// only map catalyst hours if we're an Aide
// (BCBA notes handling is not yet implemented)
if (AppService.Current.CurrentProvider.ProviderTypeID == (int)Domain2.Providers.ProviderTypeIDs.Aide)
{
var catalystHours = new App.Hours.HoursService().GetCatalystPreloads(caseID, providerID, cutoffDate);
appts.AddRange(AppointmentDTO.MapFromCatalystPreloadEntries(catalystHours));
}
return(appts);
}
public List <ParentContactLogListItemVM> LoadParentContactLogVM(int caseId)
{
var caseService = new Data.Services.CaseService();
var relationships = caseService.GetGuardianRelationships().ToDictionary(k => k.ID, v => v.Name);
var log = Context.StaffingLogParentContactLog
.Where(l => l.StaffingLogID == caseId)
.OrderByDescending(l => l.ContactDate)
.ToList()
.Select(l => new ParentContactLogListItemVM
{
ContactDate = l.ContactDate,
Notes = l.Notes,
ContactedPerson = relationships[l.GuardianRelationshipID] +
(!string.IsNullOrWhiteSpace(l.ContactedPersonName)
? " (" + l.ContactedPersonName + ")"
: ""),
ContactMethod = l.ContactMethodType.ToString() + " (" + l.ContactMethodValue + ")"
})
.ToList();
return(log);
}
public static List <Domain.Cases.Service> GetServices(int?providerTypeID, bool returnSSG = false)
{
var caseService = new Data.Services.CaseService();
List <Domain.Cases.Service> services;
if (providerTypeID.HasValue)
{
services = caseService.GetServicesByProviderType(providerTypeID.Value);
}
else
{
services = caseService.GetServices();
}
if (returnSSG)
{
return(services);
}
else
{
return(services.Where(x => x.Code != "SSG").ToList());
}
}
public StaffingLogVM CreateStaffingLogVM(int caseId, StaffingLog staffingLog)
{
StaffingLogVM model = null;
var patient = Context.Patients.SingleOrDefault(m => m.Cases.Any(c => c.ID == caseId));
if (patient != null)
{
var @case = Context.Cases.SingleOrDefault(m => m.ID == caseId);
var zipInfoRepository = new ZipInfoRepository();
var caseService = new Data.Services.CaseService();
var guardianRelationships = caseService.GetGuardianRelationships();
model = new StaffingLogVM
{
PatientID = patient.ID,
CaseID = caseId,
FirstName = patient.FirstName,
LastName = patient.LastName,
DateOfBirth = patient.DateOfBirth,
Email = patient.Email,
Phone = patient.Phone,
Address1 = patient.Address1,
Address2 = patient.Address2,
City = patient.City,
State = patient.State,
Zip = patient.Zip,
County = zipInfoRepository.GetCounty(patient.Zip),
Guardians = new List <GuardianInfoVM> {
new GuardianInfoVM {
FirstName = patient.GuardianFirstName,
LastName = patient.GuardianLastName,
Relationship = GetGuardianRelationship(patient.GuardianRelationshipID, guardianRelationships),
Email = patient.GuardianEmail,
CellPhone = patient.GuardianCellPhone,
HomePhone = patient.GuardianHomePhone,
WorkPhone = patient.GuardianWorkPhone,
Notes = patient.GuardianNotes
},
new GuardianInfoVM {
FirstName = patient.Guardian2FirstName,
LastName = patient.Guardian2LastName,
Relationship = GetGuardianRelationship(patient.Guardian2RelationshipID, guardianRelationships),
Email = patient.Guardian2Email,
CellPhone = patient.Guardian2CellPhone,
HomePhone = patient.Guardian2HomePhone,
WorkPhone = patient.Guardian2WorkPhone,
Notes = patient.Guardian2Notes
},
new GuardianInfoVM
{
FirstName = patient.Guardian3FirstName,
LastName = patient.Guardian3LastName,
Relationship = GetGuardianRelationship(patient.Guardian3RelationshipID, guardianRelationships),
Email = patient.Guardian3Email,
CellPhone = patient.Guardian3CellPhone,
HomePhone = patient.Guardian3HomePhone,
WorkPhone = patient.Guardian3WorkPhone,
Notes = patient.Guardian3Notes
}
},
FunctioningLevel = @case.FunctioningLevel?.Name,
Notes = patient.Notes,
CaseProviders = Context.CaseProviders
.Where(m => m.CaseID == caseId)
.ToList()
.Select(m => new CaseProviderVM
{
ProviderID = m.Provider.ID,
ProviderLastName = m.Provider.LastName,
ProviderFirstName = m.Provider.FirstName,
ProviderType = m.Provider.GetProviderTypeFullCode(),
IsBCBA = m.Provider.IsBCBA,
IsActive = CaseIsActive(DateTime.Now, m.StartDate, m.EndDate)
})
.OrderByDescending(m => m.IsActive)
.ThenByDescending(m => m.IsBCBA)
.ThenBy(m => m.ProviderLastName)
.ThenBy(m => m.ProviderFirstName),
SystemSpecialAttentionNeeds = Context.SpecialAttentionNeeds
.Where(n => n.Active)
.Select(n => new SpecialAttentionNeedVM
{
ID = n.ID,
Code = n.Code,
Name = n.Name
})
.ToList(),
SpecialAttentionNeedIDs = staffingLog.SpecialAttentionNeeds != null?staffingLog.SpecialAttentionNeeds.Select(n => n.ID).ToList() : new List <int>(),
ParentalRestaffRequest = staffingLog.ParentalRestaffRequest,
HoursOfABATherapy = staffingLog.HoursOfABATherapy,
AidesRespondingNo = staffingLog.AidesRespondingNo,
AidesRespondingMaybe = staffingLog.AidesRespondingMaybe,
ScheduleRequest = ScheduleRequestVM.FromInt(staffingLog.ScheduleRequest),
DateWentToRestaff = staffingLog.DateWentToRestaff,
ProviderGenderPreference = string.IsNullOrEmpty(staffingLog.ProviderGenderPreference) ? '0' : staffingLog.ProviderGenderPreference[0]
};
}
return(model);
}
public AutoPopulateHoursRepository()
{
caseService = new Data.Services.CaseService();
connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["CoreConnection"].ConnectionString;
}
public HomeRepository(Data.V2.CoreContext context)
{
caseService = new Data.Services.CaseService();
connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["CoreConnection"].ConnectionString;
_context = context;
}
public List <ValidationItemVM> GetValidationItems(DateTime period, bool fullRefresh)
{
if (!fullRefresh)
{
var cachedItems = getValidationItemsFromCache(period);
if (cachedItems != null)
{
return(cachedItems);
}
}
var items = new List <ValidationItemVM>();
var caseService = new Data.Services.CaseService();
var validator = new DomainServices.Hours.CrossHoursValidation(caseService, period);
validator.Validate();
int i = 0;
foreach (var err in validator.Errors)
{
var item = new App.Hours.Models.ValidationItemVM();
var coreContext = new Data.Models.CoreEntityModel();
var sourcePatient = coreContext.Cases.Find(err.MatchedOn.CaseID.Value).Patient;
var sourceProvider = coreContext.Providers.Find(err.MatchedOn.ProviderID);
item.GridID = i;
i++;
item.SourceCaseID = err.MatchedOn.CaseID.Value;
item.SourceDate = err.MatchedOn.Date;
item.SourceHoursID = err.MatchedOn.ID.Value;
item.SourcePatientName = sourcePatient.PatientFirstName + " " + sourcePatient.PatientLastName;
item.SourceProviderID = err.MatchedOn.ProviderID;
item.SourceProviderName = sourceProvider.ProviderFirstName + " " + sourceProvider.ProviderLastName;
item.SourceServiceCode = err.MatchedOn.ServiceCode;
item.SourceTimeIn = err.MatchedOn.TimeIn;
item.SourceTimeOut = err.MatchedOn.TimeOut;
item.TypeValue = err.ErrorType;
if (err.MatchedTo != null && err.MatchedTo.Count > 0)
{
var m = err.MatchedTo[0];
var patient = coreContext.Cases.Find(m.CaseID.Value).Patient;
var provider = coreContext.Providers.Find(m.ProviderID);
item.PartnerCaseID = m.CaseID.Value;
item.PartnerDate = m.Date;
item.PartnerHoursID = m.ID.Value;
item.PartnerPatientName = patient.PatientFirstName + " " + patient.PatientLastName;
item.PartnerProviderID = m.ProviderID;
item.PartnerProviderName = provider.ProviderFirstName + " " + provider.ProviderLastName;
item.PartnerServiceCode = m.ServiceCode;
item.PartnerTimeIn = m.TimeIn;
item.PartnerTimeOut = m.TimeOut;
}
items.Add(item);
}
setValidateItemsCache(items, period);
return(items);
}
