public void PlayComputerTurn()
{
string userId = this.Context.User.Identity.GetUserId();
string userName = this.Context.User.Identity.Name;
var newComputerGuess = this.games.MakeComputerGuess(userId);
var result = new GuessViewModel()
{
Id = newComputerGuess.Id,
Number = newComputerGuess.Number,
BullsCount = newComputerGuess.BullsCount,
CowsCount = newComputerGuess.CowsCount,
DateCreated = newComputerGuess.DateCreated
};
this.Clients.User(userName).playComputerTurn(result);
if (newComputerGuess.BullsCount == 4)
{
this.games.EndGame(userId, false);
this.Clients.User(userName).endGame();
}
}
public ActionResult Guess(int id)
{
var ggame = new GuessRepository().get(id);
var gtopic = new GuessRepository().topicgetAll();
GuessViewModel gvm = new GuessViewModel();
List <GuessTopicModel> gtm = new List <GuessTopicModel>();
gvm.gs = ggame;
foreach (var gt in gtopic)
{
GuessTopicModel tm = new GuessTopicModel();
tm.title = gt.title;
List <GuessChoiceModel> gcm = new List <GuessChoiceModel>();
var gchoice = new GuessRepository().guessCAll(gt.id);
foreach (var c in gchoice)
{
GuessChoiceModel gc = new GuessChoiceModel();
gc.choiceStr = c.choiceStr;
gc.isTrue = c.isTrue;
gcm.Add(gc);
}
tm.gchoice = gcm;
gtm.Add(tm);
}
gtm.Shuffle();
gvm.gtopics = gtm;
return(View(gvm));
}
public async Task <IActionResult> Guess(GuessViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var user = new ChatLeUser {
UserName = model.UserName
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return(View("Index", new LoginPageViewModel()
{
Guess = model
}));
}
public ActionResult MakeGuess(GuessViewModel guess)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { message = "Invalid guess number" }, JsonRequestBehavior.AllowGet));
}
var userId = this.User.Identity.GetUserId();
var newGuess = this.games.MakeUserGuess(userId, guess.Number);
if (newGuess.BullsCount == 4)
{
this.games.EndGame(userId, true);
this.hubContext.Clients.User(this.User.Identity.Name).endGame();
}
guess.Id = newGuess.Id;
guess.BullsCount = newGuess.BullsCount;
guess.CowsCount = newGuess.CowsCount;
guess.DateCreated = newGuess.DateCreated;
return(PartialView("_GuessRow", guess));
}
public async Task <ActionResult> GuessWithFeedback(GuessViewModel model)
{
if (ModelState.IsValid)
{
//save data with finish time
var time = new TimeSpan(0, 0, (model.ReturningTimer + model.Timer));
var binding = new UpdateUserBinding()
{
FinishedUtc = DateTime.UtcNow,
FinishingPercent = model.FinalPercentage.Value,
PictureCycled = model.ImagesUsed.Value,
Time = DateTime.UtcNow.Date.Add(time),
Phase = (byte)Phase.TWO
};
var editUserRequest = new HttpRequestMessage(HttpMethod.Post, $"/api/user/hash/{model.UserHash}")
{
Content = new StringContent(JsonSerializer.Serialize(binding), Encoding.UTF8, "application/json")
};
var editUserResponse = await _db.BuildApiResponse <UserModel>(editUserRequest, _session._accessToken);
return(RedirectToAction("PhaseTwoFinish", "Finish", new { userGuid = model.UserHash }));
}
return(View(model));
}
public IActionResult SaveGuess([FromBody] GuessViewModel guess)
{
if (ModelState.IsValid)
{
var entity = Mapper.Map <Guess>(guess);
_repository.SaveGuess(entity);
return(Created($"api/guess/save", guess));
}
return(BadRequest("An error occured. Something was incorrect about the data: " + ModelState));
}
public async Task <ActionResult> Play(string id)
{
if (id == null || id.Length != TechnicalConstants.GameIdLength)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
using (UnitOfWork unitOfWork = new UnitOfWork())
{
GameState gameState = await unitOfWork.GameRepository.GetGameStateAsync(id);
if (gameState == GameState.Undefined)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
switch (gameState)
{
case GameState.Playing:
GamePlayViewModel gamePlayVM = await unitOfWork.GameQuestionsRepository.GetGamePlayVMAsync(id);
return(View("Play", gamePlayVM));
case GameState.LastQuestionAnswered:
GuessViewModel firstGuessVM = await unitOfWork.GameRepository.GetGuessVMAsync(id);
return(View("FirstGuessFeedback", firstGuessVM));
case GameState.FirstGuessMarkedCorrect:
case GameState.SelectedFromTopGuessesList:
case GameState.EnteredWhoItWas:
GuessViewModel guessVM = await unitOfWork.GameRepository.GetGuessVMAsync(id);
return(View("CorrectGuess", guessVM));
case GameState.FirstGuessMarkedIncorrect:
TopGuessesViewModel topGuessesVM = await unitOfWork.GameEntityRepository.GetTopGuessesVMAsync(id);
return(View("TopGuesses", topGuessesVM));
case GameState.MustEnterWhoItWas:
SubmitNewEntityViewModel newEntitySubmissionVM = new SubmitNewEntityViewModel
{
AccessID = id,
SubmittedEntity = new Entity()
};
return(View("SubmitNewEntity", newEntitySubmissionVM));
default:
return(null);
}
}
}
public async Task <GuessViewModel> GetGuessVMAsync(string gameAccessId)
{
Game game = await this.unitOfWork.GameRepository.GetGameFromAccessIdAsync(gameAccessId);
this.unitOfWork.GameRepository.UpdateGameActivityNoSave(game);
GuessViewModel firstGuessVM = new GuessViewModel();
firstGuessVM.Game = game;
firstGuessVM.AnsweredQuestions = await this.unitOfWork.GameQuestionsRepository.GetAnsweredQuestionsAsync(game.IDGame);
await this.dbContext.SaveChangesAsync();
return(firstGuessVM);
}
public async Task GuessTest()
{
var userValidators = new List <IUserValidator <ChatLeUser> >();
var validator = new Mock <IUserValidator <ChatLeUser> >();
userValidators.Add(validator.Object);
var userManager = MockUserManager <ChatLeUser>(userValidators);
userManager.Setup(u => u.CreateAsync(It.IsAny <ChatLeUser>())).ReturnsAsync(IdentityResult.Success);
validator.Setup(v => v.ValidateAsync(userManager.Object, It.IsAny <ChatLeUser>()))
.Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
var signinManager = MockSigninManager <ChatLeUser>(userManager.Object);
var chatManager = new Mock <IChatManager <string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> >().Object;
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary());
var guessViewModel = new GuessViewModel()
{
UserName = "******"
};
using (var controller = new AccountController(userManager.Object, signinManager.Object, chatManager)
{
ViewData = viewData
})
{
var result = await controller.Guess(guessViewModel);
Assert.IsType <RedirectToActionResult>(result);
userManager.Setup(u => u.CreateAsync(It.IsAny <ChatLeUser>())).ReturnsAsync(IdentityResult.Failed());
result = await controller.Guess(guessViewModel);
Assert.IsType <ViewResult>(result);
}
}
/// <summary>
/// Init Guess set up
/// Get user details or creat them
/// Old guesses
/// New image
/// </summary>
/// <param name="userGuid">Can be null if so new user is created</param>
/// <returns></returns>
public async Task <ActionResult> GuessNoFeedback(string userGuid, byte?phase = 0)
{
if (_session._isLoggedin)
{
//create if no guid
var getUserRequest = new HttpRequestMessage(HttpMethod.Post, "/api/user");
//Get if exists
if (!string.IsNullOrEmpty(userGuid) && new Guid(userGuid) != Guid.Empty)
{
getUserRequest = new HttpRequestMessage(HttpMethod.Get, string.Format("/api/user/hash/{0}", userGuid));
}
var getUserResponse = await _db.BuildApiResponse <UserModel>(getUserRequest, _session._accessToken);
GuessViewModel model = new GuessViewModel();
if (getUserResponse.Status == HttpStatusCode.OK)
{
model.UserHash = getUserResponse.Content.HashUser.Value;
model.UserId = getUserResponse.Content.UserId;
//returning details
model.ReturningUser = (getUserResponse.Content.Guesses != null && getUserResponse.Content.Guesses.Any());
model.ReturningTimer = (getUserResponse.Content.TimePhase1.HasValue)
? ((getUserResponse.Content.TimePhase1.Value.Hour * 3600) +
(getUserResponse.Content.TimePhase1.Value.Minute * 60) + (getUserResponse.Content.TimePhase1.Value.Second))
: 0;
//Login logging
var updateLoginTokenRequest = new HttpRequestMessage(HttpMethod.Post, string.Format("/api/token/{0}/{1}", _session._accessId, model.UserHash.ToString()));
var updateLoginTokenResponse = await _db.BuildApiResponse <Token>(updateLoginTokenRequest, _session._accessToken);
//Past guesses
var usersGuessRequest = new HttpRequestMessage(HttpMethod.Get,
string.Format("/api/usersGuess/{0}/{1}", getUserResponse.Content.UserId, phase));
var usersGuessResponse = await _db.BuildApiResponse <List <UserGuessModel> >(usersGuessRequest, _session._accessToken);
model.FinalPercentage = getUserResponse.Content.Guesses != null && getUserResponse.Content.Guesses.Any() && usersGuessResponse.Content.Count >= 10
? (decimal)Calculations.FindAverageDifferenceOfList(usersGuessResponse.Content.OrderBy(x => x.UsersGuessId).Skip(usersGuessResponse.Content.Count - 10).ToList())
: (decimal)0.0;
model.ImagesUsed = usersGuessResponse.Content.Count;
model.Phase = (byte)(phase.HasValue ? phase.Value : 0);
//Get random new image that hasn't been used
var binding = new RandomImageBinding
{
PreviousImageIds = getUserResponse.Content.Guesses != null && getUserResponse.Content.Guesses.Any()
? getUserResponse.Content.Guesses.Select(x => x.ImageId).ToArray()
: new int[0],
ReturnRandom = true
};
var image = await GetRandomImage(binding);
if (image != null)
{
model.CurrentCloudinaryUrl = Common.BuildCloudinaryUrl(image.FileName);
model.CurrentImageId = image.ImageId;
return(View(model));
}
}
return(RedirectToAction("Errorpage", "Home"));
}
return(RedirectToAction("Login", "Account"));
}