public CollectionResult <Observation> GetResidentObservations(ObservationParams observationParams)
{
var observations = GetAllObservations();
var query = FillObservationQueryParams(observationParams);
observations = observations.Where(query);
var totalCount = observations.Count();
var result = observations
.OrderByDescending(t => t.RecordedDate)
.Skip(observationParams.Skip)
.Take(observationParams.Take)
.AsNoTracking()
.ToList();
var observationsResult = new CollectionResult <Observation>
{
Collection = result,
TotalCount = totalCount
};
return(observationsResult);
}
public CollectionResult <ObservationDto> GetObservationsByParams(ObservationParams filterParams)
{
var observations = _unitOfWork.ObservationRepository.GetResidentObservations(filterParams);
var result = new CollectionResult <ObservationDto>
{
TotalCount = observations.TotalCount,
Collection = AutoMapper.Mapper.Map <IEnumerable <Observation>, List <ObservationDto> >(observations.Collection)
};
return(result);
}
private Expression <Func <Observation, bool> > FillObservationQueryParams(ObservationParams filterParams)
{
var predicate = PredicateBuilder.New <Observation>(t => t.ResidentId == filterParams.ResidentId);
if (filterParams.Type.HasValue)
{
predicate = predicate.And(t => t.Type == filterParams.Type);
}
if (filterParams.StartDate.HasValue && filterParams.EndDate.HasValue)
{
predicate = predicate.And(t => t.RecordedDate >= filterParams.StartDate.Value && t.RecordedDate <= filterParams.EndDate.Value);
}
return(predicate);
}
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
// Conversation Flow Accessors state setup
var conversationFlowAccessors = _conversationState.CreateProperty <ConversationFlow>(nameof(ConversationFlow));
ConversationFlow flow = await conversationFlowAccessors.GetAsync(turnContext, () => new ConversationFlow(), cancellationToken);
// ObservationParams state setup
var observationParamsAccessor = _userState.CreateProperty <ObservationParams>(nameof(ObservationParams));
ObservationParams observationParams = await observationParamsAccessor.GetAsync(turnContext, () => new ObservationParams(), cancellationToken);
// Start question Process
await StartQuestioningProcess(flow, observationParams, turnContext, cancellationToken);
// Save data changes
await _conversationState.SaveChangesAsync(turnContext, false, cancellationToken);
await _userState.SaveChangesAsync(turnContext, false, cancellationToken);
}
public IActionResult GetObservation([FromBody] GetObservationsModel model)
{
var filterParams = new ObservationParams
{
ResidentId = model.ResidentId,
Type = model.Type,
Take = model.Take
};
var observations = _observationService.GetObservationsByParams(filterParams);
var firstObservation = observations.Collection.FirstOrDefault();
var residentObservations = new ResidentObservationModel
{
ResidentId = model.ResidentId,
Date = firstObservation?.RecordedDate,
Observations = observations.Collection.ToList()
};
return(Ok(residentObservations));
}
public IActionResult GetObservationsByParams([FromBody] ObservationParams filterParams)
{
var observations = _observationService.GetObservationsByParams(filterParams);
return(Json(JsonResultData.Success(observations)));
}
private async Task StartQuestioningProcess(ConversationFlow conversationFlow, ObservationParams observationParams, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken)
{
string input = turnContext.Activity.Text?.Trim();
string message = string.Empty;
switch (conversationFlow.Question)
{
case Question.None:
// Move to the next question
conversationFlow.Question = Question.ObservationStartDateQuestion;
await turnContext.SendActivityAsync("Enter observation Start-Date", null, null, cancellationToken);
break;
case Question.ObservationStartDateQuestion:
observationParams.StartDate = DateTime.Parse(input);
await turnContext.SendActivityAsync("And please observation End-Date", null, null, cancellationToken);
// Move to the next question
conversationFlow.Question = Question.ObservationEndDateQuestion;
break;
case Question.ObservationEndDateQuestion:
observationParams.EndDate = DateTime.Parse(input);
await turnContext.SendActivityAsync("Observation type", null, null, cancellationToken);
conversationFlow.Question = Question.ObservationTypeQuestion;
break;
case Question.ObservationTypeQuestion:
observationParams.ObservationType = input;
string observationDataText = await _externalApiAgregetionService.GetObservarionText(_config.Value.ApiKey, observationParams.StartDate, observationParams.EndDate, turnContext, cancellationToken);
await turnContext.SendActivityAsync(MessageFactory.Text(observationDataText, observationDataText), cancellationToken);
await turnContext.SendActivityAsync("Observation type", null, null, cancellationToken);
// Move to the first question
conversationFlow.Question = Question.ObservationTypeQuestion;
break;
}
}
