public async Task <SubmitGameEventResponse> AddPlayerGameEvent(DbUserModel player, GameEventRequest request) { GameEventModel eventModel = toGameEventModel(player, request); // Ensure the event happens after current time. GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(GameConfiguration.UnixTimeStarted), DateTime.UtcNow); if (eventModel.OccursAtTick <= currentTick.GetTick()) { return(new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST), });; } // TODO: validate event. await MongoConnector.GetGameEventCollection().InsertOneAsync(new GameEventModelMapper(eventModel)); return(new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), EventId = eventModel.Id, }); }
public async Task <ResponseStatus> BlockUser(DbUserModel requestingDbUserModel) { if (requestingDbUserModel.HasClaim(UserClaim.Admin) || HasClaim(UserClaim.Admin)) { return(ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED)); } // Check if a relationship already exists for the two players. var relationExists = MongoConnector.GetFriendCollection() .Find(it => (it.PlayerId == UserModel.Id && it.FriendId == requestingDbUserModel.UserModel.Id)) .CountDocuments() != 0; // Remove all pre-existing relations await MongoConnector.GetFriendCollection().DeleteManyAsync(it => (it.FriendId == requestingDbUserModel.UserModel.Id && it.PlayerId == UserModel.Id) || (it.PlayerId == requestingDbUserModel.UserModel.Id && it.FriendId == UserModel.Id)); await MongoConnector.GetFriendCollection().InsertOneAsync(new FriendModel { Id = Guid.NewGuid().ToString(), FriendId = requestingDbUserModel.UserModel.Id, FriendStatus = FriendStatus.StatusBlocked, PlayerId = UserModel.Id, UnixTimeCreated = DateTime.UtcNow.ToFileTimeUtc(), }); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); }
public async Task <ResponseStatus> UnblockUser(DbUserModel requestingDbUserModel) { var update = Builders <FriendModel> .Update.Set(it => it.FriendStatus, FriendStatus.StatusNoRelation); await MongoConnector.GetFriendCollection().UpdateOneAsync((it => it.FriendId == requestingDbUserModel.UserModel.Id && it.PlayerId == UserModel.Id), update); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); }
public async Task <CreateMessageGroupResponse> CreateMessageGroup(List <String> groupMembers) { // Ensure all members are in the room. if (groupMembers.Except(GameConfiguration.Players.Select(it => it.Id)).Any()) { // A player in the group is not in the game. return(new CreateMessageGroupResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST), });; } // Get all group chats for the room List <GroupChat> roomGroupChats = (await MongoConnector.GetMessageGroupCollection() .FindAsync(group => group.RoomId == GameConfiguration.Id)) .ToList() .Select(group => new GroupChat(this, group.ToProto())) .ToList(); foreach (GroupChat groupChat in roomGroupChats) { if (groupChat.MessageGroup.GroupMembers.Count() == groupMembers.Count()) { // If the group chats are the same size and removing all the duplicates results in an empty list, // We have a duplicate group if (!groupChat.MessageGroup.GroupMembers.Except(groupMembers).Any()) { return(new CreateMessageGroupResponse() { Status = ResponseFactory.createResponse(ResponseType.DUPLICATE), }); } } } // Otherwise, create the group GroupModel newGroup = new GroupModel(); newGroup.Id = Guid.NewGuid().ToString(); newGroup.RoomId = GameConfiguration.Id; foreach (string s in groupMembers) { DbUserModel model = await DbUserModel.GetUserFromGuid(s); if (model != null) { newGroup.GroupMembers.Add(model.UserModel.Id); } } await MongoConnector.GetMessageGroupCollection().InsertOneAsync(new GroupModelMapper(newGroup)); return(new CreateMessageGroupResponse() { GroupId = newGroup.Id, Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }); }
public async Task <ResponseStatus> RemoveFriend(DbUserModel requestingDbUserModel) { await MongoConnector.GetFriendCollection().DeleteOneAsync(it => (it.PlayerId == UserModel.Id && it.FriendId == requestingDbUserModel.UserModel.Id) || (it.FriendId == UserModel.Id && it.PlayerId == requestingDbUserModel.UserModel.Id) ); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); }
public async Task <List <GameEventModel> > GetPlayerGameEvents(DbUserModel player) { List <GameEventModel> events = (await MongoConnector.GetGameEventCollection() .FindAsync(it => it.IssuedBy == player.UserModel.Id)) .ToList() .Select(it => it.ToProto()) .ToList(); events.Sort((a, b) => a.OccursAtTick.CompareTo(b.OccursAtTick)); return(events); }
public async Task <DeleteGameEventResponse> RemovePlayerGameEvent(DbUserModel player, string eventId) { try { Guid.Parse(eventId); } catch (FormatException) { return(new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST) }); } // Get the event to check some things... GameEventModelMapper gameEvent = (await MongoConnector.GetGameEventCollection() .FindAsync(it => it.Id == eventId)) .ToList() .FirstOrDefault(); if (gameEvent == null) { return(new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST) });; } // Determine if the event has already passed. GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(GameConfiguration.UnixTimeStarted), DateTime.UtcNow); if (gameEvent.OccursAtTick <= currentTick.GetTick()) { return(new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST) }); } if (gameEvent.IssuedBy != player.UserModel.Id) { return(new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED) }); } // Remove game Event MongoConnector.GetGameEventCollection().DeleteOne(it => it.Id == eventId); return(new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }); }
public async Task <ResponseStatus> AddFriendRequestFrom(DbUserModel requestingDbUserModel) { await MongoConnector.GetFriendCollection().InsertOneAsync(new FriendModel() { PlayerId = UserModel.Id, FriendId = requestingDbUserModel.UserModel.Id, FriendStatus = FriendStatus.StatusPending, UnixTimeCreated = DateTime.UtcNow.ToFileTimeUtc(), }); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); }
public async Task <bool> IsBlocked(DbUserModel otherDbUserModel) { var blockedPlayer = (await MongoConnector.GetFriendCollection() .FindAsync(it => it.FriendStatus == FriendStatus.StatusBlocked && (it.PlayerId == UserModel.Id && it.FriendId == otherDbUserModel.UserModel.Id || it.FriendId == UserModel.Id && it.PlayerId == otherDbUserModel.UserModel.Id) )) .FirstOrDefault(); return(blockedPlayer != null); }
public async Task <List <GroupChat> > GetPlayerGroupChats(DbUserModel dbUserModel) { // Get all group chats the player is in List <GroupChat> groupChatList = (await MongoConnector.GetMessageGroupCollection() .FindAsync(group => group.RoomId == GameConfiguration.Id && group.GroupMembers.Contains(dbUserModel.UserModel.Id))) .ToList() .Select(group => new GroupChat(this, group.ToProto())) .ToList(); return(groupChatList); }
public async Task <bool> HasFriendRequestFrom(DbUserModel friend) { FriendModel friendRequest = (await MongoConnector.GetFriendCollection() .FindAsync(it => it.FriendStatus == FriendStatus.StatusPending && (it.PlayerId == UserModel.Id && it.FriendId == friend.UserModel.Id))) .ToList() .FirstOrDefault(); if (friendRequest == null) { return(false); } return(true); }
public async Task <MessageGroup> asMessageGroup(int messagesPagination = 1) { MessageGroup model = new MessageGroup() { GroupId = MessageGroup.Id, }; // Convert UserIds to Users. foreach (string userId in MessageGroup.GroupMembers) { model.GroupMembers.Add((await DbUserModel.GetUserFromGuid(userId)).AsUser()); } model.Messages.AddRange(await GetMessages(messagesPagination)); return(model); }
private GameEventModel toGameEventModel(DbUserModel requestor, GameEventRequest request) { Guid eventId; eventId = Guid.NewGuid(); return(new GameEventModel() { Id = eventId.ToString(), UnixTimeIssued = DateTime.UtcNow.ToFileTimeUtc(), IssuedBy = requestor.UserModel.Id, OccursAtTick = request.OccursAtTick, EventData = request.EventData, RoomId = GameConfiguration.Id, }); }
public async Task <ResponseStatus> SendChatMessage(DbUserModel dbUserModel, string message) { // Set the creation time. MessageModel model = new MessageModel() { Id = Guid.NewGuid().ToString(), RoomId = Room.GameConfiguration.Id, GroupId = MessageGroup.Id, SenderId = dbUserModel.UserModel.Id, Message = message, UnixTimeCreatedAt = DateTime.UtcNow.ToFileTimeUtc(), }; await MongoConnector.GetMessagesCollection().InsertOneAsync(model); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); }
public static async Task <SuperUser> CreateSuperUser() { String password = Guid.NewGuid().ToString(); Console.WriteLine($"Password: {password}"); DbUserModel dbUserModel = new DbUserModel(new UserModel() { Id = Guid.NewGuid().ToString(), Username = "******", Email = "SuperUser", EmailVerified = true, PasswordHash = JwtManager.HashPassword(password), Claims = { UserClaim.User, UserClaim.Admin, UserClaim.Dev, UserClaim.EmailVerified } }); await dbUserModel.SaveToDatabase(); return(new SuperUser(dbUserModel, password)); }
public async Task <SubmitGameEventResponse> UpdateGameEvent(DbUserModel player, UpdateGameEventRequest request) { GameEventModel gameEvent = await GetGameEventFromGuid(request.EventId); if (gameEvent == null) { return(new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST) }); } if (gameEvent.IssuedBy != player.UserModel.Id) { return(new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED) }); } // Ensure the event happens after current time. GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(GameConfiguration.UnixTimeStarted), DateTime.UtcNow); if (request.EventData.OccursAtTick <= currentTick.GetTick()) { return(new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST) }); } // TODO: validate event. // Overwrite data with request data. gameEvent.EventData = request.EventData.EventData; gameEvent.OccursAtTick = request.EventData.OccursAtTick; MongoConnector.GetGameEventCollection().ReplaceOne((it => it.RoomId == GameConfiguration.Id), new GameEventModelMapper(gameEvent)); return(new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), EventId = gameEvent.Id, }); }
public async Task <bool> IsFriend(DbUserModel friend) { FriendModel friendModel = (await MongoConnector.GetFriendCollection() .FindAsync(it => it.FriendStatus == FriendStatus.StatusFriends && ( (it.PlayerId == this.UserModel.Id && it.FriendId == friend.UserModel.Id) || (it.FriendId == this.UserModel.Id && it.PlayerId == friend.UserModel.Id) ) )) .ToList() .FirstOrDefault(); if (friendModel == null) { return(false); } return(true); }
public async Task <ResponseStatus> JoinRoom(DbUserModel dbUserModel) { if (IsRoomFull()) { return(ResponseFactory.createResponse(ResponseType.ROOM_IS_FULL)); } if (IsPlayerInRoom(dbUserModel)) { return(ResponseFactory.createResponse(ResponseType.DUPLICATE)); } if (GameConfiguration.RoomStatus != RoomStatus.Open) { return(ResponseFactory.createResponse(ResponseType.GAME_ALREADY_STARTED)); } List <DbUserModel> playersInRoom = new List <DbUserModel>(); foreach (User user in GameConfiguration.Players) { playersInRoom.Add(await DbUserModel.GetUserFromGuid(user.Id)); } // Check if any players in the room have the same device identifier if (playersInRoom.Any(it => it.UserModel.DeviceIdentifier == dbUserModel.UserModel.DeviceIdentifier)) { return(ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED)); } GameConfiguration.Players.Add(dbUserModel.AsUser()); MongoConnector.GetGameRoomCollection().ReplaceOne((it => it.Id == GameConfiguration.Id), new GameConfigurationMapper(GameConfiguration)); // Check if the player joining the game is the last player. if (GameConfiguration.Players.Count == GameConfiguration.GameSettings.MaxPlayers) { return(await StartGame()); } return(ResponseFactory.createResponse(ResponseType.SUCCESS));; }
public async Task <ResponseStatus> LeaveRoom(DbUserModel dbUserModel) { if (GameConfiguration.RoomStatus == RoomStatus.Open) { // Check if the player leaving was the host. if (GameConfiguration.Creator.Id == dbUserModel.UserModel.Id) { // Delete the game await MongoConnector.GetGameRoomCollection().DeleteOneAsync(it => it.Id == GameConfiguration.Id); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); } // Otherwise, just remove the player from the player list. GameConfiguration.Players.Remove(dbUserModel.AsUser()); await MongoConnector.GetGameRoomCollection().ReplaceOneAsync((it => it.Id == GameConfiguration.Id), new GameConfigurationMapper(GameConfiguration)); return(ResponseFactory.createResponse(ResponseType.SUCCESS)); } // TODO: Player left the game while ongoing. // Create a player leave game event and push to event list return(ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)); }
public SuperUser(DbUserModel dbUserModel, string password) { this.DbUserModel = dbUserModel; this.password = password; }
public Boolean IsPlayerInGroup(DbUserModel dbUserModel) { return(MessageGroup.GroupMembers.Any(it => it == dbUserModel.UserModel.Id)); }
public Boolean IsPlayerInRoom(DbUserModel player) { return(GameConfiguration.Players.Contains(player.AsUser())); }