public async Task <ActionResult <GetUserResponse> > GetUser(string meUserId)
{
if (!ModelState.IsValid)
{
return(BadRequest(new GetUserResponse()));
}
try
{
var user = await _userRetrievalByIdService.Handle(new UserRetrievalByIdQuery(meUserId));
if (user == null)
{
return(NotFound(new GetUserResponse()));
}
var gur = new GetUserResponse();
Mapper.Map(user, gur);
return(Ok(gur));
}
catch (ArgumentException)
{
return(NotFound(new GetUserResponse()));
}
catch (NullReferenceException)
{
return(NotFound(new GetUserResponse()));
}
}
public async Task <ActionResult <PutUserResponse> > UpdateUser(string meUserId, [FromBody] PutUserRequest putUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(new PutUserResponse()));
}
try
{
var userUpdateEmail = Mapper.Map <UserUpdateEmail>(putUser);
userUpdateEmail.UserId = meUserId;
var currentUser = await CurrentUser();
var updatedUser = await _userUpdateService.Handle(new UserUpdateQuery(userUpdateEmail, currentUser));
return(Ok(Mapper.Map <PutUserResponse>(updatedUser)));
}
catch (DocumentClientException)
{
return(NotFound(new PutUserResponse()));
}
catch (ArgumentException)
{
return(NotFound(new PutUserResponse()));
}
}
public async Task <ActionResult <GetCaseBreakdownResponse> > GetCaseBreakdown(string examinationId)
{
if (string.IsNullOrEmpty(examinationId))
{
return(BadRequest(new GetCaseBreakdownResponse()));
}
if (!Guid.TryParse(examinationId, out _))
{
return(BadRequest(new GetCaseBreakdownResponse()));
}
var user = await CurrentUser();
var examination = await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, user));
if (examination == null)
{
return(new NotFoundObjectResult(new GetCaseBreakdownResponse()));
}
if (!CanAsync(Permission.GetExamination, examination))
{
return(Forbid());
}
var patientCard = Mapper.Map <PatientCardItem>(examination);
var result = Mapper.Map <CaseBreakDownItem>(examination, opt => opt.Items["user"] = user);
return(Ok(new GetCaseBreakdownResponse
{
Header = patientCard,
CaseBreakdown = result
}));
}
public async Task <ActionResult <GetPermissionResponse> > GetPermission(string meUserId, string permissionId)
{
if (!ModelState.IsValid)
{
return(BadRequest(new GetPermissionResponse()));
}
try
{
var user = await _userRetrievalByIdService.Handle(new UserRetrievalByIdQuery(meUserId));
if (user == null)
{
return(NotFound(new GetPermissionResponse()));
}
var permission = user.Permissions.FirstOrDefault(p => p.PermissionId == permissionId);
if (permission == null)
{
return(NotFound(new GetPermissionResponse()));
}
var locationDocument = (await
_locationParentsService.Handle(
new LocationParentsQuery(permission.LocationId)))
.ToLocationPath();
if (!CanAsync(Permission.GetUserPermission, locationDocument))
{
return(Forbid());
}
var location = await permission.GetLocationName(_locationsRetrievalByIdService);
var permissionLocations = new PermissionLocation(permission, location, meUserId);
var result = Mapper.Map <GetPermissionResponse>(permissionLocations);
return(Ok(result));
}
catch (ArgumentException)
{
return(NotFound(new GetPermissionResponse()));
}
catch (NullReferenceException)
{
return(NotFound(new GetPermissionResponse()));
}
}
public async Task <ActionResult <GetLocationResponse> > GetLocation(string locationId)
{
try
{
var location =
await _locationRetrievalByIdQueryHandler.Handle(new LocationRetrievalByIdQuery(locationId));
var response = Mapper.Map <GetLocationResponse>(location);
return(Ok(response));
}
catch (DocumentClientException)
{
return(NotFound(new GetLocationResponse()));
}
}
public async Task <ActionResult <GetCoronerReferralDownloadResponse> > GetCoronerReferralDownload(string examinationId)
{
if (string.IsNullOrEmpty(examinationId))
{
return(new BadRequestObjectResult(nameof(examinationId)));
}
var currentUser = await CurrentUser();
var examination = await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, currentUser));
if (examination == null)
{
return(new NotFoundResult());
}
if (!CanAsync(Permission.GetCoronerReferralDownload, examination))
{
return(Forbid());
}
if (!examination.ScrutinyConfirmed)
{
return(new BadRequestObjectResult("Scrutiny should be confirmed before downloading."));
}
return(new OkObjectResult(Mapper.Map <GetCoronerReferralDownloadResponse>(examination)));
}
/// <summary>
/// Called after method executed
/// </summary>
/// <remarks>Required by interface. Not intended to be used</remarks>
/// <param name="context">action context</param>
public void OnActionExecuted(ActionExecutedContext context)
{
string controllerName = null;
string controllerAction = null;
if (context.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor)
{
controllerName = controllerActionDescriptor.ControllerName;
controllerAction = controllerActionDescriptor.ActionName;
}
var identity = context.HttpContext.User.Identity;
var userId = ((ClaimsIdentity)identity).Claims.SingleOrDefault(x => x.Type == Authorization.MEClaimTypes.UserId)?.Value;
var userAuthenticationType = identity.AuthenticationType ?? "Unknown";
var userIsAuthenticated = identity.IsAuthenticated;
var remoteIpAddress = context.HttpContext.Connection.RemoteIpAddress;
var remoteIp = remoteIpAddress == null ? "Unknown" : remoteIpAddress.ToString();
var totalRus = _requestChargeService.RequestCharges.Sum(i => i.Charge);
_logger.Handle(new CreateMELoggerQuery(new LogMessageActionDefault(
userId,
userAuthenticationType,
userIsAuthenticated,
controllerName,
controllerAction,
_parameters,
remoteIp,
_timestamp,
totalRus
)));
}
public async Task <ActionResult> PutCoronerReferral(string examinationId)
{
if (string.IsNullOrEmpty(examinationId))
{
return(new BadRequestObjectResult(nameof(examinationId)));
}
if (!Guid.TryParse(examinationId, out _))
{
return(new BadRequestObjectResult(nameof(examinationId)));
}
var user = await CurrentUser();
var examination = await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, user));
if (examination == null)
{
return(new NotFoundResult());
}
if (!CanAsync(Permission.UpdateExamination, examination))
{
return(Forbid());
}
if (!examination.CalculateRequiresCoronerReferral())
{
return(BadRequest());
}
await _coronerReferralService.Handle(new CoronerReferralQuery(examinationId, user));
return(Ok());
}
public async Task <ActionResult <PutVoidCaseResponse> > PutVoidCase(
string examinationId,
[FromBody] PutVoidCaseRequest putVoidCaseRequest)
{
if (string.IsNullOrEmpty(examinationId))
{
return(new BadRequestObjectResult(new PutVoidCaseResponse()));
}
if (!Guid.TryParse(examinationId, out _))
{
return(new BadRequestObjectResult(new PutVoidCaseResponse()));
}
var user = await CurrentUser();
var examination = await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, user));
if (examination == null)
{
return(new NotFoundResult());
}
if (!CanAsync(Permission.VoidExamination, examination))
{
return(Forbid());
}
var result = await _voidCaseService.Handle(new VoidCaseQuery(examinationId, user, putVoidCaseRequest.VoidReason));
var response = Mapper.Map <PutVoidCaseResponse>(result);
return(Ok(response));
}
public async Task <ActionResult <PutConfirmationOfScrutinyResponse> > PutConfirmationOfScrutiny(string examinationId)
{
if (string.IsNullOrEmpty(examinationId))
{
return(BadRequest(new PutConfirmationOfScrutinyResponse()));
}
var user = await CurrentUser();
var examination = await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, user));
if (!CanAsync(Permission.UpdateExamination, examination))
{
return(Forbid());
}
if (user.UserId != examination.MedicalTeam.MedicalExaminerUserId)
{
return(BadRequest());
}
if (!examination.CalculateCanCompleteScrutiny())
{
return(new BadRequestObjectResult("Scrutiny needs to be performed before confirming scrutiny is complete."));
}
var result = await _confirmationOfScrutinyService.Handle(new ConfirmationOfScrutinyQuery(examinationId, user));
return(Ok(Mapper.Map <PutConfirmationOfScrutinyResponse>(result)));
}
public async Task <Models.Examination> Handle(CreateExaminationQuery param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
param.Examination.ExaminationId = Guid.NewGuid().ToString();
param.Examination.MedicalExaminerOfficeResponsibleName = _locationHandler.Handle(new LocationRetrievalByIdQuery(param.Examination.MedicalExaminerOfficeResponsible)).Result.Name;
param.Examination.Unassigned = true;
param.Examination.CaseBreakdown = new CaseBreakDown();
param.Examination.CaseBreakdown.DeathEvent = new DeathEvent()
{
Created = param.Examination.CreatedAt.DateTime,
DateOfDeath = param.Examination.DateOfDeath,
TimeOfDeath = param.Examination.TimeOfDeath,
UserId = param.Examination.CreatedBy,
UsersRole = param.User.UsersRoleIn(new[] { UserRoles.MedicalExaminer, UserRoles.MedicalExaminerOfficer }).ToString(),
UserFullName = param.User.FullName(),
GmcNumber = param.User.GmcNumber,
EventId = Guid.NewGuid().ToString()
};
param.Examination.UpdateCaseUrgencySort(_urgencySettings.DaysToPreCalculateUrgencySort);
param.Examination.UpdateCaseStatus();
param.Examination.LastModifiedBy = param.User.UserId;
param.Examination.ModifiedAt = DateTime.Now;
return(await _databaseAccess.CreateItemAsync(_connectionSettings, param.Examination));
}
/// <summary>
/// Handle.
/// </summary>
/// <param name="param">Patient Details Update Query.</param>
/// <returns>An Examination.</returns>
public async Task <Models.Examination> Handle(PatientDetailsUpdateQuery param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
var caseToReplace = await
_databaseAccess
.GetItemAsync <Models.Examination>(
_connectionSettings,
examination => examination.ExaminationId == param.CaseId);
_mapper.Map(param.PatientDetails, caseToReplace);
caseToReplace.UpdateLocationPath(param.Locations);
caseToReplace.MedicalExaminerOfficeResponsibleName = _locationHandler.Handle(
new LocationRetrievalByIdQuery(caseToReplace.MedicalExaminerOfficeResponsible)).Result.Name;
caseToReplace.LastModifiedBy = param.User.UserId;
caseToReplace.ModifiedAt = DateTime.Now;
caseToReplace = caseToReplace.UpdateCaseUrgencySort(_urgencySettings.DaysToPreCalculateUrgencySort);
caseToReplace = caseToReplace.UpdateCaseStatus();
caseToReplace.CaseBreakdown.DeathEvent = _mapper.Map(caseToReplace, caseToReplace.CaseBreakdown.DeathEvent);
caseToReplace.CaseBreakdown.DeathEvent.UserId = param.User.UserId;
caseToReplace.CaseBreakdown.DeathEvent.UserFullName = param.User.FullName();
caseToReplace.CaseBreakdown.DeathEvent.GmcNumber = param.User.GmcNumber;
caseToReplace.CaseBreakdown.DeathEvent.UsersRole = param.User.UsersRoleIn(new[] { UserRoles.MedicalExaminer, UserRoles.MedicalExaminerOfficer }).ToString();
var result = await _databaseAccess.UpdateItemAsync(_connectionSettings, caseToReplace);
return(result);
}
public async Task <ActionResult <GetLocationsResponse> > GetLocations([FromQuery] GetLocationsRequest request)
{
IEnumerable <string> permissedLocations = null;
if (request == null)
{
return(BadRequest(new GetLocationsResponse()));
}
if (request.CreateExaminationOnly)
{
permissedLocations = await LocationsWithPermission(Permission.CreateExamination);
}
else if (request.AccessOnly)
{
permissedLocations = await LocationsWithPermission(Permission.GetLocation);
}
var locations =
await _locationRetrievalByQueryHandler.Handle(
new LocationsRetrievalByQuery(request.Name, request.ParentId, false, request.OnlyMEOffices, permissedLocations));
return(Ok(new GetLocationsResponse
{
Locations = locations.Select(e => Mapper.Map <LocationItem>(e)).ToList(),
}));
}
public async Task <ActionResult <GetExaminationsResponse> > GetExaminations([FromQuery] GetExaminationsRequest filter)
{
if (filter == null)
{
return(BadRequest(new GetExaminationsResponse()));
}
var permissedLocations = (await LocationsWithPermission(Permission.GetExaminations)).ToList();
var examinationsQuery = new ExaminationsRetrievalQuery(
permissedLocations,
filter.CaseStatus,
filter.LocationId,
filter.OrderBy,
filter.PageNumber,
filter.PageSize,
filter.UserId,
filter.OpenCases);
var examinations = await _examinationsRetrievalService.Handle(examinationsQuery);
var dashboardOverview = await _examinationsDashboardService.Handle(examinationsQuery);
var response = new GetExaminationsResponse
{
CountOfTotalCases = dashboardOverview.TotalCases,
CountOfUrgentCases = dashboardOverview.CountOfUrgentCases,
CountOfCasesHaveUnknownBasicDetails = dashboardOverview.CountOfHaveUnknownBasicDetails,
CountOfCasesUnassigned = dashboardOverview.CountOfUnassigned,
CountOfCasesReadyForMEScrutiny = dashboardOverview.CountOfReadyForMEScrutiny,
CountOfCasesHaveBeenScrutinisedByME = dashboardOverview.CountOfHaveBeenScrutinisedByME,
CountOfCasesPendingAdditionalDetails = dashboardOverview.CountOfPendingAdditionalDetails,
CountOfCasesPendingDiscussionWithQAP = dashboardOverview.CountOfPendingDiscussionWithQAP,
CountOfCasesPendingDiscussionWithRepresentative = dashboardOverview.CountOfPendingDiscussionWithRepresentative,
CountOfCasesHaveFinalCaseOutstandingOutcomes = dashboardOverview.CountOfHaveFinalCaseOutstandingOutcomes,
Examinations = examinations.Select(e => Mapper.Map <PatientCardItem>(e)).ToList(),
CountOfFilteredCases = dashboardOverview.CountOfFilteredCases,
};
var locations = (await _locationRetrievalByQueryHandler.Handle(
new LocationsRetrievalByQuery(null, null, false, false, permissedLocations))).ToList();
var onlyMeOffices = locations.Where(l => l.IsMeOffice).ToList();
var allLocations = (await _locationsRetrievalByQueryHandler.Handle(new LocationsParentsQuery(onlyMeOffices.Select(x => x.LocationId)))).ToList();
var flatternedLocations = allLocations.SelectMany(x => x.Value);
var distinctLocationIds = flatternedLocations.Select(x => x.LocationId).Distinct();
var distinctLocations = distinctLocationIds.Select(id => flatternedLocations.First(x => x.LocationId == id));
var orderedDistinctLocations = distinctLocations.OrderBy(x => x.NationalLocationId)
.ThenBy(x => x.RegionLocationId)
.ThenBy(x => x.TrustLocationId)
.ThenBy(x => x.SiteLocationId).ToList();
response.AddLookup(LocationFilterLookupKey, Mapper.Map <IEnumerable <Location>, IEnumerable <LocationLookup> >(orderedDistinctLocations));
response.AddLookup(UserFilterLookupKey, await GetUserLookupForLocations(locations));
return(Ok(response));
}
/// <summary>
/// Gets the users for locations.
/// </summary>
/// <param name="locations">The locations.</param>
/// <returns>List of users.</returns>
private async Task <IEnumerable <MeUser> > GetUsersForLocations(IEnumerable <string> locations)
{
var users = await _usersRetrievalService.Handle(new UsersRetrievalQuery(true, null));
var usersForLocations = users.Where(u => u.Permissions != null && u.Permissions.Any(p => locations.Contains(p.LocationId)));
return(usersForLocations);
}
/// <summary>
/// Get Users For Examination
/// </summary>
/// <param name="examination">Examination.</param>
/// <param name="role">Role.</param>
/// <returns>List of Users.</returns>
private async Task <IEnumerable <MeUser> > GetUsersForExamination(Examination examination, UserRoles role)
{
var locations = examination.LocationIds();
var users = await _usersRetrievalByRoleLocationQueryService.Handle(new UsersRetrievalByRoleLocationQuery(locations, new[] { role }));
return(users);
}
public async Task <ActionResult> SearchAsync(string searchText)
{
var query = new FindUsersBySearchTextQuery {
SearchText = searchText, IncludeInactiveUsers = true
};
var users = await asyncHandler.Handle(query);
return(View(users));
}
/// <summary>
/// Get Full Name.
/// Helper method to get the full name of a user.
/// </summary>
/// <remarks>The user id can be null and in this case don't query and just return.</remarks>
/// <param name="userId">The id of the user.</param>
/// <returns>The full name or null</returns>
private async Task <MeUser> GetUser(string userId)
{
if (userId == null)
{
return(null);
}
return(await _userRetrievalByIdService.Handle(new UserRetrievalByIdQuery(userId)));
}
public async Task <IHttpActionResult> GetAsync(string clientId, long fromInTicks)
{
return(Ok(await queryHandler.Handle(
new CommitQuery
{
ClientId = clientId,
From = new DateTime(fromInTicks)
})));
}
public Task <GetUserMealsByDateResponse> Get([FromRoute] GetUserMealsByDateQuery query)
{
var internalQuery = new GetUserMealsByDateInternalQuery
{
Date = query.Date,
Id = User.Claims.First(c => c.Type == "UserID").Value
};
return(_getUserMealsByDate.Handle(internalQuery));
}
public Task <GetUserProfileResponse> GetUserProfile()
{
var userId = User.Claims.First(c => c.Type == "UserID").Value;
var query = new GetUserProfileQuery
{
UserId = userId
};
return(_getUserProfileHandler.Handle(query));
}
public async Task <Result <StudentGrade, Exception> > Handle(GetStudentGradeForAssignmentQuery parameters)
{
return(await _getAssignmentAnswerKeyQueryHandler.Handle(new GetAssignmentAnswerKeyQuery(parameters.EducatorID, parameters.AssignmentID))
.MapFailure(exception => new Exception("An error occurred while retrieving assignment answer key!", exception))
.BindAsync(answerKey =>
_getStudentSubmissionForAssignmentQueryHandler.Handle(new GetStudentSubmissionForAssignmentQuery(parameters.EducatorID, parameters.AssignmentID, parameters.StudentID))
.Select(submission => new StudentGradeSubmissionBundle(answerKey, submission))
.MapFailure(exception => new Exception("An error occurred while retrieving student submission!", exception)))
.Select(bundle => bundle.ComputeGrade()));
}
private async Task <ActionResult <PutCaseBreakdownEventResponse> > UpsertEvent <TEvent, TRequest>(
string examinationId,
Permission permission,
[FromBody] TRequest caseBreakdownEvent)
where TEvent : IEvent
{
if (!ModelState.IsValid)
{
return(BadRequest(new PutCaseBreakdownEventResponse()));
}
if (caseBreakdownEvent == null)
{
return(BadRequest(new PutCaseBreakdownEventResponse()));
}
var user = await CurrentUser();
var theEvent = Mapper.Map <TEvent>(caseBreakdownEvent);
theEvent = SetEventUserStatuses(theEvent, user);
var examination =
await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, user));
if (examination == null)
{
return(NotFound(new PutCaseBreakdownEventResponse()));
}
if (!CanAsync(permission, examination))
{
return(Forbid());
}
var result = await _eventCreationService.Handle(new CreateEventQuery(examinationId, theEvent));
if (result == null)
{
return(NotFound(new PutCaseBreakdownEventResponse()));
}
var patientCard = Mapper.Map <PatientCardItem>(result.Examination);
var res = new PutCaseBreakdownEventResponse
{
Header = patientCard,
EventId = result.EventId
};
return(Ok(res));
}
public async Task <ActionResult <PutPatientDetailsResponse> > UpdatePatientDetails(string examinationId,
[FromBody][ExaminationValidationModelBinderContext("examinationId")] PutPatientDetailsRequest putPatientDetailsRequest)
{
if (!ModelState.IsValid)
{
return(BadRequestEnums(new PutPatientDetailsResponse()));
}
var examination =
await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, null));
if (examination == null)
{
return(NotFound(new PutPatientDetailsResponse()));
}
// Do they have update permission on the examination being updated
if (!CanAsync(Permission.UpdateExamination, examination))
{
return(Forbid());
}
var patientDetails = Mapper.Map <PatientDetails>(putPatientDetailsRequest);
var locations = (await _locationParentsService.Handle(
new LocationParentsQuery(patientDetails.MedicalExaminerOfficeResponsible))).ToList();
var locationPath = new LocationPath();
locationPath.UpdateLocationPath(locations);
// Do they have permission at this location to update the examination. I.e. they're changing the Medical Examiner Office.
if (!CanAsync(Permission.UpdateExamination, locationPath))
{
return(Forbid());
}
var myUser = await CurrentUser();
var result = await _patientDetailsUpdateService.Handle(new PatientDetailsUpdateQuery(
examinationId,
patientDetails,
myUser,
locations));
var patientCard = Mapper.Map <PatientCardItem>(result);
return(Ok(new PutPatientDetailsResponse
{
Header = patientCard
}));
}
/// <summary>
/// Get Location Name.
/// </summary>
/// <param name="permission">Permission to get location name for.</param>
/// <param name="service">The locations retrieval by id service.</param>
/// <returns>Single location</returns>
public static async Task <Location> GetLocationName(
this MEUserPermission permission,
IAsyncQueryHandler <LocationsRetrievalByIdQuery, IEnumerable <Location> > service)
{
var locationIds = new List <string>
{
permission.LocationId
};
var locations = await service.Handle(new LocationsRetrievalByIdQuery(true, locationIds));
return(locations.FirstOrDefault());
}
/// <inheritdoc/>
public async Task <bool> HasPermission(string emailAddress, ILocationPath document, Permission permission)
{
if (_authorizationSettings.Value.Disable)
{
return(true);
}
var meUser = await _userRetrievalService.Handle(new UserRetrievalByOktaIdQuery(emailAddress));
if (meUser.Permissions != null)
{
var hasPermission = meUser.Permissions.Any(
p => _rolePermissions.Can((UserRoles)p.UserRole, permission) &&
document.LocationIds().Any(l => l == p.LocationId));
if (hasPermission)
{
return(true);
}
}
return(false);
}
public async Task <ActionResult <GetMedicalTeamResponse> > GetMedicalTeam(string examinationId)
{
if (!ModelState.IsValid)
{
return(BadRequest(new GetMedicalTeamResponse()));
}
var examination = _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, null)).Result;
if (examination == null)
{
return(NotFound(new GetMedicalTeamResponse()));
}
if (!CanAsync(Permission.GetExamination, examination))
{
return(Forbid());
}
var getMedicalTeamResponse = examination.MedicalTeam != null
? Mapper.Map <GetMedicalTeamResponse>(examination)
: new GetMedicalTeamResponse
{
ConsultantsOther = new ClinicalProfessionalItem[] { },
NursingTeamInformation = string.Empty,
};
getMedicalTeamResponse
.AddLookup(
MedicalExaminersLookupKey,
await GetLookupForExamination(examination, UserRoles.MedicalExaminer))
.AddLookup(
MedicalExaminerOfficersLookupKey,
await GetLookupForExamination(examination, UserRoles.MedicalExaminerOfficer));
return(Ok(getMedicalTeamResponse));
}
/// <summary>
/// Get the Current User.
/// </summary>
/// <returns>Current User.</returns>
protected async Task <MeUser> CurrentUser()
{
var oktaUserId = User.Claims.Where(c => c.Type == MEClaimTypes.OktaUserId).Select(c => c.Value).First();
try
{
var user = await _usersRetrievalByOktaIdService.Handle(new UserRetrievalByOktaIdQuery(oktaUserId));
return(user);
}
catch (ArgumentException)
{
return(null);
}
}
public async Task <ActionResult <GetPatientDetailsResponse> > GetPatientDetails(string examinationId)
{
if (!ModelState.IsValid)
{
return(BadRequest(new GetPatientDetailsResponse()));
}
var examination =
await _examinationRetrievalService.Handle(new ExaminationRetrievalQuery(examinationId, null));
if (examination == null)
{
return(NotFound(new GetPatientDetailsResponse()));
}
if (!CanAsync(Permission.GetExamination, examination))
{
return(Forbid());
}
var result = Mapper.Map <GetPatientDetailsResponse>(examination);
return(Ok(result));
}
public async Task <ActionResult <PutExaminationResponse> > CreateExamination(
[FromBody] PostExaminationRequest postExaminationRequest)
{
if (!ModelState.IsValid)
{
return(BadRequestEnums(new PutExaminationResponse()));
}
try
{
var examination = Mapper.Map <Examination>(postExaminationRequest);
var locations = await
_locationParentsService.Handle(
new LocationParentsQuery(examination.MedicalExaminerOfficeResponsible));
examination.UpdateLocationPath(locations);
if (!CanAsync(Permission.CreateExamination, examination))
{
return(Forbid());
}
var myUser = await CurrentUser();
examination.CreatedBy = myUser.UserId;
examination.CreatedAt = DateTime.Now;
var result = await _examinationCreationService.Handle(new CreateExaminationQuery(examination, myUser));
var res = new PutExaminationResponse
{
ExaminationId = result.ExaminationId
};
return(Ok(res));
}
catch (DocumentClientException)
{
return(NotFound(new PostExaminationRequest()));
}
catch (ArgumentException)
{
return(NotFound(new PostExaminationRequest()));
}
}