public async Task <IActionResult> Post([FromBody] Model.Game amigo)
{
if (amigo == default(Model.Game))
{
return(BadRequest());
}
var item = await _gameRepository.AddAsync(amigo);
return(Accepted(item));
}
public async Task <Guid> AddGame(string name, string creator)
{
var player = await _userManager.FindByNameAsync(creator);
var game = Game.Create(name, player);
await _gameRepository.AddAsync(game);
await _unitOfWork.SaveChangesAsync();
return(game.Id);
}
public async Task <IActionResult> Create([Bind("Id,Name,LoginService,ToornamentAlias,DiscordIconId")] Game game)
{
if (ModelState.IsValid)
{
await _gameRepository.AddAsync(game);
await _gameRepository.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(game));
}
public async Task <GameResponse> SaveAsync(Game game)
{
try{
await gameRepository.AddAsync(game);
await unitOfWork.CompleteAsync();
return(new GameResponse(game));
}
catch (Exception ex) {
return(new GameResponse($"Error while saving genre! Message:{ex.Message}"));
}
}
/// <summary>
/// Adds a <see cref="Game"/> entity to the data store asynchronously.
/// </summary>
/// <param name="newGame">The <see cref="Game"/> entity to add to the data store.</param>
public async Task AddGameAsync(Game newGame)
{
Guard.ThrowIfNull(newGame, $"{GetType()}.{nameof(AddGameAsync)}: {nameof(newGame)}");
var newGameDecorator = new GameDecorator(newGame);
newGameDecorator.DecideWinnerAndLoser();
await _gameRepository.AddAsync(newGame);
await EditTeamsAsync(Direction.Up, newGameDecorator);
await _sharedRepository.SaveChangesAsync();
}
public async Task <GameDTO> CreateGameAsync(GameDTO game)
{
if (game == null)
{
throw new ArgumentNullException(nameof(game));
}
var createdGame = await _gameRepository.AddAsync(_mapper.Map <GameDTO, Game>(game));
if (createdGame == null)
{
throw new NullReferenceException("Game was not added");
}
return(_mapper.Map <Game, GameDTO>(createdGame));
}
public async Task <Result> AddNewGame(GameDto entity)
{
var result = new Result();
try
{
var newGame = _mapper.Map <Game>(entity);
await _repository.AddAsync(newGame);
result.ReturnInsert(newGame);
}
catch (Exception e)
{
result.WithError(e.Message);
}
return(result);
}
public async Task <IActionResult> Post([FromBody] GameViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await gameRepository.PermissionToAddGame(model.UserId))
{
var game_model = mapper.Map <Game>(model);
await gameRepository.AddAsync(game_model);
return(new OkObjectResult(StatusCodes.Status201Created));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> CreatePlayer([FromBody] GameViewModelIn newGame)
{
try
{
var game = await _gameRepository.AddAsync(new Game()
{
NameOfGame = newGame.NameOfGame,
TimeOfStart = newGame.TimeOfStart,
ClubId = newGame.ClubId,
PitchId = newGame.PitchId
});
return(Ok(game));
}
catch (Exception e)
{
return(BadRequest("Check if club exists"));
}
}
public async Task <Game> CreateGame(GameCreateRequest request, int userId)
{
var activeCodes = await _gameRepository.GetActiveGamesCodes();
string code = "";
do
{
code = CodeGenerator.Generate(CodeLength);
} while (activeCodes.Contains(code));
var game = new Game
{
MasterId = userId,
Name = request.Name,
Code = code
};
return(await _gameRepository.AddAsync(game));
}
public async Task AddAsync(Game subject)
{
await gameRepository.AddAsync(subject);
}
async Task HandleReceived(string text)
{
SocketMessage message = new SocketMessage(text);
if (!message.Okay)
{
await Send("{\"t\":\"error\",\"d\":\"invalid message\"}");
return;
}
switch (message.Type)
{
case "create":
LobbySeek seek;
bool isValid = LobbySeek.TryParse(message.Data, client, out seek);
if (!isValid)
{
await Send("{\"t\":\"error\",\"d\":\"invalid seek\"}");
return;
}
string seekId = await seekRepository.Add(seek);
await Send("{\"t\":\"ack\",\"d\":\"" + seekId + "\"}");
break;
case "remove":
await seekRepository.Remove(message.Data, client);
break;
case "bump":
seekRepository.Bump(message.Data, client);
break;
case "join":
LobbySeek joined = seekRepository.Get(message.Data);
if (joined == null)
{
await Send("{\"t\":\"error\",\"d\":\"seek does not exist\"}");
return;
}
await seekRepository.Remove(joined.ID, joined.Owner);
bool hostIsWhite = randomProvider.RandomBool();
int nWhite;
int nBlack;
int max = joined.Variant != "RacingKings" ? 960 : 1440;
if (joined.ChosenPosition == LobbySeek.Position.Random)
{
nWhite = randomProvider.RandomPositiveInt(max);
if (joined.Symmetrical)
{
nBlack = nWhite;
}
else
{
nBlack = randomProvider.RandomPositiveInt(max);
}
}
else
{
nWhite = joined.WhitePosition;
nBlack = joined.BlackPosition;
}
Game game = new Game(await gameRepository.GenerateIdAsync(), hostIsWhite ? joined.Owner : client, hostIsWhite ? client : joined.Owner, joined.Variant, joined.FullVariantName, nWhite, nBlack, nWhite == nBlack, joined.TimeControl, DateTime.UtcNow, 0, gameConstructor);
await gameRepository.AddAsync(game);
string redirectJson = "{\"t\":\"redirect\",\"d\":\"" + game.ID + "\"}";
await Send(redirectJson);
await handlerRepository.SendTo(joined.Owner, redirectJson);
break;
case "init":
List <LobbySeek> seeks = seekRepository.GetShallowCopy();
foreach (LobbySeek s in seeks)
{
Dictionary <string, object> msg = new Dictionary <string, object>
{
{ "t", "add" },
{ "d", await s.SeekJson(userRepository) }
};
await Send(JsonConvert.SerializeObject(msg));
}
break;
case "keepAlive":
await Send("{\"t\":\"keepAlive\"}");
break;
default:
await Send("{\"t\":\"error\",\"d\":\"invalid message\"}");
break;
}
}
public async Task AddGame(Game game)
{
await _gameRepository.AddAsync(game);
}
