public async Task <IActionResult> Create([Bind] TeamMappingResponse teamMappingResponse)
{
ResponseTeamMappingDTO responseTeamMember = new ResponseTeamMappingDTO
{
CreatedBy = teamMappingResponse.CreatedBy,
DistrictCode = teamMappingResponse.DistrictCode,
MappingId = teamMappingResponse.MappingId,
TeamMemberId = teamMappingResponse.TeamMemberId
};
string url = $"{CoreApiUrl}ResponseTeamMappings/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, responseTeamMember);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Response team member has been successfully mapped", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index), new { teamMemberId = _teamMemberId, teamMemberName = _teamMemberName }));
}
else
{
AppContextHelper.SetToastMessage("Failed to map response team member", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
ViewBag.TeamMemberName = _teamMemberName;
return(View(teamMappingResponse));
}
public async Task <IActionResult> Create([Bind] ResponseTeamMemberDTO responseTeamMember)
{
string url = $"{CoreApiUrl}ResponseTeamMembers/Add";
//Clean up phoner number
var sanitizedNumber = PhoneNumberSanitizer.Sanitize(responseTeamMember.PhoneNumber, "+265");
responseTeamMember.PhoneNumber = sanitizedNumber;
var fullName = $"{responseTeamMember.FirstName} {responseTeamMember.Surname}";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, responseTeamMember);
if (response.StatusCode == HttpStatusCode.Created)
{
var identityResponse = await HttpRequestFactory.Post($"{IdentityServerAuthority}/api/Users/RegisterUser", new UserDTO { PhoneNumber = responseTeamMember.PhoneNumber, FullName = fullName });
if (identityResponse.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("User account has been successfully created", MessageType.Danger, 1, Response);
}
AppContextHelper.SetToastMessage("Response team member has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create response team member", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(responseTeamMember));
}
public async Task <IActionResult> Edit([Bind] ScheduledNotificationViewModel scheduledNotificationViewModel)
{
ScheduledNotificationDTO scheduledNotification = scheduledNotificationViewModel.ScheduledNotification;
string url = $"{NotificationsApiUrl}ScheduledNotifications/Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, scheduledNotification);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Scheduled notification has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update scheduled notification", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
scheduledNotificationViewModel.EscalationRules = await GetEscalationRules();
scheduledNotificationViewModel.NotificationTemplates = await GetNotificationTemplates();
scheduledNotificationViewModel.NotificationChannels = await GetNotificationChannels();
return(View(scheduledNotificationViewModel));
}
public async Task <IActionResult> Edit([Bind] PatientResponseViewModel patientResponseViewModel)
{
PatientDTO patient = patientResponseViewModel.PatientResponse;
string url = $"{PatientsApiUrl}Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, patient);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Patient has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update patient", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
patientResponseViewModel.PatientStatuses = await GetPatientStatuses();
patientResponseViewModel.IdentificationTypes = await GetIdentificationTypes();
patientResponseViewModel.TransmissionClassifications = await GetClassifications();
return(View(patientResponseViewModel));
}
public async Task <IActionResult> Create([Bind] DataCenterResponseViewModel dataCenterResponseViewModel)
{
DataCenterDTO dataCenter = dataCenterResponseViewModel.DataCenterResponse;
string url = $"{CoreApiUrl}DataCenters/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, dataCenter);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Identification type has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create identification type", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
dataCenterResponseViewModel.Districts = await GetDistricts();
dataCenterResponseViewModel.FacilityTypes = await GetFacilityTypes();
return(View(dataCenterResponseViewModel));
}
public async Task <IActionResult> Edit([Bind] ResourceDTO resource)
{
string url = $"{ResourcesApiUrl}Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, resource);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Resource has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update resource", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(resource));
}
public async Task <IActionResult> VerifyDelete(int mappingId)
{
string url = $"{CoreApiUrl}ResponseTeamMappings/Delete?mappingId={mappingId}";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Response team member mapping has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index), new { teamMemberId = _teamMemberId, teamMemberName = _teamMemberName }));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete response team member mapping", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(RedirectToAction(nameof(Delete), new { mappingId }));
}
public async Task <IActionResult> VerifyDelete(int symptomId)
{
string url = $"{PatientsApiUrl}Symptoms/Delete?symptomId={symptomId}";
var PatientSymptom = new PatientSymptomDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Patient symptom has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete patient symptom", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetPatientSymptom(symptomId)));
}
public async Task <IActionResult> VerifyDelete(int notificationId)
{
string url = $"{NotificationsApiUrl}BulkNotifications/Delete?notificationId={notificationId}";
var BulkNotification = new BulkNotificationDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Bulk notification has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete bulk notification", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetBulkNotification(notificationId)));
}
public async Task <IActionResult> VerifyConfirmPatient(long patientId)
{
string url = $"{PatientsApiUrl}ConfirmPatient?patientId={patientId}";
var patient = new PatientResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, patientId);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Patient has been successfully confirmed", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to confirm patient", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(RedirectToAction(nameof(ConfirmPatient), new { patientId }));
}
public async Task <IActionResult> Create([Bind] TransmissionClassificationDTO classification)
{
string url = $"{PatientsApiUrl}TransmissionClassifications/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, classification);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Classification has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create classification", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(classification));
}
public async Task <IActionResult> VerifyDelete(string resourceId)
{
string url = $"{ResourcesApiUrl}Delete?resourceId={resourceId}";
var Resource = new ResourceDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Resource has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete resource", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetResource(resourceId)));
}
public async Task <IActionResult> VerifyDelete(int ruleId)
{
string url = $"{NotificationsApiUrl}ScheduledNotificationEscalationRules/Delete?ruleId={ruleId}";
var ScheduledNotificationEscalationRule = new ScheduledNotificationEscalationRuleDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Scheduled notification escalation rule has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete scheduled notification escalation rule", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetScheduledNotificationEscalationRule(ruleId)));
}
public async Task <IActionResult> VerifyDelete(string countryCode)
{
string url = $"{CoreApiUrl}Countries/Delete?countryCode={countryCode}";
var Country = new CountryDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Country has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete country", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetCountry(countryCode)));
}
public async Task <IActionResult> Create([Bind] ScheduledNotificationEscalationRuleDTO escalationRule)
{
string url = $"{NotificationsApiUrl}ScheduledNotificationEscalationRules/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, escalationRule);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Scheduled notification escalation rule has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create scheduled notification escalation rule", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(escalationRule));
}
public async Task <IActionResult> Create([Bind] FacilityTypeDTO facilityType)
{
string url = $"{CoreApiUrl}FacilityTypes/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, facilityType);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Facility type has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create facility type", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(facilityType));
}
public async Task <IActionResult> VerifyDelete(int facilityTypeId)
{
string url = $"{CoreApiUrl}FacilityTypes/Delete?facilityTypeId={facilityTypeId}";
var FacilityType = new FacilityTypeDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Facility type has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete identification Type", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetFacilityType(facilityTypeId)));
}
public async Task <IActionResult> VerifyDelete(int workerId)
{
string url = $"{CoreApiUrl}HealthCareWorkers/Delete?workerId={workerId}";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Health care worker has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete health care worker", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
var HealthCareWorker = await GetHealthCareWorker(workerId);
return(View(HealthCareWorker));
}
public async Task <IActionResult> Create([Bind] ResourceAllocationResponseViewModel resourceAllocationResponseView)
{
ResourceAllocationDTO resourceAllocation = resourceAllocationResponseView.ResourceAllocationResponse;
string url = $"{ResourcesApiUrl}ResourcesAllocation/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, resourceAllocation);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("ResourcesAllocation has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create resourceAllocation", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
resourceAllocationResponseView.Resources = await GetResources();
return(View(resourceAllocationResponseView));
}
public async Task <IActionResult> Create([Bind] HealthCareWorkerResponseViewModel healthCareWorkerViewModel)
{
HealthCareWorkerDTO healthCareWorker = healthCareWorkerViewModel.HealthCareWorkerResponse;
string url = $"{CoreApiUrl}HealthCareWorkers/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, healthCareWorker);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Health care worker has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create health care worker", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
healthCareWorkerViewModel.IdentificationTypes = await GetIdentificationTypes();
return(View(healthCareWorkerViewModel));
}
public async Task <IActionResult> Create(IFormFile formfile, BulkNotificationRequestViewModel bulkNotificationRequsestViewModel)
{
var numberList = new List <string>();
if (formfile != null)
{
var phoneNumbersUploadedFile = formfile;
IWorkbook book;
var filePath = Path.GetTempFileName();
//using var stream = System.IO.File.Create(filePath);
//read workbook as XLSX
try
{
book = new XSSFWorkbook(phoneNumbersUploadedFile.OpenReadStream());
}
catch (Exception exception)
{
var e = exception;
book = null;
}
// If reading fails, try to read workbook as XLS:
if (book == null)
{
book = new HSSFWorkbook(phoneNumbersUploadedFile.OpenReadStream());
}
for (int i = 0; i < book.NumberOfSheets; i++)
{
var currentSheet = book.GetSheetAt(i);
for (int row = 0; row <= currentSheet.LastRowNum; row++)
{
if (currentSheet.GetRow(row) != null) //null is when the row only contains empty cells
{
var number = currentSheet.GetRow(row).GetCell(0).ToString();
//Clean up phone number
var sanitizedNumber = PhoneNumberSanitizer.Sanitize(currentSheet.GetRow(row).GetCell(0).ToString(), "+265");
numberList.Add(sanitizedNumber);
}
}
}
}
if (!String.IsNullOrEmpty(bulkNotificationRequsestViewModel.BulkNotificationRequest.CustomNumbers))
{
var customNumbers = bulkNotificationRequsestViewModel.BulkNotificationRequest.CustomNumbers.Split(",");
numberList.InsertRange(customNumbers.Length, customNumbers);
}
bulkNotificationRequsestViewModel.BulkNotificationRequest.UploadedPhoneNumbers = numberList;
string url = $"{NotificationsApiUrl}BulkNotifications/Add";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Post(accessToken, url, bulkNotificationRequsestViewModel.BulkNotificationRequest);
if (response.StatusCode == HttpStatusCode.Created)
{
AppContextHelper.SetToastMessage("Bulk notification has been successfully created", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to create bulk notification", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
bulkNotificationRequsestViewModel.Channels = await GetNotificationChannels();
return(View(bulkNotificationRequsestViewModel));
}
