public IHttpActionResult PutTriviaAnswer(int id, TriviaAnswer triviaAnswer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != triviaAnswer.Id)
{
return(BadRequest());
}
db.Entry(triviaAnswer).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TriviaAnswerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private static bool MatchesOption(TriviaAnswer answer, TriviaOption o)
{
var a = answer.OptionId / 0;
return(o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
}
public void WrongAnswer()
{
// Manually Added Trivia Answer not to initialize database;
TriviaAnswer answer = new TriviaAnswer
{
UserId = "name",
OptionId = 13,
QuestionId = 4,
Id = 48
};
TriviaOption a = new TriviaOption();
List <TriviaOption> options = new List <TriviaOption>();
// Manually Added Trivia Option not to initialize database;
a.Title = "What fictional company did Nancy Davolio work for?";
a.QuestionId = 4;
a.Id = 13;
a.IsCorrect = false;
options.Add(a);
var selectedOption = options.FirstOrDefault(o => o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
Assert.IsFalse(selectedOption.IsCorrect);
}
/// <summary>
///
/// </summary>
/// <param name="triviaAnswer"></param>
/// <returns></returns>
public async Task <TriviaAnswerResponse> PostAnswerAsync(TriviaAnswer triviaAnswer)
{
TriviaAnswerResponse triviaAnswerResponse = null;
HttpContent httpContent =
new StringContent(
JsonConvert.SerializeObject(triviaAnswer),
Encoding.UTF8,
RestApiHelper.ContentTypeJson);
string response = null;
try
{
response = await RestApiHelper.ExecuteHttpPostAsync(
TriviaAnswerUri, httpContent, RestApiHelper.ContentTypeJson);
System.Diagnostics.Debug.WriteLine($"Received response: {response}");
triviaAnswerResponse = JsonConvert.DeserializeObject <TriviaAnswerResponse>(response);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine($"Error occured while posting an answer: {e.Message}");
}
return(triviaAnswerResponse);
}
private bool StoreAsync(TriviaAnswer answer)
{
this.db.db.TriviaAnswers.Add(answer);
var selectedOption = this.db.db.TriviaQuestions.FirstOrDefault(x => x.Id == answer.QuestionId).Options.FirstOrDefault(x => x.Id == answer.OptionId);
return(selectedOption.IsCorrect);
}
// Saves the answer chosen by the user for a specific question, and returns whether or not the provided answer is correct
private async Task <bool> StoreAsync(TriviaAnswer answer)
{
_db.TriviaAnswers.Add(answer);
await _db.SaveChangesAsync();
var selectedOption = await _db.TriviaOptions.FirstOrDefaultAsync(o => o.Id == answer.OptionId && o.QuestionId == answer.QuestionId);
return(selectedOption.IsCorrect);
}
private bool Store(TriviaAnswer answer)
{
this.db.TriviaAnswers.Add(answer);
this.db.SaveChanges();
var selectedOption = this.db.TriviaOptions.FirstOrDefault(o => o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
return(selectedOption.IsCorrect);
}
public async Task <IHttpActionResult> Post(TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
answer.UserId = User.Identity.Name;
return(Ok(await StoreAsync(answer)));
}
public async Task <IHttpActionResult> GetTriviaAnswer(int id)
{
TriviaAnswer triviaAnswer = await db.TriviaAnswers.FindAsync(id);
if (triviaAnswer == null)
{
return(NotFound());
}
return(Ok(triviaAnswer));
}
public IHttpActionResult GetTriviaAnswer(int id)
{
TriviaAnswer triviaAnswer = db.TriviaAnswers.Find(id);
if (triviaAnswer == null)
{
return(NotFound());
}
return(Ok(triviaAnswer));
}
public async Task <IHttpActionResult> Post(TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
answer.UserId = User.Identity.Name;
var isCorrect = await this.StoreAsync(answer);
return(this.Ok <bool>(isCorrect));
}
public IHttpActionResult PostTriviaAnswer(TriviaAnswer triviaAnswer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TriviaAnswers.Add(triviaAnswer);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = triviaAnswer.Id }, triviaAnswer));
}
public async Task <IHttpActionResult> Post(TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
answer.UserId = "*****@*****.**";
var isCorrect = await this.StoreAsync(answer);
return(this.Ok <bool>(isCorrect));
}
public async Task <IHttpActionResult> Post(TriviaAnswer triviaAnswer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
triviaAnswer.UserId = User.Identity.Name;
bool isCorrect = await StoreAsync(triviaAnswer);
return(Ok <bool>(isCorrect));
}
public async Task <IActionResult> Post([FromBody] TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(HttpBadRequest(ModelState));
}
var isCorrect = await this.StoreAsync(answer);
return(this.CreatedAtAction("Get", new { }, isCorrect));
}
// POST api/Trivia
public bool Post(TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(false);
}
answer.UserId = User.Identity.Name;
var isCorrect = this.Store(answer);
return(isCorrect);
}
public IHttpActionResult DeleteTriviaAnswer(int id)
{
TriviaAnswer triviaAnswer = db.TriviaAnswers.Find(id);
if (triviaAnswer == null)
{
return(NotFound());
}
db.TriviaAnswers.Remove(triviaAnswer);
db.SaveChanges();
return(Ok(triviaAnswer));
}
public async Task <IHttpActionResult> DeleteTriviaAnswer(int id)
{
TriviaAnswer triviaAnswer = await db.TriviaAnswers.FindAsync(id);
if (triviaAnswer == null)
{
return(NotFound());
}
db.TriviaAnswers.Remove(triviaAnswer);
await db.SaveChangesAsync();
return(Ok(triviaAnswer));
}
private async Task <bool> StoreAsync(TriviaAnswer answer)
{
var selectedOption = new TriviaOption();
await Task.Run(() =>
{
this._triviaRepository.Get <TriviaAnswer>().Add(answer);
this._triviaRepository.Commit();
selectedOption = this._triviaRepository.Get <TriviaOption>().FirstOrDefaultAsync(
o => o.Id == answer.OptionId && o.QuestionId == answer.QuestionId).Result;
});
return(selectedOption.IsCorrect);
}
public async Task <HttpResponseMessage> Post(TriviaAnswer answer)
{
if (ModelState.IsValid)
{
answer.UserId = User.Identity.Name;
var isCorrect = await this.answersService.StoreAsync(answer);
return(Request.CreateResponse(HttpStatusCode.Created, isCorrect));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task <bool> StoreAsync(TriviaAnswer answer)
{
var selectedOption = await this.db.TriviaOptions.FirstOrDefaultAsync(o =>
MatchesOption(answer, o));
if (selectedOption != null)
{
answer.TriviaOption = selectedOption;
this.db.TriviaAnswers.Add(answer);
await this.db.SaveChangesAsync();
}
return(selectedOption.IsCorrect);
}
private async Task <bool> StoreAsync(TriviaAnswer answer)
{
var selectedOption = await this.context.TriviaOptions.FirstOrDefaultAsync(o =>
o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
if (selectedOption != null)
{
answer.TriviaOption = selectedOption;
this.context.TriviaAnswers.Add(answer);
await this.context.SaveChangesAsync();
}
return(selectedOption.IsCorrect);
}
public async Task <IHttpActionResult> Post(TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
answer.UserId = User.Identity.Name;
var isCorrect = await this.StoreAsync(answer);
var statisticsService = new StatisticsService(this.db);
await statisticsService.NotifyUpdates();
return(this.Ok <bool>(isCorrect));
}
public async void SubmitAnswer(string question)
{
Func <Task> submit = new Func <Task> (async() =>
{
if (question != null)
{
var currentQuestion =
Trivias.Where(trivia => trivia.Id == question).First();
currentQuestion.Question.UserAnswer = SelectedAward;
var triviaResult = await TriviaAnswer.SubmitAnswer(currentQuestion.Question);
currentQuestion.Question = triviaResult;
LoadTriviaResults();
}
});
await ExecuteSafeOperation(submit);
}
public async Task <IHttpActionResult> PostTriviaAnswer(TriviaAnswer triviaAnswer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
triviaAnswer.UserId = User.Identity.Name;
this.db.TriviaAnswers.Add(triviaAnswer);
await db.SaveChangesAsync();
var selectedOption = await db.TriviaOptions.FirstOrDefaultAsync(o => o.Id == triviaAnswer.OptionId &&
o.QuestionId == triviaAnswer.QuestionId);
return(this.Ok <bool>(selectedOption.IsCorrect));
}
private async void LoadQuestions(int level)
{
Func <Task> questions = async() =>
{
CurrentLevel = level;
var unsortedItems = await TriviaAnswer.GetSavedQuestions(level);
var result = new ObservableCollection <TriviaProxy>();
foreach (var item in unsortedItems)
{
TriviaProxy proxy = new TriviaProxy();
proxy.Question = item;
proxy.Options = new ObservableCollection <Award>();
result.Add(proxy);
}
if (result.Count < Utils.TRIVIA_QUESTIONS_LIMIT)
{
var missingTriviaItemsCount = Utils.TRIVIA_QUESTIONS_LIMIT - result.Count;
var newQuestions = await TriviaAnswer.GetNewQuestions(level, missingTriviaItemsCount);
var sortedAwards = from award in newQuestions
orderby award.Category
group award by new { award.Category, award.Year } into awardsGroup
select new AwardsGroup <string, Award>(
$"{awardsGroup.Key.Year}-{awardsGroup.Key.Category}", awardsGroup);
foreach (var questionGroup in sortedAwards)
{
TriviaAnswer newTrivia = new TriviaAnswer();
newTrivia.Award = questionGroup.Where(award => award.Won == 1).FirstOrDefault();
newTrivia.Level = CurrentLevel;
TriviaProxy proxy = new TriviaProxy();
proxy.Question = newTrivia;
proxy.Options = questionGroup;
result.Add(proxy);
}
}
Trivias = result;
await((MasterDetailPage)App.Current.MainPage).Detail.Navigation.PushAsync(new TriviaQuestionsPanel());
};
await ExecuteSafeOperation(questions);
}
public async Task <IHttpActionResult> Post(TriviaAnswer answer)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
answer.UserId = User.Identity.Name;
var isCorrect = await this.StoreAsync(answer);
//await Task.Run(() =>
//{
// if (!_resultsDictionary.ContainsKey(User.Identity.Name))
// {
// _resultsDictionary.Add(User.Identity.ToString(), new List<Result>());
// }
// _resultsDictionary[User.Identity.Name].Add(new Result { QuestionId = answer.QuestionId, IsCorrect = isCorrect });
//});
return(this.Ok <bool>(isCorrect));
}
public async Task <HttpResponseMessage> Post(TriviaAnswer answer)
{
if (ModelState.IsValid)
{
answer.UserId = UserId;
bool isCorrect = false;
try
{
isCorrect = await this.answersService.StoreAsync(answer);
}
catch (Exception e)
{
}
return(Request.CreateResponse(HttpStatusCode.Created, isCorrect));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public void RightAnswer()
{
// Manually Added Trivia Answer not to initialize database;
TriviaAnswer answer = new TriviaAnswer
{
UserId = "name",
OptionId = 48,
QuestionId = 12
};
TriviaOption a = new TriviaOption();
List <TriviaOption> options = new List <TriviaOption>();
// Manually Added Trivia Option not to initialize database;
a.Title = "How many function calls did Windows 1.0 approximately have?";
a.QuestionId = 12;
a.Id = 48;
a.IsCorrect = true;
options.Add(a);
var selectedOption = options.FirstOrDefault(o => o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
Assert.IsTrue(selectedOption.IsCorrect);
}
private async Task <bool> StoreAsync(TriviaAnswer answer)
{
if (answer.UserId == "wrong")
{
answer.UserId = User.Identity.Name;
var Option = await this.context.TriviaOptions.FirstOrDefaultAsync(o =>
o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
if (Option != null)
{
answer.TriviaOption = Option;
this.context.TriviaAnswers.Add(answer);
await this.context.SaveChangesAsync();
}
return(false);
}
answer.UserId = User.Identity.Name;
var selectedOption = await this.context.TriviaOptions.FirstOrDefaultAsync(o =>
o.Id == answer.OptionId &&
o.QuestionId == answer.QuestionId);
if (selectedOption != null)
{
answer.TriviaOption = selectedOption;
this.context.TriviaAnswers.Add(answer);
await this.context.SaveChangesAsync();
}
return(selectedOption.IsCorrect);
}
