public ValidationResults Validate(Domain2.Hours.Hours entry, EntryApp entryApp, bool isOnAideLegacyMode)
{
if (entry.Provider.IsAide && isOnAideLegacyMode)
{
if (string.IsNullOrWhiteSpace(entry.Memo))
{
return(new ValidationResults {
IsValid = false, Errors = new[] { "Notes are required for this entry." }
});
}
if (entryApp != EntryApp.ProviderApp && !ValidateMemo(entry.Memo))
{
return(new ValidationResults {
IsValid = false, Errors = new[] { "Note must be at least 3 sentences, with at least 18 characters per sentence." }
});
}
}
else if (entry.Provider.IsBCBA && (entry.ExtendedNotes == null || entry.ExtendedNotes.Count < 3))
{
return(new ValidationResults {
IsValid = false, Errors = new[] { "A minimum of three notes are required for this entry." }
});
}
return(new ValidationResults {
IsValid = true
});
}
public void NormalizeCoreData(EntryApp entryApp)
{
foreach (var entry in ProposedEntries)
{
entry.Date = entry.Date.Date; // trim time from date
entry.EntryApp = GetEntryAppString(entryApp);
entry.TotalHours = (decimal)(entry.EndTime - entry.StartTime).TotalHours;
if (!UseExplicitPayableValue)
{
entry.PayableHours = entry.TotalHours;
}
if (!UseExplicitBillableValue)
{
if (entry.IsTrainingEntry)
{
entry.BillableHours = 0;
}
else
{
entry.BillableHours = entry.TotalHours;
}
}
}
}
public ValidationIssueCollection GetResults(EntryApp entryApp)
{
// assume Prepare() has been called already
if (_preparedService == null)
{
throw new InvalidOperationException("Cannot run this version of GetResults without first preparing the service");
}
return(_preparedService.Resolve(entryApp));
}
private string GetEntryAppString(EntryApp value)
{
switch (value)
{
case EntryApp.Unknown: return(null);
case EntryApp.Manage: return("Manage");
case EntryApp.ProviderApp: return("Provider App");
case EntryApp.ProviderPortal: return("Provider Portal");
default: return(null);
}
}
public ValidationIssueCollection Resolve(EntryApp entryApp)
{
this.EntryApp = entryApp;
NormalizeCoreData(entryApp);
if (!new CoreValidations(this, _repository).Resolve())
{
return(Issues);
}
// ensure all entries have IDs
foreach (var entry in ProposedEntries)
{
if (entry.ID == 0)
{
_repository.SaveEntry(entry);
}
}
// resolves any additional SSG entries and adds them to the ProposedHours queue
// removes any orphaned SSGs as well
// IMPORTANT: don't reposition this, it needs to come before Case/Provider Auths
if (!new SSGResolution(this, _repository).Resolve())
{
return(Issues);
}
if (!new CaseAndProviderValidations(this).Resolve())
{
return(Issues);
}
if (!new AuthorizationResolution(_repository, HoursResolutionLoggingService.Create()).Resolve(ProposedEntries))
{
return(Issues);
}
if (!new ScheduleResolution(this).Resolve())
{
return(Issues);
}
return(Issues);
}
public HoursEntryControllerBase(TService service, EntryApp entryApp = EntryApp.Unknown)
{
Service = service;
EntryApp = entryApp;
}
public HoursEntryResponseVM SubmitHoursRequest(BaseHoursEntryRequestVM request, EntryApp entryApp, bool isOnAideLegacyMode)
{
// this runs when an application is saving a full entry
// all information is present
// validation should have been done already, but we run again for good measure
// this entry is saved to the database if valid
if (EntryMode == HoursEntryMode.ManagementEntry)
{
request.IgnoreWarnings = true;
}
var resolutionDataContext = new CoreContext();
var helper = new HoursResolutionHelper(resolutionDataContext);
var entry = helper.GetHoursObject(request, isOnAideLegacyMode);
helper.Prepare(entry, EntryMode);
using (var transaction = resolutionDataContext.Database.BeginTransaction())
{
helper.Transaction = transaction;
try
{
var issues = helper.GetResults(entryApp);
if (issues.HasErrors || (issues.HasWarnings && !request.IgnoreWarnings.GetValueOrDefault()))
{
Rollback(transaction);
return(new HoursEntryResponseVM
{
HoursID = request.HoursID,
WasProcessed = false,
Messages = helper.GetResponseMessages(issues)
});
}
var signatureType = "image/png";
if (request.HasSignatures)
{
entry.SessionSignature = new SessionSignature
{
ProviderSignature = request.Signatures[0].Base64Signature,
ProviderName = request.Signatures[0].Name,
ProviderSignatureType = signatureType,
ParentSignature = request.Signatures[1].Base64Signature,
ParentName = request.Signatures[1].Name,
ParentSignatureType = signatureType
};
}
if (request.AllowHasDataChanges)
{
entry.HasCatalystData = request.HasData;
}
if (request.CatalystPreloadID.HasValue)
{
entry.HasCatalystData = true;
var preload = resolutionDataContext.CatalystPreloadEntries.Find(request.CatalystPreloadID.Value);
if (preload != null)
{
preload.IsResolved = true;
}
}
resolutionDataContext.SaveChanges();
transaction.Commit();
return(new HoursEntryResponseVM
{
HoursID = request.HoursID,
WasProcessed = true,
});
}
catch (Exception e)
{
Rollback(transaction);
Exceptions.Handle(e);
return(new HoursEntryResponseVM
{
HoursID = request.HoursID,
WasProcessed = false,
Messages = new List <HoursEntryResponseMessage> {
new HoursEntryResponseMessage {
Severity = MessageSeverity.Error,
Message = "We're sorry, but an unknown error has occurred. Please contact your system administrator for more information."
}
}
});
}
}
}
public HoursEntryResponseVM SubmitHoursForValidation(BaseHoursEntryRequestVM request, EntryApp entryApp, bool isOnAideLegacyMode)
{
// this runs when an application is validating a full entry
// all information is present
// nothing is saved: this is for validation only
var resolutionDataContext = new CoreContext();
using (var transaction = resolutionDataContext.Database.BeginTransaction())
{
var helper = new HoursResolutionHelper(resolutionDataContext);
try
{
var entry = helper.GetHoursObject(request, isOnAideLegacyMode);
var issues = helper.GetResults(entry, EntryMode, entryApp, EntryType.Full);
if (issues.HasErrors || (issues.HasWarnings && !request.IgnoreWarnings.GetValueOrDefault()))
{
Rollback(transaction);
return(new HoursEntryResponseVM
{
HoursID = request.HoursID,
WasProcessed = false,
Messages = helper.GetResponseMessages(issues)
});
}
return(new HoursEntryResponseVM
{
HoursID = request.HoursID
});
}
catch (Exception e)
{
Exceptions.Handle(e);
return(new HoursEntryResponseVM
{
HoursID = request.HoursID,
WasProcessed = false,
Messages = new List <HoursEntryResponseMessage> {
new HoursEntryResponseMessage {
Severity = MessageSeverity.Error,
Message = "We're sorry, but an unknown error has occurred. Please contact your system administrator for more information."
}
}
});
}
finally
{
// we're just validating, don't actually submit all of these changes
Rollback(transaction);
}
}
}
public ValidationIssueCollection GetResults(List <Hours> entries, HoursEntryMode entryMode, EntryApp entryApp)
{
return(GetResults(entries, entryMode, entryApp, EntryType.Full));
}
public ValidationIssueCollection GetResults(Hours entry, HoursEntryMode entryMode, EntryApp entryApp)
{
return(GetResults(new List <Hours>()
{
entry
}, entryMode, entryApp, EntryType.Full));
}
public ValidationIssueCollection GetResults(List <Hours> entries, HoursEntryMode entryMode, EntryApp entryApp, EntryType entryType, bool isPrecheck = false)
{
var repo = new ResolutionServiceRepository(_context);
var service = new ResolutionService(entries, repo)
{
EntryMode = entryMode,
EntryType = entryType,
IsPreCheck = isPrecheck
};
return(service.Resolve(entryApp));
}
public ValidationIssueCollection GetResults(Hours entry, HoursEntryMode entryMode, EntryApp entryApp, EntryType entryType, bool isPrecheck = false)
{
return(GetResults(new List <Hours> {
entry
}, entryMode, entryApp, entryType, isPrecheck));
}
