private void HandleSavePayorCovergeCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DtoResponse <PayorCoverageCacheDto> > ();
PayorCoverage = response.DataTransferObject;
IsLoading = false;
if (!PayorCoverage.HasErrors)
{
_popupService.ClosePopup("EditPayorCoverageView");
}
else
{
if (PayorCoverage.Key == 0)
{
PayorCoverage.EditStatus = EditStatus.Create;
}
var errorMessageBuilder = new StringBuilder();
foreach (var dataErrorInfo in response.DataTransferObject.DataErrorInfoCollection.Where(e => e.DataErrorInfoType == DataErrorInfoType.ObjectLevel))
{
errorMessageBuilder.Append(dataErrorInfo.Message + "\n");
}
var message = errorMessageBuilder.ToString();
if (!string.IsNullOrWhiteSpace(message))
{
_userDialogService.ShowDialog(message, "Error Saving Payor", UserDialogServiceOptions.Ok);
}
}
}
private void LookupValueRequestDispatcherCompleted(ReceivedResponses receivedResponses)
{
IDictionary <string, ObservableCollection <LookupValueDto> > localLookupValueLists =
new Dictionary <string, ObservableCollection <LookupValueDto> > ();
var responses = from response in receivedResponses.Responses
where typeof(GetLookupValuesResponse).IsAssignableFrom(response.GetType())
select response;
foreach (GetLookupValuesResponse response in responses)
{
var lookupValueDtos = new ObservableCollection <LookupValueDto> (response.LookupValues);
if (response.Name == "PatientGender")
{
var genderList = from item in lookupValueDtos orderby item.WellKnownName select item;
localLookupValueLists.Add(response.Name, new ObservableCollection <LookupValueDto> (genderList));
}
else
{
localLookupValueLists.Add(response.Name, lookupValueDtos);
}
}
LookupValueLists = localLookupValueLists;
IsLoading = false;
}
private void HandleGetAllJobFunctionsCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DtoResponse <JobFunctionSystemRolesDto> > ();
var validationErrors = response.DataTransferObject.DataErrorInfoCollection.ToList();
ProcessSystemRoleResponses(response.DataTransferObject.SystemRoles, validationErrors);
}
private void GetLocationsByAgencyCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetLocationsByAgencyResponse> ();
LocationsList = response.Locations;
IsLoading = false;
}
private void GetStaffsByAgencyCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetStaffsByAgencyResponse> ();
var staffSummaryDtos = new ObservableCollection <StaffSummaryDto> (response.Staffs);
StaffList = staffSummaryDtos;
}
private void HandleDeletePatientDocumentCompleted(ReceivedResponses receivedResponses)
{
IsLoading = false;
var response = receivedResponses.Get <DeletePatientDocumentResponse> ();
PatientDocumentDtos = new ObservableCollection <PatientDocumentDto> (response.PatientDocumentDtos);
}
private void MedicationFormStrengthRequestCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <MedicationFormStrengthResponse> ();
DTSInfo = response.DTSInfo;
_dtsMedicationCode = GetCodedConceptDto(response.MainCode);
RaisePropertyChanged(() => DtsMedicationCode);
if (Medication != null && Medication.MedicationCodeCodedConcept != null)
{
var origDrugConcept =
response.DTSInfo.Drugs.FirstOrDefault(d => d.Code == Medication.MedicationCodeCodedConcept.CodedConceptCode);
if (origDrugConcept == null)
{
response.DTSInfo.SelectedStrength =
response.DTSInfo.Strengths.FirstOrDefault(s => s.Code == Medication.MedicationCodeCodedConcept.CodedConceptCode);
response.DTSInfo.SelectedForm =
response.DTSInfo.Forms.FirstOrDefault(f => f.Code == Medication.MedicationCodeCodedConcept.CodedConceptCode);
}
else
{
response.DTSInfo.SelectedStrength =
response.DTSInfo.Strengths.FirstOrDefault(
s => origDrugConcept.Associations.SelectMany(a => a.Value).Contains(s.Code));
response.DTSInfo.SelectedForm =
response.DTSInfo.Forms.FirstOrDefault(f => origDrugConcept.Associations.SelectMany(a => a.Value).Contains(f.Code));
}
Medication.RootMedicationCodedConcept = GetCodedConceptDto(response.MainCode);
}
else if (Medication != null)
{
Medication.MedicationCodeCodedConcept = GetCodedConceptDto(response.MainCode);
Medication.RootMedicationCodedConcept = GetCodedConceptDto(response.MainCode);
}
IsLoading = false;
}
private void HandleDeleteSystemRoleCompleted(ReceivedResponses receivedResponses)
{
IsLoading = false;
var response = receivedResponses.Get <DeleteTaskOrTaskGroupResponse> ();
var validationErrors = response.DataTransferObject.DataErrorInfoCollection.ToList();
if (validationErrors.Count() == 0)
{
var taskAndTaskGroupSystemRoleList = response.TaskAndTaskGroupSystemRoles.SystemRoles;
PagedCollectionViewWrapper.WrapInPagedCollectionView(taskAndTaskGroupSystemRoleList, (p => true));
}
else
{
var errors = new StringBuilder();
errors.AppendLine("The following errors occurred:");
foreach (var validationError in validationErrors)
{
errors.AppendLine(validationError.Message);
}
_userDialogService.ShowDialog(errors.ToString(), "Errors", UserDialogServiceOptions.Ok);
}
}
/// <summary>
/// Requests the completed.
/// </summary>
/// <param name="receivedResponses">The received responses.</param>
protected override void RequestCompleted(ReceivedResponses receivedResponses)
{
base.RequestCompleted(receivedResponses);
var responseAuditDto = receivedResponses.Get <DtoResponse <AuditDto> > ();
EditingDto = responseAuditDto.DataTransferObject;
}
private void HandleSavePatientDocumentCompleted(ReceivedResponses receivedResponses)
{
IsLoading = false;
var response = receivedResponses.Get <DtoResponse <PatientDocumentDto> > ();
var results = response.DataTransferObject;
if (results.HasErrors)
{
var errorMessageSb = new StringBuilder();
foreach (var dataErrorInfo in results.DataErrorInfoCollection)
{
errorMessageSb.AppendLine(dataErrorInfo.ToString());
}
var errorMessage = errorMessageSb.ToString();
if (!string.IsNullOrEmpty(errorMessage))
{
_userDialogService.ShowDialog(errorMessage, "Save Patient Document", UserDialogServiceOptions.Ok);
}
}
else
{
var patientDocumentUploadedEvent = new PatientDocumentUploadedEventArgs
{
PatientKey = PatientDocumentDto.PatientKey
};
RaiseViewClosing();
_eventAggregator.GetEvent <PatientDocumentUploadedEvent> ().Publish(patientDocumentUploadedEvent);
}
}
private void HandleCreateCompleted(ReceivedResponses receivedResponses)
{
IsLoading = false;
var response = receivedResponses.Get <DtoResponse <BillingOfficeDto> > ();
var billingOfficeDto = response.DataTransferObject;
if (billingOfficeDto.HasErrors)
{
var errorBuilder = new StringBuilder();
foreach (var error in billingOfficeDto.DataErrorInfoCollection)
{
errorBuilder.Append(error.Message + "\n");
}
_userDialogService.ShowDialog(errorBuilder.ToString(), "Failed Creating Billing Office", UserDialogServiceOptions.Ok);
}
else
{
_navigationService.Navigate(
"WorkspacesRegion",
"BillingAdministrationWorkspaceView",
null,
new KeyValuePair <string, string> ("BillingOfficeKey", billingOfficeDto.Key.ToString()),
new KeyValuePair <string, string> ("IsCreate", true.ToString()));
_popupService.ClosePopup("CreateBillingOfficeView");
_eventAggregator.GetEvent <HasBillingOfficeEvent> ().Publish(new EventArgs());
}
}
public override Message OnReceiveMessage(Message message)
{
if (message.GetType() != typeof(Response))
{
throw new NotImplementedException();
}
var response = (Response)message;
lock (ReceivedResponses) {
// if duplicated response, ignore
if (ReceivedResponses.ContainsKey(response.Request.SeqNum))
{
return(null);
}
ReceivedResponses.Add(response.Request.SeqNum, response);
}
// if it receives at least one response for a blocking request then unblock ( can only send one and then block, so it will always unblock properly? )
if (response.Request.GetType() == typeof(ReadRequest) ||
response.Request.GetType() == typeof(TakeRequest))
{
if (RequestSemaphore.TryGetValue(response.Request.SeqNum, out var semaphore))
{
semaphore.Release();
return(null);
}
throw new NotImplementedException("No semaphore was allocated.");
}
return(null);
}
private void HandleCreateNewStaffCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <CreateNewStaffResponse> ();
var result = response.StaffNameDto;
if (result.HasErrors)
{
FirstName = result.FirstName;
LastName = result.LastName;
MiddleInitial = result.MiddleInitial;
var errors = new StringBuilder();
IsMIRequired = true;
result.DataErrorInfoCollection.ForEach(error => errors.AppendLine(error.Message));
HasErrors = true;
_userDialogService.ShowDialog(errors.ToString(), "Add Staff", UserDialogServiceOptions.Ok);
}
else
{
HasErrors = false;
if (SearchCommunicater.ItemAddedCommand != null && SearchCommunicater.ItemAddedCommand.CanExecute(result.Key))
{
SearchCommunicater.ItemAddedCommand.Execute(result.Key);
}
}
}
private void HandleSavePayorCoverageCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DtoResponse <PayorCoverageCacheDto> >();
if (response.DataTransferObject.HasErrors)
{
var errorMessageBuilder = new StringBuilder();
foreach (var dataErrorInfo in response.DataTransferObject.DataErrorInfoCollection)
{
errorMessageBuilder.Append(dataErrorInfo.Message + "\n");
}
_userDialogService.ShowDialog(errorMessageBuilder.ToString(), "Error Deleting Payor", UserDialogServiceOptions.Ok);
}
else
{
var payorToDelete = Primary.FirstOrDefault(pc => pc.Key == response.DataTransferObject.Key);
if (payorToDelete != null)
{
Primary.Remove(payorToDelete);
}
else if ((payorToDelete = Secondary.FirstOrDefault(pc => pc.Key == response.DataTransferObject.Key)) != null)
{
Secondary.Remove(payorToDelete);
}
else if ((payorToDelete = Tertiary.FirstOrDefault(pc => pc.Key == response.DataTransferObject.Key)) != null)
{
Tertiary.Remove(payorToDelete);
}
else if ((payorToDelete = PayorCoverageHistory.FirstOrDefault(pc => pc.Key == response.DataTransferObject.Key)) != null)
{
PayorCoverageHistory.Remove(payorToDelete);
}
}
IsLoading = false;
}
private void SaveLabResultCompleted(ReceivedResponses receivedResponses)
{
IsLoading = false;
PostProcessing = true;
PreProcessing = false;
var response = receivedResponses.Get <SaveLabResultResponse> ();
if (response.ErrorMessages.Count > 0)
{
var errorMessages = new StringBuilder();
response.ErrorMessages.ForEach(
em =>
{
errorMessages.AppendLine(em);
errorMessages.AppendLine();
});
UserMessage = errorMessages.ToString();
ErrorState = true;
}
else
{
UserMessage = "Lab Result has been successfully saved.";
EnableSave = false;
}
}
private void HandleRequestCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetClinicianPatientsResponse> ();
PatientList = response.PatientList;
IsLoading = false;
}
private void HandleRequestComplete(ReceivedResponses receivedResponses)
{
HandleGetLookupValuesCompleted(receivedResponses);
if (!_isCreate)
{
GetProblemByKeyCompleted(receivedResponses);
}
else
{
//TODO: The following code is for current requirement
var problemTypeList = LookupValueLists[ProblemTypeLookupName];
if (problemTypeList != null && problemTypeList.Count >= 0)
{
Problem.ProblemType = problemTypeList.First(p => p.WellKnownName == ProblemType.Diagnosis);
}
var problemStatusList = LookupValueLists[ProblemStatusLookupName];
if (problemStatusList != null)
{
Problem.ProblemStatus = problemStatusList.First(p => p.WellKnownName == ProblemStatus.Active);
}
var staffDto = receivedResponses.Get <DtoResponse <StaffSummaryDto> > ();
Problem.ObservedByStaff = staffDto.DataTransferObject;
}
}
private void HandleGetClinicalCaseSummaryRequestCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DtoResponse <CaseSummaryDto> > ();
CaseSummary = response.DataTransferObject;
IsLoading = false;
}
private void HandleGetAvailableProgramOfferingLocationsCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetAvailableProgramOfferingLocationsResponse> ();
ProgramEnrollment.Location = null;
AvailableProgramOfferingLocations = response.ProgramOfferingLocations;
}
private void PatientListSearchRequestComplete(ReceivedResponses responses)
{
var response = responses.Get <PatientListSearchResponse> ();
PatientList = response.PatientList;
IsLoading = false;
}
private void HandleImportC32Completed(ReceivedResponses receivedResponse)
{
var response = receivedResponse.Get <ImportC32Response> ();
IsLoading = false;
ExecuteCancelCommand();
}
/// <summary>
/// Requests the completed.
/// </summary>
/// <param name="receivedResponses">The received responses.</param>
protected override void RequestCompleted(ReceivedResponses receivedResponses)
{
base.RequestCompleted(receivedResponses);
//Publish visit changed event.
var visitChangedEventArgs = new VisitChangedEventArgs
{
Sender = this,
VisitKey = EditingDto.VisitKey,
ClinicianKey = EditingDto.ClinicianKey,
PatientKey = EditingDto.PatientKey,
VisitStartDateTime = EditingDto.AppointmentStartDateTime
};
_eventAggregator.GetEvent <VisitChangedEvent> ().Publish(visitChangedEventArgs);
var activityChangedEventArgs = new ActivityChangedEventArgs
{
Sender = this,
VisitKey = EditingDto.VisitKey,
ClinicianKey = EditingDto.ClinicianKey,
PatientKey = EditingDto.PatientKey
};
_eventAggregator.GetEvent <ActivityChangedEvent> ().Publish(activityChangedEventArgs);
if (EditingDto.IsDast10ResultChanged)
{
_userDialogService.ShowDialog("DAST-10 guidance has been changed.", "Notification", UserDialogServiceOptions.Ok);
}
}
private void HandleGetSystemAccountsByAdvancedSearchCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetSystemAccountsByAdvancedSearchResponse> ();
var result = response.PagedSystemAccountSearchResultDto;
if (result != null)
{
if (result.PagedList.Count > 0)
{
ChangeSearchState(
SearchState.AdvancedSearchFoundState,
new PagedCollectionView(result.PagedList),
result.PageIndex,
result.PageSize,
result.TotalCount);
}
else
{
ChangeSearchState(
SearchState.AdvancedSearchNotFoundState,
new PagedCollectionView(result.PagedList),
result.PageIndex,
result.PageSize,
result.TotalCount);
}
}
else
{
ChangeSearchState(SearchState.AdvancedSearchNotFoundState, null);
}
IsLoading = false;
}
private void HandleSentTestResponse(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DroolsTestResponse> ();
Results = response.C32Reponse;
IsLoading = false;
}
private void HandleGetPatientsByAdvancedSearchCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetPatientsByAdvancedSearchResponse> ();
var result = response.PagedPatientSearchResultDto;
if (result != null)
{
if (result.PagedList.Count > 0)
{
ChangeSearchState(
SearchState.AdvancedSearchFoundState,
new PagedCollectionView(result.PagedList),
result.PageIndex,
result.PageSize,
result.TotalCount);
}
else
{
ChangeSearchState(
SearchState.AdvancedSearchNotFoundState,
new PagedCollectionView(result.PagedList),
result.PageIndex,
result.PageSize,
result.TotalCount);
}
}
else
{
ChangeSearchState(SearchState.AdvancedSearchNotFoundState, null);
}
(AddNewCommand as DelegateCommandBase).RaiseCanExecuteChanged();
IsLoading = false;
}
private void NavigatedToRequestDispatcherCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DtoResponse <BriefInterventionDto> > ();
EditingDto = response.DataTransferObject;
IsLoading = false;
}
private void HandleGetPatientAccessHistoryBySearchCriteriaCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <GetPatientAccessHistoryBySearchCriteriaResponse> ();
var result = response.PagedPatientAccessEventSearchResultDto;
TotalItemCount = result.TotalCount;
PatientAccessEvents = new PagedCollectionView(result.PagedList);
_patientAccessEvents.GroupDescriptions.Clear();
_patientAccessEvents.SortDescriptions.Clear();
IsLoading = false;
if (_selectedGroupingDescription != _defaultGroupingDescription)
{
_patientAccessEvents.GroupDescriptions.Add(_selectedGroupingDescription);
_patientAccessEvents.SortDescriptions.Add(
new SortDescription(_selectedGroupingDescription.PropertyName, ListSortDirection.Ascending));
}
if (SortBy != null)
{
_patientAccessEvents.SortDescriptions.Add(new SortDescription(SortBy, SortDirection));
}
IsLoading = false;
}
private void GetVitalSignByActivityKeyCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <DtoResponse <VitalSignDto> > ();
EditingDto = response.DataTransferObject;
IsLoading = false;
}
private void ResponsesReceived(ReceivedResponses receivedResponses)
{
if (receivedResponses.HasResponse <GetUserGroupResponse>())
{
BindingModel.Populate(receivedResponses.Get <GetSuitableParentUserGroupsResponse>().SuitableParentUserGroups,
receivedResponses.Get <GetUserGroupResponse>().UserGroup);
}
else
{
BindingModel.Populate(receivedResponses.Get <GetSuitableParentUserGroupsResponse>().SuitableParentUserGroups);
}
if (receivedResponses.HasResponse <CheckPermissionsResponse>())
{
var response = receivedResponses.Get <CheckPermissionsResponse>();
if (!response.AuthorizationResults[Permissions.DeleteUserGroup])
{
View.PreventDeletion();
}
if (!response.AuthorizationResults[Permissions.EditUserGroup])
{
View.PreventModification();
}
}
View.Show();
}
private void HandleResetTestDataCompleted(ReceivedResponses receivedResponses)
{
var response = receivedResponses.Get <ResetTestDataResponse> ();
GetAllClaimBatches();
IsLoading = false;
}
private void BatchRequestsSucceeded(ReceivedResponses receivedResponses)
{
var helloWorldResponse = receivedResponses.Get<HelloWorldResponse>();
var getServerDateResponse = receivedResponses.Get<GetServerDateResponse>();
AddSucceededRequestsToView("Batch response", helloWorldResponse.Message,
"The server date is: " + getServerDateResponse.Date);
}
private void HandleGetPayorTypesCompleted( ReceivedResponses receivedResponses )
{
IsLoading = false;
var response = receivedResponses.Get<GetPayorTypesByBillingOfficeKeyResponse> ();
PayorTypeList = response.PayorTypes;
}
private void HandleResetTestDataCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<ResetTestDataResponse> ();
GetAllClaimBatches ();
IsLoading = false;
}
private void HandleClaimBatchesCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<GetClaimBatchDisplayNamesByClaimBatchStatusResponse> ();
var claimBatchList = new List<ClaimBatchDisplayNameDto> ( response.ClaimBatchDisplayNames );
PagedCollectionViewWrapper.WrapInPagedCollectionView ( claimBatchList );
IsLoading = false;
}
private void HandleSaveRequestComplete( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<DtoResponse<MedicationDto>> ();
Medication = response.DataTransferObject;
if ( !Medication.HasErrors )
{
_eventAggregator.GetEvent<MedicationChangedEvent> ().Publish (
new MedicationChangedEventArgs { Sender = this, MedicationKey = Medication.Key, PatientKey = Medication.PatientKey } );
CloseViewCommand.Execute ( null );
}
IsLoading = false;
}
private void GetMedicationByKeyCompleted( ReceivedResponses receivedResponses )
{
if ( receivedResponses.HasResponse<GetMedicationByKeyResponse> () )
{
IsLoading = false;
var response = receivedResponses.Get<GetMedicationByKeyResponse> ();
Medication = response.Medication;
DtsMedicationCode = Medication.MedicationCodeCodedConcept;
}
}
private void SingleRequestSucceeded(ReceivedResponses receivedResponses)
{
var helloWorldResponse = receivedResponses.Get<HelloWorldResponse>();
AddSucceededRequestsToView("Single response", helloWorldResponse.Message);
}
private void GetDefaultClinicalCaseByPatientRequestCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<GetDefaultClinicalCaseByPatientResponse> ();
var caseSummaryDto = response.CaseSummaryDto;
if ( caseSummaryDto == null )
{
// Create new clinical case and navigate to clinical case editor.
CreateClinicalCase ();
}
else
{
SelectedClinicalCase = new ClinicalCaseSummaryDto
{
Key = caseSummaryDto.Key,
ClinicalCaseNumber = caseSummaryDto.ClinicalCaseNumber,
ClinicalCaseStartDate = caseSummaryDto.ClinicalCaseStartDate,
ClinicalCaseCloseDate = caseSummaryDto.ClinicalCaseCloseDate
};
RefreshDashboard ( caseSummaryDto.Key );
}
}
private void GetAllClinicalCasesByPatientRequestCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<GetAllClinicalCasesByPatientResponse> ();
var caseSummaryDtos = response.ClinicalCases;
AllClinicalCases = new ObservableCollection<ClinicalCaseSummaryDto> ( caseSummaryDtos );
if ( SelectedClinicalCase != null )
{
SelectedClinicalCase = AllClinicalCases.SingleOrDefault ( x => x.Key == SelectedClinicalCase.Key );
}
}
private void CreateNewClinicalCaseRequestDispatcherCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<CreateNewClinicalCaseResponse> ();
var clinicalCaseDto = response.ClinicalCaseDto;
SelectedClinicalCase = new ClinicalCaseSummaryDto
{
Key = clinicalCaseDto.Key,
ClinicalCaseNumber = clinicalCaseDto.ClinicalCaseProfile.ClinicalCaseNumber
};
if ( SelectedClinicalCase != null )
{
_lastSelectedClinicalCaseKey = SelectedClinicalCase.Key;
NavigateToClinicalCase ( true );
}
}
private void HandleGetAllProblemsByClinicalCaseCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<GetAllProblemsByClinicalCaseResponse> ();
_problemList = new List<ProblemDto> ( response.ProblemDtos );
PagedCollectionViewWrapper.WrapInPagedCollectionView ( _problemList, _filter );
IsLoading = false;
}
private void PatientListSearchRequestComplete( ReceivedResponses responses )
{
var response = responses.Get<PatientListSearchResponse> ();
PatientList = response.PatientList;
IsLoading = false;
}
private void HandleInitializationCompleted( ReceivedResponses receivedResponses )
{
GetDefaultClinicalCaseByPatientRequestCompleted ( receivedResponses );
GetAllClinicalCasesByPatientRequestCompleted ( receivedResponses );
if (SelectedClinicalCase != null)
{
_lastSelectedClinicalCaseKey = SelectedClinicalCase.Key;
}
IsLoading = false;
}
private void GetTaskSystemRoleListCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<DtoResponse<TaskSystemRolesDto>> ();
TaskSystemRoleLookupList = new PagedCollectionView ( response.DataTransferObject.SystemRoles );
}
private void GetLookupValuesCompleted( ReceivedResponses receivedResponses )
{
var responses = from response in receivedResponses.Responses
where typeof( GetLookupValuesResponse ).IsAssignableFrom ( response.GetType () )
select response;
var lookupValueLists =
responses.Cast<GetLookupValuesResponse> ().ToDictionary ( response => response.Name, response => response.LookupValues );
LookupValueLists = lookupValueLists;
if ( Medication != null && Medication.Key == 0 )
{
Medication.MedicationStatus =
lookupValueLists["MedicationStatus"].FirstOrDefault (
m => m.WellKnownName == MedicationStatus.Active );
}
IsLoading = false;
}
private void HandleCloneRequestComplete( ReceivedResponses receivedResponse )
{
var response = receivedResponse.Get<SystemRoleCommandResponse> ();
var validationErrors = response.DataTransferObject.DataErrorInfoCollection.ToList ();
ProcessSystemRoleResponses ( response.SystemRole, validationErrors, true );
}
private void HandleRequestComplete( ReceivedResponses receivedResponses )
{
GetLookupValuesCompleted ( receivedResponses );
GetMedicationByKeyCompleted ( receivedResponses );
}
private void HandleEditRequestComplete( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<DtoResponse<SystemRoleDto>> ();
var validationErrors = response.DataTransferObject.DataErrorInfoCollection.ToList ();
ProcessSystemRoleResponses ( response.DataTransferObject, validationErrors, true );
}
private void MedicationFormStrengthRequestCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<MedicationFormStrengthResponse> ();
DTSInfo = response.DTSInfo;
_dtsMedicationCode = GetCodedConceptDto ( response.MainCode );
RaisePropertyChanged ( () => DtsMedicationCode );
if ( Medication != null && Medication.MedicationCodeCodedConcept != null )
{
var origDrugConcept =
response.DTSInfo.Drugs.FirstOrDefault ( d => d.Code == Medication.MedicationCodeCodedConcept.CodedConceptCode );
if ( origDrugConcept == null )
{
response.DTSInfo.SelectedStrength =
response.DTSInfo.Strengths.FirstOrDefault ( s => s.Code == Medication.MedicationCodeCodedConcept.CodedConceptCode );
response.DTSInfo.SelectedForm =
response.DTSInfo.Forms.FirstOrDefault ( f => f.Code == Medication.MedicationCodeCodedConcept.CodedConceptCode );
}
else
{
response.DTSInfo.SelectedStrength =
response.DTSInfo.Strengths.FirstOrDefault (
s => origDrugConcept.Associations.SelectMany ( a => a.Value ).Contains ( s.Code ) );
response.DTSInfo.SelectedForm =
response.DTSInfo.Forms.FirstOrDefault ( f => origDrugConcept.Associations.SelectMany ( a => a.Value ).Contains ( f.Code ) );
}
Medication.RootMedicationCodedConcept = GetCodedConceptDto ( response.MainCode );
}
else if ( Medication != null )
{
Medication.MedicationCodeCodedConcept = GetCodedConceptDto ( response.MainCode );
Medication.RootMedicationCodedConcept = GetCodedConceptDto ( response.MainCode );
}
IsLoading = false;
}
private void HandleInitializationCompleted( ReceivedResponses receivedResponses )
{
GetTaskSystemRoleListCompleted ( receivedResponses );
GetTaskGroupSystemRoleListCompleted ( receivedResponses );
RefreshSystemRoleLists ();
IsLoading = false;
}
private void PostC32ToPopHealtheRequestRequestDispatcherCompleted( ReceivedResponses receivedResponses )
{
IsLoading = false;
var response = receivedResponses.Get<PostC32ToPopHealthResponse> ();
_userDialogService.ShowDialog (
string.Format ( "Message from PopHealth:\n{0}", response.Message ), "Export C32 to PopHealth", UserDialogServiceOptions.Ok );
}
private void HandleSaveJobFunctionCompleted( ReceivedResponses receivedResponse )
{
var response = receivedResponse.Get<SystemRoleCommandResponse> ();
var validationErrors = response.DataTransferObject.DataErrorInfoCollection.ToList ();
ProcessSystemRoleResponses ( response.SystemRole, validationErrors );
}
private void HandleGenerateHcc837ProfessionalCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<GenerateHcc837ProfessionalResponse> ();
var relativePath = string.Format (
"../{0}?{1}={2}&{3}={4}",
HttpHandlerPaths.BillingModuleHttpHandlerPath,
HttpUtility.UrlEncode ( HttpHandlerQueryStrings.RequestName ),
HttpUtility.UrlEncode ( HttpHandlerRequestNames.DownloadHealthCareClaim837ProfessionalDocument ),
HttpUtility.UrlEncode ( HttpHandlerQueryStrings.ClaimBatchKey ),
_currentClaimBatchKey );
var uri = Application.Current.Host.Source != null ? new Uri ( Application.Current.Host.Source, relativePath ) : new Uri ( "blank:" );
HtmlPage.Window.Navigate ( uri, "_blank" );
}
private void LookupValuesRequestComplete( ReceivedResponses receivedResponses )
{
var responses = from response in receivedResponses.Responses
where typeof( GetLookupValuesResponse ).IsAssignableFrom ( response.GetType () )
select response;
var lookupValueLists =
responses.Cast<GetLookupValuesResponse> ().ToDictionary ( response => response.Name, response => response.LookupValues );
LookupValueLists = lookupValueLists;
}
private void HandleTaskGroupCommandCompleted( ReceivedResponses receivedResponses )
{
IsLoading = false;
var response = receivedResponses.Get<SystemRoleCommandResponse> ();
var validationErrors = response.DataTransferObject.DataErrorInfoCollection.ToList ();
if ( validationErrors.Count () == 0 )
{
var newlyChangedTaskGroup = response.SystemRole;
RefreshForTaskGroupChanges ( newlyChangedTaskGroup );
}
else
{
ProcessValidationErrors ( validationErrors );
}
}
private void HandleInitializationForTaskWorkingModeCompleted( ReceivedResponses receivedResponses )
{
IsLoading = false;
GetSystemPermissionListCompleted ( receivedResponses );
if ( !_isTaskGroupWorkingModeInitialized )
{
GetTaskSystemRoleListCompleted ( receivedResponses );
}
_isTaskWorkingModeInitialized = true;
}
private void HandleDeleteProblemCompleted( ReceivedResponses receivedResponse )
{
var response = receivedResponse.Get<DeleteProblemResponse> ();
_problemList = new List<ProblemDto> ( response.ProblemDtos );
PagedCollectionViewWrapper.WrapInPagedCollectionView ( _problemList, _filter );
IsLoading = false;
}
private void GetSystemPermissionListCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<DtoResponse<SystemPermissionsDto>> ();
var systemPermissionList = response.DataTransferObject.SystemPermissions;
PermissionCollectionView = new PagedCollectionView ( systemPermissionList );
if ( _isTaskGroupWorkingModeInitialized )
{
UpdateSelectedItemInTreeView ( true );
}
}
private void HandleGetLookupValuesCompleted( ReceivedResponses receivedResponses )
{
var lookupValueLists = new Dictionary<string, IList<LookupValueDto>> ();
var responses = from response in receivedResponses.Responses
where typeof( GetLookupValuesResponse ).IsAssignableFrom ( response.GetType () )
select response;
foreach ( GetLookupValuesResponse response in responses )
{
lookupValueLists.Add ( response.Name, response.LookupValues );
}
LookupValueLists = lookupValueLists;
RaisePropertyChanged ( () => LookupValueLists );
IsLoading = false;
}
private void GetTaskSystemRoleListCompleted( ReceivedResponses receivedResponses )
{
var response = receivedResponses.Get<DtoResponse<TaskSystemRolesDto>> ();
var taskSystemRoleList = response.DataTransferObject.SystemRoles;
taskSystemRoleList = new ObservableCollection<SystemRoleDto> ( taskSystemRoleList.OrderBy ( p => p.Name ).ToList () );
foreach ( var task in taskSystemRoleList )
{
task.GrantedSystemPermissions =
new ObservableCollection<SystemPermissionDto> ( task.GrantedSystemPermissions.OrderBy ( p => p.DisplayName ) );
}
TaskCollectionView = new PagedCollectionView ( taskSystemRoleList );
if ( IsBegunWithTaskWorkingMode.HasValue && IsBegunWithTaskWorkingMode.Value )
{
var initialTaskToEdit = taskSystemRoleList.SingleOrDefault ( p => p.Key == _initialSystemRoleKeyToEdit );
if ( initialTaskToEdit != null )
{
SelectedItemInTaskList = initialTaskToEdit;
}
else if ( _isAddingNewTask )
{
_isAddingNewTask = false;
ExecuteCreateNewTaskCommand ();
Thread.Sleep ( 500 );
}
else if ( !_isTaskGroupWorkingModeInitialized )
{
UpdateSelectedItemInTreeView ( true );
}
}
}
