public async Task SetAnswers([FromBody] AnswerRequest request)
{
foreach (var answer in request.Answers)
{
var dQuestion = new DQuestion
{
UserId = request.UserId,
QuestionId = answer.Key,
Answer = answer.Value
};
_context.DQuestions.Add(dQuestion);
}
await _context.SaveChangesAsync();
Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMinutes(1));
await _predictionService.CreateActivityPredictionsAsync(request.UserId);
var userIds = await _matchUsersService.CreateAvailableActivitiesAsync();
var devices = _notificationManager.GetDevicesForTags(userIds);
foreach (var d in devices)
{
_notificationManager.SendMessage(d, _notificationManager.ConstructMessage("new"));
}
});
}
public async Task <ActionResult <AnswerRequest> > PostAnswerRequest(AnswerRequest answerRequest)
{
_context.AnswerRequests.Add(answerRequest);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAnswerRequest", new { id = answerRequest.AnswerId }, answerRequest));
}
public async Task <IActionResult> PutAnswerRequest(short id, AnswerRequest answerRequest)
{
if (id != answerRequest.AnswerId)
{
return(BadRequest());
}
_context.Entry(answerRequest).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnswerRequestExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// GET: AnswerRequests/Details/5
public async Task <IActionResult> Details(short?id)
{
try
{
if (id == null)
{
return(NotFound());
}
// Préparation de l'appel à l'API
string accessToken = await HttpContext.GetTokenAsync("access_token");
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Récurération des données et convertion des données dans le bon type
string content = await client.GetStringAsync(_configuration["URLAPI"] + $"api/AnswerRequests/{id}");
AnswerRequest answerRequest = JsonConvert.DeserializeObject <AnswerRequest>(content);
if (answerRequest == null)
{
return(NotFound());
}
return(View(answerRequest));
}
catch (HttpRequestException e)
{
return(Unauthorized());
}
}
public void ChooseByBtn()
{
//ตอบ
var answer = Answers.Where(x => x.AnswerNo == CurrentChoices.QuestionNo).FirstOrDefault();
answer.Choice = CurrentChoices;
AnswerRequest ans = new AnswerRequest
{
ExamSheetId = TestingData.sheet._id,
ClientId = TestingData.Config.ClientId,
Qid = QuestionSelect.Question._id,
ChoiceId = CurrentChoices._id,
};
svc.Answer(ans);
if (Answers.Where(x => x.Choice.ChoiceNo == 0).Count() == 0)
{
SendExamVisibility = Visibility.Visible;
//LeftScrollVisibility = Visibility.Collapsed;
//TODO ปุ่มส่งผลสอบกระพิบ
}
else
{
//ไปข้อถัดไป
NextQuestion();
}
}
public async Task <IActionResult> AddAnswerAsync([FromBody] AnswerRequest answerRequest)
{
AnswerResponse answerResponse = new AnswerResponse();
try
{
await answerRequest.GetRequestedUserAsync(_dbContext);
Answer answer = answerRequest?.Answer;
if (answer == null)
{
throw new Exception("Answer is empty");
}
await _dbContext.Answers.AddAsync(answer);
await _dbContext.SaveChangesAsync();
answerResponse.Answers = new List <Answer>()
{
await _dbContext.Answers.FindAsync(answer.Id)
};
answerResponse.Message = "Answer added";
answerResponse.IsSuccess = true;
}
catch (Exception ex)
{
answerResponse.Message = ex.Message;
}
return(StatusCode(answerResponse.Status, answerResponse));
}
public async Task <ActionResult> ValidateAnswer(AnswerRequest answer)
{
InitSetAnswersArguments(answer);
var stepresult = await ExecuteFlowAsync();
return(ValidateStepResult(stepresult));
}
public static async Task ExecuteChallengeAsync(CancellationToken cancelToken)
{
var service = new ApiService();
var token = await service.GetTokenByApiAsync(cancelToken); // Get token from api call
var magazineIdsByCategoriesTask = GetMagazineIdsByCategoriesAsync
(token, (await service.GetCategoriesByApiAsync(token, cancelToken)).Data, service, cancelToken);
var subscribersTask = service.GetSubscribersByApiAsync(token, cancelToken); // Get subscribers by api call
var magazineIdsByCategory = await magazineIdsByCategoriesTask;
var subscribers = await subscribersTask; // both subscribers and magazine are called async as they are not dependent on each other.
var subscribersWithMagazineIds = GetSubscribersWithMagazineIds(subscribers);
var subscriberSubscribedEachCategory = GetSubscriberSubscribedEachCategory(subscribersWithMagazineIds, magazineIdsByCategory);
var answerRequest = new AnswerRequest()
{
Subscribers = subscriberSubscribedEachCategory
};
var result = await service.PostAnswerToApiAsync(token, answerRequest, cancelToken);
PrintPropertiesOfAnswerObject(result);
}
public async Task <AnswerResponse> PostAnswerToApiAsync(string token, AnswerRequest answerRequest, CancellationToken cancelToken)
{
var url = WebApiUrl.GetConnectionStringForAnswer(token);
var body = JsonConvert.SerializeObject(answerRequest);
var response = await WebApiHelper.GetWebApiResponseAsync <AnswerResponse>(url, HttpMethod.Post, HttpClient, body, cancelToken);
return(response);
}
public async Task <IActionResult> AddAnswer([FromBody] AnswerRequest request)
{
if (await _feedbackService.AddAnswer(request))
{
return(Ok());
}
return(BadRequest("False"));
}
public void Answer(AnswerRequest answer)
{
var client = new RestClient(serviceUrl);
var request = new RestRequest("Client/Answer", Method.POST);
request.AddParameter("application/json", JsonConvert.SerializeObject(answer), ParameterType.RequestBody);
var response = client.Execute(request);
}
public static Result AnswerRequestToResult(AnswerRequest request)
{
Result result = new Result();
result.AnswerId = request.AnswerId;
result.QuestionId = request.QuestionId;
result.userId = request.UserId;
return(result);
}
public AnswerSettingsBuilder()
{
_channel = string.Empty;
_identification = string.Empty;
_answerRequest = new AnswerRequest();
_paramProduct = string.Empty;
_product = string.Empty;
_identificationType = string.Empty;
}
public async Task <AnswerResponse> PostAnswer(string token, string[] subscribers)
{
AnswerRequest request = new AnswerRequest {
subscribers = subscribers
};
string action = $"/answer/{token}";
return(await Communication.Post <AnswerResponse, AnswerRequest>(action, request));
}
public async Task <IActionResult> Update(int answerId, AnswerRequest answerRequest)
{
bool updated = await _answerService.UpdateAsync(answerId, answerRequest);
if (updated)
{
return(Ok(await _answerService.GetByIdAsync(answerId)));
}
return(NotFound());
}
public async Task <ActionResult <NextQuestionResponse> > SetAnswer(AnswerRequest answer)
{
if (!await SurveyService.ValidateAnswerRequest(_context, answer))
{
return(NotFound());
}
_context.Result.Add(SurveyService.AnswerRequestToResult(answer));
await _context.SaveChangesAsync();
return(await SurveyService.GetNextQuestonNumber(_context, answer.QuestionId));
}
public override AnswerResponse Handle(ParticipatingInfo participant, AnswerRequest request)
{
var result = base.Handle(participant, request);
if (!result.HasError)
{
participant.CircutePercent = decimal.Parse(request.Message);
return(result);
}
return(result);
}
public async Task <string> Answer(ulong userId, int supportRequestId, string text)
{
var request = new AnswerRequest
{
UserId = userId,
SupportRequestId = supportRequestId,
Text = text
};
var reply = await _client.AnswerAsync(request);
return(reply.Message);
}
public void Answer()
{
AnswerRequest ans = new AnswerRequest
{
ExamSheetId = TestingData.sheet._id,
ClientId = TestingData.Config.ClientId,
Qid = CurrentQuestion._id,
ChoiceId = CurrentQuestion.UserAnswer._id,
};
svc.Answer(ans);
}
public static async Task <AnswerResponse> PostAnswerToAPIAsync(List <string> Ids, string token)
{
var url = WebApiUrl.GetConnectionStringForAnswer(token);
var answerRequest = new AnswerRequest()
{
subscribers = Ids
};
var payload = new AnswerRequestResponseInfo(answerRequest);
var response = await RestSharpImp.CallApiGenericPostMethod(payload, url);
return(response);
}
public static string Answer(
AnswerRequest request,
IAkinatorServer server)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var url = $"{server.ServerUrl}/answer?session={request.Session}&signature={request.Signature}&step={request.Step}&answer={(int)request.Choice}";
return(url);
}
public async Task <bool> UpdateAsync(int answerId, AnswerRequest answerRequest)
{
Answer existingAnswer = await _answerRepository.GetByIdAsync(answerId);
if (existingAnswer == null)
{
return(false);
}
existingAnswer.Body = answerRequest.Body;
existingAnswer.TimesSelected = answerRequest.TimesSelected;
return(await _answerRepository.UpdateAsync(existingAnswer));
}
public async Task <IActionResult> AddAnswer(Guid questionId, [FromBody] AnswerRequest request)
{
if (!ModelState.IsValid)
{
return(GetModelErrorResponse());
}
request.QuestionId = questionId;
// request.UserId = extract from token payload
var answerId = await _question.RegisterAnswer(request);
return(GetResponse <Guid>(answerId, StatusCodes.Status201Created));
}
public async Task <Answer> PostAnswerAsync(string datasetId, AnswerRequest request)
{
var url = $"api/{datasetId}/answer";
var content = new StringContent(
JsonConvert.SerializeObject(request),
Encoding.UTF8,
"application/json"
);
var response = await _http.PostAsync(url, content);
var str = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <Answer>(str));
}
public object ProcessRequest(byte[] requestBytes, IPAddress address, WebSocket socket)
{
var requestAsString = _toStringConverter.Convert(requestBytes);
try
{
var json = JObject.Parse(requestAsString);
var type = json["type"].ToString();
var payload = json["payload"].ToString();
switch (type)
{
case "clientOffer":
var clientOfferRequest = new ClientOfferRequest(address, socket, payload);
var clientOfferRequestHandler = _handlersFactory.Create(clientOfferRequest, clientOfferRequest.GetResponseType());
return(clientOfferRequestHandler.Handle(clientOfferRequest));
case "serverOffer":
var serverRequest = new ServerOfferRequest(address, socket, payload);
var serverRequestHandler = _handlersFactory.Create(serverRequest, serverRequest.GetResponseType());
return(serverRequestHandler.Handle(serverRequest));
case "answer":
var answerRequest = new AnswerRequest(address, socket, payload);
var answerRequestHandler = _handlersFactory.Create(answerRequest, answerRequest.GetResponseType());
return(answerRequestHandler.Handle(answerRequest));
case "new-ice":
var newICERequest = new NewICEAvailableRequest(address, socket, payload);
var newICERequestHandler = _handlersFactory.Create(newICERequest, newICERequest.GetResponseType());
return(newICERequestHandler.Handle(newICERequest));
case "txt":
default:
var txtRequest = new TxtRequest(address, socket, payload);
var txtRequestHandler = _handlersFactory.Create(txtRequest, txtRequest.GetResponseType());
return(txtRequestHandler.Handle(txtRequest));
}
}
catch (System.Exception ex)
{
return($@"An error {ex} occured.");
}
}
public async Task <Guid> RegisterAnswer(AnswerRequest request)
{
var answerId = Guid.NewGuid();
var command = new AnswerCommand
{
Id = answerId,
Body = request.Body,
UserId = request.UserId,
QuestionId = request.QuestionId
};
await _mediator.Send(command);
return(answerId);
}
public async Task <Answer> AnswerAsync(string id, AnswerRequest request, CancellationToken cancellationToken)
{
var answer = new Answer {
QuestionId = id, Content = request.Content, Id = Guid.NewGuid().ToString()
};
_answerCollection.InsertOneAsync(answer, cancellationToken);
var filter = Builders <Question> .Filter.Eq(q => q.Id, id);
var update = Builders <Question> .Update.Push(q => q.Answers, answer.Id);
await _questionCollection.UpdateOneAsync(filter, update, null, cancellationToken);
return(answer);
}
public IActionResult PostAnswer(string gameId,
[FromBody] AnswerRequest answer)
{
_log.LogInformation($"Add an answer to {gameId}: {answer.Answer}");
if (answer.Answer == null)
{
return(new StatusCodeResult(400));
}
var ans = _answerService.AddAnswer(answer.Answer, gameId);
if (ans == null)
{
return(new StatusCodeResult(404));
}
return(new JsonResult(ans));
}
public async Task AnswerAsync_Right_ShouldBeOk()
{
var question = await CreateOrGetOneQuestionWithNoAnswerAsync();
question.Should().NotBeNull();
var answer = new AnswerRequest {
Content = "问题一的回答一"
};
await _questionService.AnswerAsync(question.Id, answer, CancellationToken.None);
var questionWithAnswer = await _questionService.GetWithAnswerAsync(question.Id, CancellationToken.None);
questionWithAnswer.Should().NotBeNull();
questionWithAnswer.AnswerList.Should().NotBeEmpty();
questionWithAnswer.AnswerList.First().Content.Should().Be(answer.Content);
}
public void InitSetAnswersArguments(AnswerRequest answer)
{
var userId = long.Parse(User.Identity.GetUserId(), CultureInfo.InvariantCulture);
ProcessFlowArgument.User = new User
{
Id = userId
};
ProcessFlowArgument.Execution = new Execution
{
ProductId = 1,
Id = ExecutionId
};
ProcessFlowArgument.IsSubmitting = true;
var arg = ProcessFlowArgument as IAnswerQuestionArgument;
arg.AnswerRequest = answer;
ProcessFlowArgument = arg;
}
/// <summary>
/// A Player has answered.
/// The result of this method is to show the waiting screen to everyone who has already answered and then when everyone has answered to show the voting screen
/// </summary>
public void Answer(AnswerRequest data)
{
Trace.TraceInformation("Answer called " + data.GameId);
var playerId = Context.User.Identity.GetUserId();
if (!string.IsNullOrEmpty(playerId) && !string.IsNullOrEmpty(data.Answer))
{
var game = GameConstants.Dal.LoadGame<Lee>(data.GameId) as Lee;
game.RecordPlayerAnswer(playerId, data.Answer);
GameConstants.Dal.SaveGame(game);
//find all of the users that we should update
var playersToUpdate = game.CurrentRound.PlayerInputs.Where(pi => !string.IsNullOrEmpty(pi.Answer)).Select(pi => pi.PlayerId).ToArray();
UpdateClients(game, GetUserGroup(playersToUpdate));
}
}
