public void GetAnswer_Success()
{
DataSetFactory dataSetFactory = new DataSetFactory();
AnswerResponse answerResponse = dataSetFactory.GetAndPostAnswer().Result;
Assert.IsTrue(answerResponse.Success);
}
private async Task <IActionResult> GetAnswerByParameterName(string parameterName)
{
try
{
AnswerResponse result = null;
switch (parameterName)
{
case "alleenstaande":
result = await GetLivingSituation("alleenstaande");
break;
case "aanvrager_met_toeslagpartner":
result = await GetLivingSituation("alleenstaande");
break;
case "toetsingsinkomen":
result = await GetAssessmentIncome();
break;
default:
return(StatusCode(400, $"ParameterName supplied: '{parameterName}' is not a valid parameter."));
}
return(StatusCode(200, result));
}
catch (Exception ex)
{
return(StatusCode(500, new ServerError500Response(ex)));
}
}
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));
}
private async Task <AnswerResponse> GetLivingSituation(string type)
{
string value = null;
switch (type)
{
case "alleenstaande":
value = "true";
break;
case "aanvrager_met_toeslagpartner":
value = "false";
break;
default:
throw new Exception($"Unspecified livingsituation requested: '{type}'");
}
var answerPayload = new AnswerResponse
{
Parameters = new List <Parameter> {
new Parameter
{
Name = type,
Value = value
}
}
};
return(answerPayload);
}
public AnswerResponse DataSetPostAnswerTest()
{
// TODO uncomment below to test the method and replace null with proper value
// Get DataSet ID
Init();
string datasetId = "fnxIQtYq1Qg";
DatasetIdResponse responseDataSetId = instance.DataSetGetDataSetId();
Assert.IsInstanceOf <DatasetIdResponse>(responseDataSetId, "response is DatasetIdResponse");
datasetId = responseDataSetId.DatasetId;
// Get the Dealers and vehicles for the given DataSetID
Answer answer = new Answer();
answer = instance.DataSetGetCheat(datasetId); //// CHEAT answer
// Post the response answer
//var response = instance.DataSetPostAnswer(datasetId, answer);
AnswerResponse ansResponse = instance.DataSetPostAnswer(datasetId, answer);
Assert.IsInstanceOf <AnswerResponse>(ansResponse, "response is AnswerResponse");
return(ansResponse);
}
static async Task Main(string[] args)
{
try
{
MagazineStore m = new MagazineStore();
// Get Token
Token t = await m.GetToken();
Console.WriteLine($"Retrieved Token : {t.token}");
// Get Subscribers
var tSubscribers = m.GetSubscribers(t.token);
// Get Magazines
var tMagazines = m.GetMagazines(t.token);
Task.WaitAll(new Task[] { tSubscribers, tMagazines });
Subscribers s = tSubscribers.Result;
var magazines = tMagazines.Result;
// Get List of Subscribers who subscribed magazine in each category
var list = m.GetSubscribersForAllCategories(s.data, magazines);
// Submit the answer and get the response
AnswerResponse a = await m.PostAnswer(t.token, list);
Console.WriteLine(JsonConvert.SerializeObject(a));
}
catch (Exception ex)
{
Console.WriteLine($"Unhandled Exception : {ex.Message}");
}
}
public List <AnswerResponse> GetAnswers(string gameId)
{
_log.LogInformation($"Get answers for gameId {gameId}");
return(_gameContext.Answers
.Where(x => x.GameId == gameId)
.Select(x => AnswerResponse.FromAnswer(x))
.ToList());
}
public AnswerResponse GetAnswer(int answerId)
{
_log.LogInformation($"Get answer for answerId {answerId}");
return(_gameContext.Answers
.Where(x => x.Id == answerId)
.Select(x => AnswerResponse.FromAnswer(x))
.First());
}
public QuestionData(AnswerResponse response)
{
Question = new KeyValuePair <string, string>(
response.parameters.questionid,
response.parameters.question);
Answers = response.parameters.answers
.Select(ans => ans.answer)
.ToList();
Progression = response.parameters.progression;
}
public static void PrintPropertiesOfAnswerObject(AnswerResponse answerResponse)
{
Console.WriteLine("answerCorrect: " + answerResponse.data.answerCorrect);
Console.WriteLine("totalTime: " + answerResponse.data.totalTime);
Console.WriteLine("shouldBe: " + answerResponse.data.shouldBe);
Console.WriteLine("success: " + answerResponse.success);
Console.WriteLine("token: " + answerResponse.token);
Console.WriteLine("message: " + answerResponse.message);
Console.ReadLine();
}
public async Task <AnswerResponse> CheckAnswer(string gameName, string playerName, int answerId)
{
var data = new AnswerResponse();
var questionId = await GetCurrentQuestionId(gameName);
var answers = await GetAllAnswers(gameName, questionId - 1);
data.isCorrect = answers[answerId].isCorrect;
data.correctAnswerId = answers.FindIndex(x => x.isCorrect);
return(data);
}
public async Task <AnswerResponse> CheckAnswer(string gameName, string playerName, int answerId)
{
AnswerResponse data = new AnswerResponse();
var lines = await File.ReadAllLinesAsync(_gameDirectoryPath + $"/{gameName}/{_defaultQuestionFile}");
var questions = ParseQuestions(lines);
var questionId = await GetCurrentQuestionId(gameName);
data.isCorrect = questions[questionId].Answers[answerId].isCorrect;
data.correctAnswerId = questions[questionId].Answers.FindIndex(x => x.isCorrect == true);
return(data);
}
private AnswerResponse FormatThirdQuestionAnswerResponse(CountryPublicHoliday result)
{
AnswerResponse formattedResponse = new AnswerResponse();
formattedResponse.AdditionalInfo = new List <string>();
formattedResponse.QuestionString = ThirdQuestionString;
formattedResponse.Answer = result.CountryCode + ", " + result.CountryName;
foreach (var holiday in result.UniqueHolidays)
{
formattedResponse.AdditionalInfo.Add(string.Format("{0} is unique holiday for {1}", holiday.Date.ToShortDateString(), holiday.Name));
}
formattedResponse.Explanation = string.Format("The country contains {0} unique holidays in 2019!", result.UniqueHolidays.Count);
return(formattedResponse);
}
public AnswerResponse AnswerQuestion(int questionNumber)
{
if (questionNumber == 1)
{
CountryPublicHoliday result = this.publicHolidaysOperations.GetMaxHolidaysCountry(2019);
if (result != null)
{
this.answerResponse = FormatFirstQuestionAnswerResponse(result);
}
else
{
return(GetExceptionAnswerResponse(ExceptionMessageString));
}
}
else if (questionNumber == 2)
{
HolidaysMonth result = this.publicHolidaysOperations.GetMaxHolidaysMonthGlobally(2019);
if (result != null)
{
this.answerResponse = FormatSecondQuestionAnswerResponse(result);
}
else
{
return(GetExceptionAnswerResponse(ExceptionMessageString));
}
}
else if (questionNumber == 3)
{
CountryPublicHoliday result = this.publicHolidaysOperations.GetMaxUniqueHolidaysCountry(2019);
if (result != null)
{
this.answerResponse = FormatThirdQuestionAnswerResponse(result);
}
else
{
return(GetExceptionAnswerResponse(ExceptionMessageString));
}
}
else
{
return(GetExceptionAnswerResponse("Question number is not provided, Please pass correct question number."));
}
this.answerResponse.Status = true;
return(this.answerResponse);
}
private AnswerResponse FormatSecondQuestionAnswerResponse(HolidaysMonth result)
{
AnswerResponse formattedResponse = new AnswerResponse();
formattedResponse.AdditionalInfo = new List <string>();
formattedResponse.QuestionString = SecondQuestionString;
formattedResponse.Answer = result.MonthName;
result.Holidays.Sort();
foreach (var day in result.Holidays)
{
formattedResponse.AdditionalInfo.Add(string.Format("Day: {0} is public holiday globally", day.ToString()));
}
formattedResponse.Explanation = string.Format("The month contains {0} Holidays in 2019!", result.Holidays.Count);
return(formattedResponse);
}
private async Task <AnswerResponse> GetAssessmentIncome()
{
var answerPayload = new AnswerResponse
{
Parameters = new List <Parameter>
{
new Parameter
{
Name = "toetsingsinkomen",
Value = "24000"
}
}
};
return(answerPayload);
}
private void LoadAnswersCommentsToResponse(AnswerEntity entity, AnswerResponse response)
{
entity.Comments.ToList().ForEach(comment =>
{
var newComment = new CommentResponse
{
Id = comment.Id,
Body = comment.Body,
User = new UserResponse
{
Id = comment.UserId
}
};
response.Comments.Add(newComment);
});
}
public object Any(Answer request)
{
Guid userId = UserSession.GetUserId();
TableRepository tableRepository = new TableRepository();
// create answers
AnswerEntry answerEntry = tableRepository.Get <AnswerEntry>(Tables.Answers, request.QuestionId, userId);
if (answerEntry == null)
{
DateTime dateTime = DateTime.UtcNow;
answerEntry = new AnswerEntry(request.QuestionId, userId)
{
Content = request.Content,
Creation = dateTime,
Modification = dateTime,
Votes = 0
};
// update the answers count
QuestionEntry questionEntry = tableRepository.Get <QuestionEntry>(Tables.Questions, request.QuestionOwnerId, request.QuestionId);
if (questionEntry != null)
{
questionEntry.Answers++;
tableRepository.InsertOrMerge(questionEntry, Tables.Questions);
}
}
else
{
// perform an edit
answerEntry.Content = request.Content;
answerEntry.Modification = DateTime.UtcNow;
}
tableRepository.InsertOrMerge(answerEntry, Tables.Answers);
AnswerResponse response = new AnswerResponse
{
Result = ErrorCode.OK
};
return(response);
}
static async Task RunAsync()
{
try
{
VAutoClient.Initialize();
Console.WriteLine("Retreiving data set id...");
DatasetIdResponse datasetIdResponse = await VAutoClient.GetDataSetIdAsync();
string dataSetId = datasetIdResponse.datasetId;
Console.WriteLine("Done.");
Console.WriteLine("Retreiving vehicle ids...");
VehicleIdsResponse vehicleIds = await VAutoClient.GetVehicleIdsAsync(dataSetId);
Console.WriteLine("Done.");
Console.WriteLine("Purging vehicle id duplicates...");
IEnumerable <int> vehicleIdList = vehicleIds.vehicleIds.Distinct(); //ensure duplicate calls for vehicle data are not performed.
Console.WriteLine("Done.");
Console.WriteLine("Retreiving vehicle and dealer data...");
List <Task <VehicleResponse> > vehicleDataTasks = new List <Task <VehicleResponse> >();
List <Task <DealersResponse> > dealerDataTasks = new List <Task <DealersResponse> >();
await GetVehicleAndDealerData(dataSetId, vehicleIdList, vehicleDataTasks, dealerDataTasks);
Console.WriteLine("Done.");
Console.WriteLine("Building answer...");
Answer answer = BuildAnswer(dealerDataTasks, vehicleDataTasks);
Console.WriteLine("Done.");
Console.WriteLine("Posting answer...");
AnswerResponse answerResponse = await VAutoClient.PostAnswer(dataSetId, answer);
Console.WriteLine("Done.");
Console.WriteLine("Result: {0}\nMessage: {1}\nMilliseconds: {2}", answerResponse.success, answerResponse.message, answerResponse.totalMilliseconds);
}
catch (Exception e)
{
Console.WriteLine("\n\nException: {0}\n\nStackTrace: {1}", e.Message, e.StackTrace);
}
}
static async Task <AnswerResponse> postAnswer(string token, List <string> subscribers)
{
SubscibersList listToSubmit = new SubscibersList()
{
subscribers = subscribers
};
HttpResponseMessage response = await client.PostAsJsonAsync("api/answer/" + token, JToken.FromObject(listToSubmit));
string result = string.Empty;
if (response.IsSuccessStatusCode)
{
result = await response.Content.ReadAsStringAsync();
}
JObject apiResponse = JObject.Parse(result);
AnswerResponse output = apiResponse.GetValue("data").ToObject <AnswerResponse>();
return(output);
}
public async Task <IActionResult> GetAnswersByQuestionIdAsync(int questionId)
{
AnswerResponse answerResponse = new AnswerResponse();
try
{
answerResponse.Answers = await _dbContext.Answers
.Where(a => a.QuestionId == questionId)
.ToListAsync();
answerResponse.IsSuccess = true;
}
catch (Exception ex)
{
answerResponse.Message = ex.Message;
}
return(StatusCode(answerResponse.Status, answerResponse));
}
public static async Task <AnswerResponse> PostAnswer(string dataSetId, Answer answerRequest)
{
var jsonContent = JsonConvert.SerializeObject(answerRequest);
var stringContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(client.BaseAddress.AbsoluteUri + string.Format("/api/{0}/answer", dataSetId), stringContent);
AnswerResponse answerResponse = null;
if (response.IsSuccessStatusCode || response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
answerResponse = await response.Content.ReadAsAsync <AnswerResponse>();
}
else
{
throw new Exception(string.Format("Failed to post the answer.\n\n{0}\n\nDataSet ID: {1}\n\n{2}", response.ReasonPhrase, dataSetId, jsonContent));
}
return(answerResponse);
}
private void LoadAnswersToResponse(QuestionEntity entity, QuestionResponse response)
{
entity.Answers.ToList().ForEach(answer =>
{
var newAnswer = new AnswerResponse()
{
Id = answer.Id,
Body = answer.Body,
Votes = answer.Votes,
User = new UserResponse
{
Id = answer.UserId
}
};
LoadAnswersCommentsToResponse(answer, newAnswer);
response.Answers.Add(newAnswer);
});
}
public async Task <IActionResult> GetAnswerByIdAsync(int id)
{
AnswerResponse answerResponse = new AnswerResponse();
try
{
answerResponse.Answers = new List <Answer>()
{
await _dbContext.Answers.FindAsync(id)
};
answerResponse.IsSuccess = true;
}
catch (Exception ex)
{
answerResponse.Message = ex.Message;
}
return(StatusCode(answerResponse.Status, answerResponse));
}
/// <inheritdoc/>
async Task <AnswerServiceResponse> ISubmitAnswerService.SubmitNewAnswer()
{
string datasetId = (await apiService.CreateDataSet()).DatasetId;
// Create an answer for this dataset
Answer answer = await GetAnswer(datasetId);
// Submit the answer and return response
AnswerServiceResponse finalServiceResponse = new AnswerServiceResponse
{
JsonRequest = JsonConvert.SerializeObject(answer, Formatting.Indented)
};
AnswerResponse answerResponse = await apiService.PostAnswer(datasetId, answer);
finalServiceResponse.Success = answerResponse.Success;
finalServiceResponse.Message = answerResponse.Message;
finalServiceResponse.TotalMilliseconds = answerResponse.TotalMilliseconds;
return(finalServiceResponse);
}
/// <summary>
/// Dataset factory
/// Gets dataset ID, calls vehicle factory, then dealer factory to obtain data necessary for answer
/// </summary>
/// <returns></returns>
public async Task <AnswerResponse> GetAndPostAnswer()
{
AnswerResponse answerResponse = new AnswerResponse();
Answer answer = new Answer();
DatasetIdResponse datasetIdResponse = dataSetApi.GetDataSetId();
//check datasetid response then get list of vehicles
if (CheckDatasetIdResponse(datasetIdResponse))
{
string datasetId = datasetIdResponse.DatasetId;
answer.Dealers = await vehiclesFactory.GetListOfVehicles(datasetId);
answerResponse = dataSetApi.PostAnswer(datasetId, answer);
return(answerResponse);
}
else
{
throw new ApiException(404, "DatasetIdResponse or Dataset ID not found.");
}
}
public GameStatusResponse GetStatusResponse(string gameId, string playerId)
{
var status = GetStatus(gameId);
if (status == null)
{
return(null);
}
var gameStatus = GameStatusResponse.FromStatus(status);
gameStatus.IsCurrentChoice = status.ChoosingPlayerId == playerId;
gameStatus.RemainingQuestions = RemainingQuestions(gameId);
// Return previous choice
if (!gameStatus.IsCurrentChoice)
{
gameStatus.ChoiceA = _playData.GetPreviousChoiceA();
gameStatus.ChoiceB = _playData.GetPreviousChoiceB();
}
else if (gameStatus.ChoiceA == null || gameStatus.ChoiceB == null)
{
// TODO: Something with EF not populating the object, can look at it later
var choiceA = _gameContext.Answers.Find(status.ChoiceAId);
var choiceB = _gameContext.Answers.Find(status.ChoiceBId);
gameStatus.ChoiceA = AnswerResponse.FromAnswer(choiceA);
gameStatus.ChoiceB = AnswerResponse.FromAnswer(choiceB);
}
if (gameStatus.ChoosingPlayer == null)
{
var player = _gameContext.Players.Find(status.ChoosingPlayerId);
if (player != null)
{
gameStatus.ChoosingPlayer = PlayerResponse.FromPlayer(player);
gameStatus.ChoosingPlayer.IsChoosing = true;
}
}
return(gameStatus);
}
void OutputResults(AnswerResponse response)
{
Log("Server Results");
var successResult = response.Success.HasValue ? response.Success.Value.ToString() : "N/A";
Log($"{nameof(response.Success)}: {successResult}");
var timeResult = response.TotalMilliseconds.HasValue ? Convert.ToString(response.TotalMilliseconds.Value) : "N/A";
Log($"{nameof(response.TotalMilliseconds)}: {timeResult}");
Log($"{nameof(response.Message)}: '{response.Message}'");
var json = JsonConvert.SerializeObject(response);
var responseFilePath = Path.Combine(Environment.CurrentDirectory, "Answer.json");
Log($"Outputting results to file in '{responseFilePath}'");
File.WriteAllText(responseFilePath, json);
}
public AnswerResponse AddAnswer(string request, string gameId)
{
_log.LogInformation($"Adding answer for gameId {gameId}: {request}");
if (!_gameContext.Games.Any(x => x.Id == gameId))
{
return(null);
}
var answer = _gameContext.Answers.Add(
new Answer
{
Text = request,
Submitted = DateTime.Now,
GameId = gameId
});
_gameContext.SaveChanges();
return(AnswerResponse.FromAnswer(answer.Entity));
}
public GameStatusResponse MakeChoice(string gameId, int answerId)
{
// Update answers, eliminated and increase chosen count
var status = GetStatus(gameId);
var choiceA = GetAnswer(status.ChoiceAId);
var choiceB = GetAnswer(status.ChoiceBId);
var currentPlayer = status.ChoosingPlayerId;
if (status.ChoiceAId == answerId)
{
choiceA.ChosenCount++;
choiceB.IsEliminated = true;
}
else if (status.ChoiceBId == answerId)
{
choiceB.ChosenCount++;
choiceA.IsEliminated = true;
}
else
{
return(null);
}
// Set previous questions to current questions
_playData.SetPreviousChoiceA(AnswerResponse.FromAnswer(status.ChoiceA));
_playData.SetPreviousChoiceB(AnswerResponse.FromAnswer(status.ChoiceB));
// Get new questions
SetNewChoice(status);
// New Player
status.ChoosingPlayer = GetNextPlayer(gameId);
_gameContext.GameState.Update(status);
_gameContext.Players.Update(status.ChoosingPlayer);
_gameContext.SaveChanges();
return(GetStatusResponse(gameId, currentPlayer));
}
public object Any(Answer request)
{
Guid userId = UserSession.GetUserId();
TableRepository tableRepository = new TableRepository();
// create answers
AnswerEntry answerEntry = tableRepository.Get<AnswerEntry>(Tables.Answers, request.QuestionId, userId);
if (answerEntry == null)
{
DateTime dateTime = DateTime.UtcNow;
answerEntry = new AnswerEntry(request.QuestionId, userId)
{
Content = request.Content,
Creation = dateTime,
Modification = dateTime,
Votes = 0
};
// update the answers count
QuestionEntry questionEntry = tableRepository.Get<QuestionEntry>(Tables.Questions, request.QuestionOwnerId, request.QuestionId);
if (questionEntry != null)
{
questionEntry.Answers++;
tableRepository.InsertOrMerge(questionEntry, Tables.Questions);
}
}
else
{
// perform an edit
answerEntry.Content = request.Content;
answerEntry.Modification = DateTime.UtcNow;
}
tableRepository.InsertOrMerge(answerEntry, Tables.Answers);
AnswerResponse response = new AnswerResponse
{
Result = ErrorCode.OK
};
return response;
}
