public async Task <IActionResult> Edit([Bind] PatientSymptomDTO patientSymptom)
{
string url = $"{PatientsApiUrl}Symptoms/Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, patientSymptom);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Patient symptom has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update patient symptom", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(patientSymptom));
}
public async Task <IActionResult> Edit([Bind] ResponseTeamMemberDTO responseTeamMember)
{
string url = $"{CoreApiUrl}ResponseTeamMembers/Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, responseTeamMember);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Response team member has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update response team member", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(responseTeamMember));
}
public async Task <IActionResult> VerifyDelete(int teamMemberId)
{
string url = $"{CoreApiUrl}ResponseTeamMembers/Delete?teamMemberId={teamMemberId}";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Delete(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("Response team member has been successfully deleted", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to delete response team member", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(await GetResponseTeamMember(teamMemberId)));
}
public async Task <IActionResult> ConfirmPatient([FromQuery] long patientId)
{
string url = $"{PatientsApiUrl}GetById?patientId={patientId}";
var patient = new PatientResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
patient = response.ContentAsType <PatientResponse>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(patient));
}
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> 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> 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(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> 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> Index(int regionId)
{
if (regionId == 0)
{
if (_regionId == 0)
{
return(RedirectToAction("Index", "Regions"));
}
}
else
{
_regionId = regionId;
var region = await GetRegion(regionId);
_regionName = region.RegionName;
}
ViewBag.RegionName = _regionName;
string url = $"{CoreApiUrl}Districts/GetByRegionId?regionId={_regionId}";
var districts = Enumerable.Empty <DistrictResponse>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
districts = response.ContentAsType <IEnumerable <DistrictResponse> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(districts));
}
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> Edit([Bind] ResourceAllocationResponseViewModel resourceAllocationResponseView)
{
ResourceAllocationDTO resourceAllocation = resourceAllocationResponseView.ResourceAllocationResponse;
string url = $"{ResourcesApiUrl}ResourcesAllocation/Update";
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Put(accessToken, url, resourceAllocation);
if (response.StatusCode == HttpStatusCode.OK)
{
AppContextHelper.SetToastMessage("ResourcesAllocation has been successfully updated", MessageType.Success, 1, Response);
return(RedirectToAction(nameof(Index)));
}
else
{
AppContextHelper.SetToastMessage("Failed to update resourceAllocation", MessageType.Danger, 1, Response);
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
resourceAllocationResponseView.Resources = await GetResources();
return(View(resourceAllocationResponseView));
}
public async Task <IActionResult> Index()
{
string valuesFilter = "false";
string phoneNumber = AppContextHelper.GetStringValueClaim(HttpContext, JwtClaimTypes.Name);;
string url = $"{PatientsApiUrl}GetByResponseTeamMember?phoneNumber={System.Web.HttpUtility.UrlEncode(phoneNumber)}&valuesFilter={valuesFilter}";
var patients = Enumerable.Empty <PatientResponse>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
patients = response.ContentAsType <IEnumerable <PatientResponse> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(patients));
}
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));
}
