public async Task <FeedbackResultViewModel> FeedbackResultBuilder(FeedbackViewModel feedback)
{
feedback.DateAdded = DateTime.Now;
feedback.PageData = await _pageDateViewModelBuilder.PageDataBuilder(feedback.PageData);
feedback.PageId = feedback.PageData.ToString();
try
{
var request = new JsonRestRequest(_configuration.FeedbackAddFeedbackUrl, Method.POST);
request.AddJsonBody(feedback);
if (!string.IsNullOrEmpty(_configuration.FeedbackApiUsername) && !string.IsNullOrEmpty(_configuration.FeedbackApiPassword))
{
request.Credentials = new NetworkCredential(_configuration.FeedbackApiUsername, _configuration.FeedbackApiPassword);
}
var response = await _restClient.ExecuteAsync(request);
if (response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Created)
{
return(new FeedbackConfirmationResultViewModel(feedback));
}
}
catch
{
return(new FeedbackErrorResultViewModel(feedback));
}
return(new FeedbackErrorResultViewModel(feedback));
}
public async void GetFullPathwayJourney_returns_expected_journey(IEnumerable <JourneyStep> journey, int totalJourneyLength, int totalQuestions, int totalInlineCareAdvices, int totalInterimCareAdvice, int totalReads, int totalSets, string startingpPathwayId, string dispositionCode, string traumaType, IDictionary <string, string> state)
{
var fullPathwayJourney = new FullPathwayJourney
{
JourneySteps = journey,
StartingPathwayId = startingpPathwayId,
StartingPathwayType = traumaType,
DispostionCode = dispositionCode,
State = state
};
var request = new JsonRestRequest(BusinessApiFullJourneyUrl, Method.POST);
request.AddJsonBody(fullPathwayJourney);
var result = await _restClient.ExecuteAsync <List <QuestionWithAnswers> >(request);
//this checks a response is returned
Assert.IsNotNull(result);
var questions = result.Data;
//check correct journey length and make up of nodes returned
Assert.AreEqual(totalJourneyLength, questions.Count);
Assert.AreEqual(totalQuestions, questions.Count(q => q.Labels.Contains("Question")));
Assert.AreEqual(totalReads, questions.Count(q => q.Labels.Contains("Read")));
Assert.AreEqual(totalSets, questions.Count(q => q.Labels.Contains("Set")));
Assert.AreEqual(totalInterimCareAdvice, questions.Count(q => q.Labels.Contains("InterimCareAdvice")));
}
public JsonRestRequest BuildGetMapRequest(long mapId)
{
var request = new JsonRestRequest(Endpoints.MapsUrl, Method.GET);
request.AddUrlSegment("mapId", mapId.ToString());
return(request);
}
public JsonRestRequest BuildGetActivityRequest(long activityId)
{
var request = new JsonRestRequest(Endpoints.ActivitiesUrl, Method.GET);
request.AddUrlSegment("activityId", activityId.ToString());
return(request);
}
public async Task MessageCaseDataCaptureApi_SendsRequestWithCorrectParameters()
{
// Arrange
var builder = new RegisterForSMSViewModelBuilder(_mockConfiguration.Object, _mockRestClient.Object);
var mobileNumber = "1234567891";
var endPointUrl = "api/test-endpoint";
var model = new SendSmsOutcomeViewModel()
{
MobileNumber = mobileNumber, VerificationCodeInput = new VerificationCodeInputViewModel()
{
InputValue = "654321"
}
};
var expectedRequest = new JsonRestRequest(endPointUrl, Method.POST).AddJsonBody(mobileNumber);
_mockRestClient.Setup(s => s.ExecuteAsync(It.IsAny <IRestRequest>())).ReturnsAsync(new RestResponse());
// Act
var result = await builder.MessageCaseDataCaptureApi <VerifySMSCodeRequest, SMSEnterVerificationCodeViewDeterminer>(model, endPointUrl);
// Assert
_mockRestClient.Verify(m => m.ExecuteAsync(It.Is <RestRequest>(
r => r.Method == Method.POST &&
r.Resource == endPointUrl &&
((VerifySMSCodeRequest)r.Parameters[0].Value).MobilePhoneNumber == mobileNumber)), Times.Once);
}
public async Task <TResponse> SendJsonAsync <TResponse>(string method, string endpoint, object payload, RequestOptions options)
{
string json = payload != null?SerializeJson(payload) : null;
var request = new JsonRestRequest(RestClient, method, endpoint, json, options);
return(Deserialize <TResponse>(await SendInternalAsync(request).ConfigureAwait(false)));
}
public JsonRestRequest BuildAddMapRequest(Map map)
{
var request = new JsonRestRequest(Endpoints.MapsUrl, Method.POST);
request.RemoveUrlSegment("mapId");
request.AddBody(map);
return(request);
}
public JsonRestRequest BuildAddActivityRequest(Activity activity)
{
var request = new JsonRestRequest(Endpoints.ActivitiesUrl, Method.POST);
request.RemoveUrlSegment("activityId");
request.AddBody(activity);
return(request);
}
private async Task <IRestResponse> SendRequestToDataCaptureApi <T>(string endPoint, T body)
{
var request = new JsonRestRequest(endPoint, Method.POST);
request.AddJsonBody(body);
return(await _restClientCaseDataCaptureApi.ExecuteAsync(request));
}
private async Task <IRestResponse> SendItkMessage(ITKDispatchRequest itkRequestData)
{
var request = new JsonRestRequest(_configuration.ItkDispatcherApiSendItkMessageUrl, Method.POST);
request.AddJsonBody(itkRequestData);
var response = await _restClientItkDispatcherApi.ExecuteAsync(request);
return(response);
}
public JsonRestRequest BuildAddActorRequest(Actor actor)
{
var request = new JsonRestRequest(Endpoints.ActorsUrl, Method.POST);
request.AddUrlSegment("activityId", actor.ActivityId.ToString());
request.RemoveUrlSegment("actorId");
request.AddBody(actor);
return(request);
}
public JsonRestRequest BuildAddActionRequest(long activityId, Action action)
{
var request = new JsonRestRequest(Endpoints.ActionsUrl, Method.POST);
request.AddUrlSegment("activityId", action.ActivityId.ToString());
request.RemoveUrlSegment("actionId");
request.AddBody(action);
return(request);
}
public IRestResponse <T> ExecuteJsonRequest <T>(JsonRestRequest request) where T : new()
{
RestClient client = new RestClient(BaseUrl);
client.AddHandler("application/json", () => { return(new JsonDeserializer()); });
IRestResponse <T> response = client.Execute <T>(request);
return(response);
}
public async Task <IEnumerable <QuestionWithAnswers> > GetPathwayJourney(JourneyStep[] steps, string startingPathwayId, string dispositionCode, string gender, int age)
{
var request = new JsonRestRequest(_configuration.GetDomainApiPathwayJourneyUrl(startingPathwayId, dispositionCode, gender, age), Method.POST);
request.AddJsonBody(steps);
var pathwayJourney = await _restClient.ExecuteAsync <IEnumerable <QuestionWithAnswers> >(request);
return(pathwayJourney.Data);
}
public void Log(AuditEntry auditEntry)
{
Task.Run(() =>
{
var url = _configuration.LoggingServiceApiAuditUrl;
var request = new JsonRestRequest(url, Method.POST);
request.AddJsonBody(auditEntry);
_restClient.ExecuteAsync(request);
});
}
public async Task <QuestionWithAnswers> GetNextQuestion(string id, string nodeLabel, string answer)
{
return(await _cacheStore.GetOrAdd(new QuestionWithAnswersCacheKey(id, nodeLabel, answer), async() =>
{
var request = new JsonRestRequest(_configuration.GetDomainApiNextQuestionUrl(id, nodeLabel), Method.POST);
request.AddJsonBody(answer);
var questions = await _restClient.ExecuteAsync <QuestionWithAnswers>(request);
return HandleRestResponse(questions);
}));
}
public async Task SendJsonAsync(string method, string endpoint, object payload, RequestOptions options = null)
{
options = options ?? new RequestOptions();
var json = payload != null?SerializeJson(payload) : null;
var request = new JsonRestRequest(RestClient, method, endpoint, json, options);
await SendInternalAsync(method, endpoint, request).ConfigureAwait(false);
}
private async Task <List <QuestionWithAnswers> > GetFullJourney(QuestionViewModel model)
{
var request = new JsonRestRequest(_configuration.BusinessApiGetFullPathwayJourneyUrl, Method.POST);
request.AddJsonBody(model.Journey.Steps.ToArray());
var response = await _restClientBusinessApi.ExecuteAsync <List <QuestionWithAnswers> >(request)
.ConfigureAwait(false);
return(response.Data);
}
public async Task <QuestionWithAnswers> GetNextNode(QuestionViewModel model)
{
var answer = JsonConvert.DeserializeObject <Answer>(model.SelectedAnswer);
var serialisedState = HttpUtility.UrlEncode(model.StateJson);
var request = new JsonRestRequest(_configuration.GetBusinessApiNextNodeUrl(model.PathwayId, model.NodeType, model.Id, serialisedState, true), Method.POST);
request.AddJsonBody(answer.Title);
var response = await _restClientBusinessApi.ExecuteAsync <QuestionWithAnswers>(request).ConfigureAwait(false);
return(response.Data);
}
public async Task <Collection <Action> > List(long mapId)
{
throw new NotImplementedException();
var request = new JsonRestRequest(_requestBuilder.Endpoints.ActionsUrl, Method.GET)
.AddUrlSegment("mapId", mapId.ToString());
var restResponse = await _restClient.ExecuteTaskAsync <List <ApiAction> >(request);
_responseValidator.Validate(restResponse);
return(_actionConvertor.Convert(restResponse.Data));
}
public IRestResponse <List <Forecast> > GetForecasts()
{
string resource = APIResources.GetWeatherForecastResource;
var request = new JsonRestRequest(Method.GET, resource);
var response = ExecuteJsonRequest <List <Forecast> >(request);
StatusCode = response.StatusCode;
return(response);
}
private async Task <IEnumerable <QuestionWithAnswers> > GetModuleZeroJourney(string gender, int age, string traumaType)
{
var pathwayJourney = _modZeroJourneyStepsBuilder.GetModZeroJourney(gender, age, traumaType);
var steps = pathwayJourney.Steps;
var request = new JsonRestRequest(_configuration.GetDomainApiPathwayJourneyUrl(pathwayJourney.PathwayId, pathwayJourney.DispositionId, gender, age), Method.POST);
request.AddJsonBody(steps);
var moduleZeroJourney = await _restClient.ExecuteAsync <IEnumerable <QuestionWithAnswers> >(request);
var state = BuildState(gender, age, pathwayJourney.State);
var filteredModZeroJourney = NavigateReadNodeLogic(steps.ToArray(), moduleZeroJourney.Data.ToList(), state);
return(filteredModZeroJourney);
}
public async Task <IEnumerable <CareAdvice> > FillCareAdviceBuilder(string dxCode, string ageGroup, string gender, IList <string> careAdviceKeywords)
{
if (!careAdviceKeywords.Any())
{
return(Enumerable.Empty <CareAdvice>());
}
var businessApiInterimCareAdviceUrl = _configuration.GetBusinessApiInterimCareAdviceUrl(dxCode, ageGroup, gender);
var request = new JsonRestRequest(businessApiInterimCareAdviceUrl, Method.POST);
request.AddJsonBody(GenerateKeywordsList(careAdviceKeywords));
var careAdvices = await _restClient.ExecuteAsync <IEnumerable <CareAdvice> >(request);
CheckResponse(careAdvices);
return(careAdvices.Data);
}
public async Task <IEnumerable <CareAdvice> > GetCareAdvice(string ageCategory, string gender, string keywords, string dxCode)
{
return(await _cacheStore.GetOrAdd(new CareAdviceCacheKey(ageCategory, gender, keywords, dxCode), async() =>
{
var domainApiCareAdviceUrl = _configuration.GetDomainApiCareAdviceUrl(dxCode, ageCategory, gender);
var request = new JsonRestRequest(domainApiCareAdviceUrl, Method.POST);
request.AddJsonBody(keywords);
var response = await _restClient.ExecuteAsync <IEnumerable <CareAdvice> >(request);
if (!response.IsSuccessful)
{
throw new Exception(string.Format("A problem occured requesting {0}. {1}", domainApiCareAdviceUrl, response.ErrorMessage));
}
return response.Data;
}));
}
public async Task <DosCheckCapacitySummaryResult> FillCheckCapacitySummaryResult(DosViewModel dosViewModel, bool filterServices, DosEndpoint?endpoint)
{
var checkCapacitySummaryUrl = string.Format("{0}?filterServices={1}&endpoint={2}", _configuration.BusinessDosApiCheckCapacitySummaryUrl, filterServices, endpoint);
var dosFilterdCase = dosViewModel as DosFilteredCase;
var request = new JsonRestRequest(checkCapacitySummaryUrl, Method.POST);
request.AddJsonBody(dosFilterdCase);
_logger.Debug(string.Format("DOSBuilder.FillCheckCapacitySummaryResult(): URL: {0} BODY: {1}", checkCapacitySummaryUrl, JsonConvert.SerializeObject(dosFilterdCase)));
var response = await _restClient.ExecuteAsync <DosCheckCapacitySummaryResult>(request);
if (!response.IsSuccessful || response.Data.Error != null)
{
return(response.Data);
}
var services = new List <ServiceViewModel>();
if (response.Data.Success != null)
{
var checkCapacitySummaryResults = JsonConvert.SerializeObject(response.Data.Success.Services);
var jArray = (JArray)JsonConvert.DeserializeObject(checkCapacitySummaryResults);
services = jArray.ToObject <List <ServiceViewModel> >();
}
var checkCapacitySummaryResult = new DosCheckCapacitySummaryResult()
{
Success = new SuccessObject <ServiceViewModel>()
{
Code = (int)response.StatusCode,
Services = FilterCallbackEnabled(services)
}
};
return(checkCapacitySummaryResult);
}
//Test to show answer nodes are checked in the correct order so that 'evaluate variables' are handled correctly.
public async void TestGetQuestion_returns_expected_Next_QuestionAgeVariable()
{
var expectedNexQuestionId = "PW628.13100";
var NodeId = "PW628.10700";
var state = "{\"PATIENT_AGE\":\"50\",\"PATIENT_GENDER\":\"\\\"F\\\"\",\"PATIENT_PARTY\":\"1\",\"PATIENT_AGEGROUP\":\"Adult\"}";
var requestUrl = string.Format(BusinessApiNextNodeUrl, _testPathwayNo3, "Question", NodeId, HttpUtility.UrlEncode(state));
var request = new JsonRestRequest(requestUrl, Method.POST);
request.AddJsonBody("No");
var response = await _restClient.ExecuteAsync(request);
//this checks a responce is returned
Assert.IsNotNull(response);
var content = response.Content;
//these check the right fields are returned
Assert.IsTrue(content.Contains("\"id\":\"" + expectedNexQuestionId + "\""));
SchemaValidation.AssertValidResponseSchema(content, SchemaValidation.ResponseSchemaType.Question);
//this next one checks the right question has returned
Assert.IsTrue(content.Contains("\"questionNo\":\"TX220118"));
}
public static T GetGeographyQuestions <T>() where T : new()
{
var req = new JsonRestRequest("api/questions", Method.GET);
return(RestSharpClient.Execute <T>(req));
}
public static string GetGeographyQuestions()
{
var req = new JsonRestRequest("api/questions", Method.GET);
return(RestSharpClient.Execute(req));
}
public static async Task <T> GetGeographyQuestionsAsync <T>() where T : new()
{
var req = new JsonRestRequest("api/questions", Method.GET);
return(await RestSharpClient.ExecuteAsyn <T>(req));
}
