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 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 HandleGetAllProblemsByClinicalCaseCompleted( ReceivedResponses receivedResponses )
        {
            var response = receivedResponses.Get<GetAllProblemsByClinicalCaseResponse> ();

            _problemList = new List<ProblemDto> ( response.ProblemDtos );
            PagedCollectionViewWrapper.WrapInPagedCollectionView ( _problemList, _filter );
            IsLoading = false;
        }

 private void HandleGetPayorTypesCompleted( ReceivedResponses receivedResponses )
 {
     IsLoading = false;
     var response = receivedResponses.Get<GetPayorTypesByBillingOfficeKeyResponse> ();
     PayorTypeList = response.PayorTypes;
 }

        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 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 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 GetTaskSystemRoleListCompleted( ReceivedResponses receivedResponses )
 {
     var response = receivedResponses.Get<DtoResponse<TaskSystemRolesDto>> ();
     TaskSystemRoleLookupList = new PagedCollectionView ( response.DataTransferObject.SystemRoles );
 }

 private void HandleInitializationCompleted( ReceivedResponses receivedResponses )
 {
     GetDefaultClinicalCaseByPatientRequestCompleted ( receivedResponses );
     GetAllClinicalCasesByPatientRequestCompleted ( receivedResponses );
     if (SelectedClinicalCase != null)
     {
         _lastSelectedClinicalCaseKey = SelectedClinicalCase.Key;
     }
     IsLoading = false;
 }

        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 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 );
                }
            }
        }

        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 SingleRequestSucceeded(ReceivedResponses receivedResponses)
 {
     var helloWorldResponse = receivedResponses.Get<HelloWorldResponse>();
     AddSucceededRequestsToView("Single response", helloWorldResponse.Message);
 }

        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 );
        }