public async Task <IEnumerable <PatientDailyStatusResponse> > GetPatientDailyStatuses(long patientId)
{
string url = $"{PatientsApiUrl}PatientDailyStatuses/GetByPatient?patientId={patientId}";
var PatientDailyStatuses = Enumerable.Empty <PatientDailyStatusResponse>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
PatientDailyStatuses = response.ContentAsType <IEnumerable <PatientDailyStatusResponse> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(PatientDailyStatuses);
}
private async Task <FacilityTypeDTO> GetFacilityType(int facilityTypeId)
{
string url = $"{CoreApiUrl}FacilityTypes/GetById?facilityTypeId={facilityTypeId}";
var FacilityType = new FacilityTypeDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
FacilityType = response.ContentAsType <FacilityTypeDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(FacilityType);
}
private static async Task Post()
{
var model = new MovieModel
{
Id = 4,
Title = "Thunderball",
ReleaseYear = 1965,
Summary = "James Bond heads to The Bahamas to recover two nuclear warheads stolen by SPECTRE agent Emilio Largo in an international extortion scheme."
};
var requestUri = $"{baseUri}";
var response = await HttpRequestFactory.Post(requestUri, model);
Console.WriteLine($"Status: {response.StatusCode}");
//Console.WriteLine(response.ContentAsString());
var outputModel = response.ContentAsType <MovieModel>();
Console.WriteLine("{0} - {1}", outputModel.Id, outputModel.Title);
}
private async Task <HealthCareWorkerResponse> GetHealthCareWorker(int workerId)
{
string url = $"{CoreApiUrl}HealthCareWorkers/GetById?workerId={workerId}";
var HealthCareWorker = new HealthCareWorkerResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
HealthCareWorker = response.ContentAsType <HealthCareWorkerResponse>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(HealthCareWorker);
}
public async Task <IEnumerable <IdentificationTypeDTO> > GetIdentificationTypes()
{
string url = $"{CoreApiUrl}IdentificationTypes/GetAll";
var identificationTypes = Enumerable.Empty <IdentificationTypeDTO>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
identificationTypes = response.ContentAsType <IEnumerable <IdentificationTypeDTO> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(identificationTypes);
}
public void FormDataIsCopied()
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
var value = CommonTestHelpers.GenerateList(5);
var dictionary = CommonTestHelpers.GenerateDictionary(value);
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetUrl(UrlParser.GenerateUri("/Home/Index"));
httpRequest.Setup(p => p.Method).Returns("GET");
httpRequest.Setup(p => p.HasFormContentType).Returns(true);
httpRequest.Setup(p => p.Form).Returns(new CustomFormCollection(value.ToStringValuesDictionary()));
var result = HttpRequestFactory.Create(httpRequest.Object);
Assert.AreEqual(JsonSerializer.Serialize(value), JsonSerializer.Serialize(result.Properties.FormData));
}
public async Task <IActionResult> GetDistricts()
{
string url = $"{CoreApiUrl}Districts/GetAll";
var districts = Enumerable.Empty <DistrictDTO>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
districts = response.ContentAsType <IEnumerable <DistrictDTO> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(PartialView(districts));
}
public async Task <LoginResponse> Login(User usuario)
{
var baseUri = PegaUriDeLogin();
var requestUri = $"{baseUri}";
var response = await HttpRequestFactory.Post(requestUri, usuario);
if (!response.IsSuccessStatusCode)
{
throw new Exception("Não foi possível realizar o login.");
}
var responseJson = response.Content.ReadAsStringAsync().Result;
var login = JsonConvert.DeserializeObject <LoginResponse>(responseJson);
return(login);
}
private async Task <NotificationTemplateDTO> GetNotificationTemplate(int templateId)
{
string url = $"{NotificationsApiUrl}NotificationTemplates/GetById?templateId={templateId}";
var NotificationTemplate = new NotificationTemplateDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
NotificationTemplate = response.ContentAsType <NotificationTemplateDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(NotificationTemplate);
}
public async Task <IActionResult> GetResourcesAllocation()
{
string url = $"{ResourcesApiUrl}ResourcesAllocation/GetAll";
var resourcesAllocation = Enumerable.Empty <ResourceAllocationDTO>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
resourcesAllocation = response.ContentAsType <IEnumerable <ResourceAllocationDTO> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(PartialView(resourcesAllocation));
}
public string UploadHttpWebRequestByoAuth(string userID, string pwd, string status, string filename, byte[] imageStream, string apiToken, string apiTokenSecret)
{
//SinaApiService myApi = new SinaApiService();
//string myResult = myApi.status_uploadbyoauth(userID, pwd, "xml", status,
// WebConfigurationManager.AppSettings["consumerKey"],
// WebConfigurationManager.AppSettings["consumerSecret"], apiToken,
// apiTokenSecret, filename, imageStream);
var httpRequest = HttpRequestFactory.CreateHttpRequest(Method.POST) as HttpPost;
httpRequest.Token = apiToken;
httpRequest.TokenSecret = apiTokenSecret;
httpRequest.UserRemoteIP = "127.0.0.1";
string url = "http://api.t.sina.com.cn/statuses/upload.xml?";
string myResult = httpRequest.RequestWithPicture(url, "status=" + HttpUtility.UrlEncode(status), filename, imageStream);
return(myResult);
}
private async Task <IEnumerable <ResourceDTO> > GetResources()
{
string url = $"{ResourcesApiUrl}GetAll";
var resources = Enumerable.Empty <ResourceDTO>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
resources = response.ContentAsType <IEnumerable <ResourceDTO> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(resources);
}
private async Task <ResourceAllocationResponse> GetResourceAllocation(string resourceAllocationId)
{
string url = $"{ResourcesApiUrl}ResourcesAllocation/GetById?resourceAllocationId={resourceAllocationId}";
var resourceAllocation = new ResourceAllocationResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
resourceAllocation = response.ContentAsType <ResourceAllocationResponse>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(resourceAllocation);
}
public async Task <IActionResult> PendingStatusSubmission()
{
string url = $"{PatientsApiUrl}GetUnSubmittedPatientsByDate?fromSubmissionDate={DateTime.UtcNow.Date}&toSubmissionDate={DateTime.UtcNow}";
var patients = Enumerable.Empty <PatientDTO>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
patients = response.ContentAsType <IEnumerable <PatientDTO> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(patients));
}
public async void GetAllLocationsTest()
{
await this.locationRepository.CreateAsync(LocationFactory.CreateLocation(1));
await this.locationRepository.CreateAsync(LocationFactory.CreateLocation(2));
await this.locationRepository.CreateAsync(LocationFactory.CreateLocation(3));
HttpRequest request = HttpRequestFactory.CreateGetRequest();
ObjectResult result = (ObjectResult)await this.locationController.LocationGetAll(request);
List <Location> locations = (List <Location>)result.Value;
// status code should be 200 OK
Assert.Equal(200, result.StatusCode);
// amount of found locations should be 3
Assert.Equal(3, locations.Count);
}
private async Task <ScheduledNotificationResponse> GetScheduledNotification(int notificationId)
{
string url = $"{NotificationsApiUrl}ScheduledNotifications/GetById?notificationId={notificationId}";
var scheduledNotification = new ScheduledNotificationResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
scheduledNotification = response.ContentAsType <ScheduledNotificationResponse>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(scheduledNotification);
}
private async Task <PatientSymptomDTO> GetPatientSymptom(int symptomId)
{
string url = $"{PatientsApiUrl}Symptoms/GetById?symptomId={symptomId}";
var PatientSymptom = new PatientSymptomDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
PatientSymptom = response.ContentAsType <PatientSymptomDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(PatientSymptom);
}
public async Task <IActionResult> Index()
{
string url = $"{NotificationsApiUrl}ScheduledNotifications/GetAll";
var scheduledNotifications = Enumerable.Empty <ScheduledNotificationResponse>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
scheduledNotifications = response.ContentAsType <IEnumerable <ScheduledNotificationResponse> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(scheduledNotifications));
}
private async Task <DistrictResponse> GetDistrict(string districtCode)
{
string url = $"{CoreApiUrl}Districts/GetById?districtCode={districtCode}";
var district = new DistrictResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
district = response.ContentAsType <DistrictResponse>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(district);
}
public async void CreateNewLocationAsAdminNameTooLongTest()
{
Dictionary <string, StringValues> formdata = new Dictionary <string, StringValues>();
formdata.Add("Name", "Skillgarden Amsterdam op de grote buitenheuvel naast het postkantoor");
formdata.Add("City", "Amsterdam Centrum");
formdata.Add("Lat", "1.2345235");
formdata.Add("Lng", "1.2134234");
HttpRequest requestmessage = await HttpRequestFactory.CreateFormDataRequest(formdata, HttpMethod.Post);
ObjectResult result = (ObjectResult)await this.locationController.LocationCreate(requestmessage, this.adminClaim);
ErrorResponse errorResponse = (ErrorResponse)result.Value;
// status code should be 400 and errormessage = "Name can not be longer than 50 characters"
Assert.Equal(400, result.StatusCode);
Assert.Equal("Name can not be longer than 50 characters", errorResponse.Message);
}
private async Task <CountryDTO> GetCountry(string countryCode)
{
string url = $"{CoreApiUrl}Countries/GetByCode?countryCode={countryCode}";
var Country = new CountryDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
Country = response.ContentAsType <CountryDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(Country);
}
public async void CreateNewLocationAsAdminCityTooLongTest()
{
Dictionary <string, StringValues> formdata = new Dictionary <string, StringValues>();
formdata.Add("Name", "Skillgarden Wales");
formdata.Add("City", "Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch");
formdata.Add("Lat", "1.2345235");
formdata.Add("Lng", "1.2134234");
HttpRequest requestmessage = await HttpRequestFactory.CreateFormDataRequest(formdata, HttpMethod.Post);
ObjectResult result = (ObjectResult)await this.locationController.LocationCreate(requestmessage, this.adminClaim);
ErrorResponse errorResponse = (ErrorResponse)result.Value;
// status code should be 400 and errorcode = "City can not be longer than 50 characters"
Assert.Equal(400, result.StatusCode);
Assert.Equal("City can not be longer than 50 characters", errorResponse.Message);
}
private async Task <DataCenterResponse> GetDataCenter(int centerId)
{
string url = $"{CoreApiUrl}DataCenters/GetById?centerId={centerId}";
var dataCenter = new DataCenterResponse();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
dataCenter = response.ContentAsType <DataCenterResponse>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(dataCenter);
}
public async void CreateNewLocationAsAdminCityTooShortTest()
{
Dictionary <string, StringValues> formdata = new Dictionary <string, StringValues>();
formdata.Add("Name", "Skillgarden Wales");
formdata.Add("City", "X");
formdata.Add("Lat", "1.2345235");
formdata.Add("Lng", "1.2134234");
HttpRequest requestmessage = await HttpRequestFactory.CreateFormDataRequest(formdata, HttpMethod.Post);
ObjectResult result = (ObjectResult)await this.locationController.LocationCreate(requestmessage, this.adminClaim);
ErrorResponse errorResponse = (ErrorResponse)result.Value;
// status code should be 400 and errorcode = "City must be at least 2 characters"
Assert.Equal(400, result.StatusCode);
Assert.Equal("City must be at least 2 characters", errorResponse.Message);
}
private async Task <ResponseTeamMemberDTO> GetResponseTeamMember(int teamMemberId)
{
string url = $"{CoreApiUrl}ResponseTeamMembers/GetById?teamMemberId={teamMemberId}";
var responseTeamMember = new ResponseTeamMemberDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
responseTeamMember = response.ContentAsType <ResponseTeamMemberDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(responseTeamMember);
}
public async void CreateNewLocationAsAdminLngNoDoubleTest()
{
Dictionary <string, StringValues> formdata = new Dictionary <string, StringValues>();
formdata.Add("Name", "Skillgarden Amsterdam");
formdata.Add("City", "Amsterdam");
formdata.Add("Lat", "1.2134234");
formdata.Add("Lng", "één punt twee drie negen vier");
HttpRequest requestmessage = await HttpRequestFactory.CreateFormDataRequest(formdata, HttpMethod.Post);
ObjectResult result = (ObjectResult)await this.locationController.LocationCreate(requestmessage, this.adminClaim);
ErrorResponse errorResponse = (ErrorResponse)result.Value;
// status code should be 400 and errorcode = "Lat must be a double"
Assert.Equal(400, result.StatusCode);
Assert.Equal("Lng must be a double", errorResponse.Message);
}
public async Task <IActionResult> Index()
{
string url = $"{CoreApiUrl}FacilityTypes/GetAll";
var FacilityTypes = Enumerable.Empty <FacilityTypeDTO>();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
FacilityTypes = response.ContentAsType <IEnumerable <FacilityTypeDTO> >();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(View(FacilityTypes));
}
public async void CreateNewLocationAsAdminNoImageTest()
{
Dictionary <string, StringValues> formdata = new Dictionary <string, StringValues>();
formdata.Add("Name", "Skillgarden Amsterdam");
formdata.Add("City", "Amsterdam Centrum");
formdata.Add("Lat", "1.2345235");
formdata.Add("Lng", "1.2134234");
HttpRequest requestmessage = await HttpRequestFactory.CreateFormDataRequest(formdata, HttpMethod.Post, "empty");
ObjectResult result = (ObjectResult)await this.locationController.LocationCreate(requestmessage, this.adminClaim);
ErrorResponse errorResponse = (ErrorResponse)result.Value;
// status code should be 400 INVALID_REQUEST_BODY
Assert.Equal(400, result.StatusCode);
Assert.Equal(ErrorCode.INVALID_REQUEST_BODY, errorResponse.ErrorCodeEnum);
}
private async Task <ScheduledNotificationEscalationRuleDTO> GetScheduledNotificationEscalationRule(int ruleId)
{
string url = $"{NotificationsApiUrl}ScheduledNotificationEscalationRules/GetById?ruleId={ruleId}";
var ScheduledNotificationEscalationRule = new ScheduledNotificationEscalationRuleDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
ScheduledNotificationEscalationRule = response.ContentAsType <ScheduledNotificationEscalationRuleDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(ScheduledNotificationEscalationRule);
}
private async Task <NationalityDTO> GetNationality(string nationalityCode)
{
string url = $"{CoreApiUrl}Nationalities/GetByCode?nationalityCode={nationalityCode}";
var Nationality = new NationalityDTO();
var accessToken = await HttpContext.GetTokenAsync("access_token");
var response = await HttpRequestFactory.Get(accessToken, url);
if (response.StatusCode == HttpStatusCode.OK)
{
Nationality = response.ContentAsType <NationalityDTO>();
}
else
{
ModelState.AddModelError("", HttpResponseHandler.Process(response));
}
return(Nationality);
}
