public override async Task <SubmitGameEventResponse> UpdateGameEvent(UpdateGameEventRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; // GameEventToUpdate. return(await room.UpdateGameEvent(dbUserModel, request)); }
public override async Task <LeaveRoomResponse> LeaveRoom(LeaveRoomRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new LeaveRoomResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new LeaveRoomResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; return(new LeaveRoomResponse() { Status = await room.LeaveRoom(dbUserModel) }); }
public override async Task <DeleteGameEventResponse> DeleteGameEvent(DeleteGameEventRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new DeleteGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; return(await room.RemovePlayerGameEvent(dbUserModel, request.EventId)); }
public override async Task <GetSpecialistPackagesResponse> GetSpecialistPackages(GetSpecialistPackagesRequest request, ServerCallContext context) { DbUserModel user = context.UserState["user"] as DbUserModel; if (user == null) { return new GetSpecialistPackagesResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; // Search through all specialists for the search term. List <SpecialistPackageModel> results = (await SpecialistPackageModel.Search(request.SearchTerm)).Skip((int)request.PageNumber * 50).Take(50).ToList(); GetSpecialistPackagesResponse response = new GetSpecialistPackagesResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }; foreach (SpecialistPackageModel model in results) { response.SpecialistPackages.Add(model.SpecialistPackage); } return(response); }
public override async Task <ViewBlockedPlayersResponse> ViewBlockedPlayers(ViewBlockedPlayersRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new ViewBlockedPlayersResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; ViewBlockedPlayersResponse response = new ViewBlockedPlayersResponse(); var blockedUsers = await Task.WhenAll( (await dbUserModel.GetBlockedUsers()) .Select( async it => ( await DbUserModel.GetUserFromGuid(it.FriendId) ).AsUser() ) ); response.BlockedUsers.AddRange(blockedUsers); response.Status = ResponseFactory.createResponse(ResponseType.SUCCESS); return(response); }
public override async Task <CreateRoomResponse> CreateNewRoom(CreateRoomRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new CreateRoomResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; // Ensure max players is over 1 if (request.GameSettings.MaxPlayers < 2) { return new CreateRoomResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST) } } ; Room room = new Room(request, dbUserModel.AsUser()); await room.CreateInDatabase(); return(new CreateRoomResponse() { CreatedRoom = room.GameConfiguration, Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }); }
public override async Task <CreateSpecialistPackageResponse> CreateSpecialistPackage(CreateSpecialistPackageRequest request, ServerCallContext context) { DbUserModel user = context.UserState["user"] as DbUserModel; if (user == null) { return new CreateSpecialistPackageResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; // Set author request.SpecialistPackage.Creator = user.AsUser(); SpecialistPackageModel packageModel = new SpecialistPackageModel(request.SpecialistPackage); await packageModel.SaveToDatabase(); // Get the generated specialist ID string packageId = packageModel.SpecialistPackage.Id; return(new CreateSpecialistPackageResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), SpecialistPackageId = packageId, }); }
public override async Task <ViewFriendsResponse> ViewFriends(ViewFriendsRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new ViewFriendsResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; ViewFriendsResponse response = new ViewFriendsResponse(); var friends = (await Task.WhenAll( (await dbUserModel.GetFriends()) .Select(async it => { return(it.PlayerId == dbUserModel.UserModel.Id ? (await DbUserModel.GetUserFromGuid(it.FriendId)).AsUser() : (await DbUserModel.GetUserFromGuid(it.PlayerId)).AsUser()); } ) )).ToList(); response.Friends.AddRange(friends); response.Status = ResponseFactory.createResponse(ResponseType.SUCCESS); return(response); }
public override async Task <AuthorizationResponse> LoginWithToken(AuthorizedTokenRequest request, ServerCallContext context) { if (string.IsNullOrEmpty(request.Token)) { return new AuthorizationResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_CREDENTIALS) } } ; if (JwtManager.ValidateToken(request.Token, out var uuid)) { // Validate user exists. DbUserModel dbUserModel = await DbUserModel.GetUserFromGuid(uuid); if (dbUserModel != null) { context.UserState["user"] = dbUserModel; return(new AuthorizationResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), Token = request.Token, User = dbUserModel.AsUser(), }); } } return(new AuthorizationResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_CREDENTIALS) }); }
public override async Task <AccountRegistrationResponse> RegisterAccount(AccountRegistrationRequest request, ServerCallContext context) { DbUserModel dbUserModel = await DbUserModel.GetUserFromUsername(request.Username); if (dbUserModel != null) { return new AccountRegistrationResponse() { Status = ResponseFactory.createResponse(ResponseType.DUPLICATE) } } ; // Create a new user model DbUserModel model = new DbUserModel(request); await model.SaveToDatabase(); string token = JwtManager.GenerateToken(model.UserModel.Id); context.ResponseTrailers.Add("Authorization", token); return(new AccountRegistrationResponse { Token = token, User = model.AsUser(), Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }); }
public override async Task <SubmitGameEventResponse> SubmitGameEvent(SubmitGameEventRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; if (!room.IsPlayerInRoom(dbUserModel)) { return new SubmitGameEventResponse() { Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED) } } ; return(await room.AddPlayerGameEvent(dbUserModel, request.EventData)); }
public override async Task <SubmitCustomSpecialistResponse> SubmitCustomSpecialist(SubmitCustomSpecialistRequest request, ServerCallContext context) { DbUserModel user = context.UserState["user"] as DbUserModel; if (user == null) { return new SubmitCustomSpecialistResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; // Set author request.Configuration.Creator = user.AsUser(); SpecialistConfigurationModel configModel = new SpecialistConfigurationModel(request.Configuration); await configModel.saveToRedis(); // Get the generated specialist ID string specialistId = configModel.SpecialistConfig.Id; return(new SubmitCustomSpecialistResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), SpecialistConfigurationId = specialistId, }); }
public async Task SignInUser(DbUserModel user) { var claims = new List <Claim> { new Claim(ClaimTypes.NameIdentifier, user.UserName.ToString()), new Claim(ClaimTypes.Name, user.UserId.ToString()), new Claim(ClaimTypes.Role, user.CategoryId.ToString()) }; var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme, "name", null); var principal = new ClaimsPrincipal(identity); await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal); }
public void SuperUserAccountHasAdminClaims() { SuperUser superUser = DbUserModel.CreateSuperUser().Result; // Fetch the user from the database. DbUserModel dbUserModel = DbUserModel.GetUserFromGuid(superUser.DbUserModel.UserModel.Id).Result; // Ensure the user has admin power Assert.IsTrue(dbUserModel.HasClaim(UserClaim.Admin)); Assert.IsTrue(dbUserModel.HasClaim(UserClaim.Dev)); Assert.IsTrue(dbUserModel.HasClaim(UserClaim.EmailVerified)); }
public override async Task <GetGameRoomEventsResponse> GetGameRoomEvents(GetGameRoomEventsRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new GetGameRoomEventsResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new GetGameRoomEventsResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; if (room.GameConfiguration.Players.All(it => it.Id != dbUserModel.UserModel.Id) && !dbUserModel.HasClaim(UserClaim.Admin)) { return new GetGameRoomEventsResponse() { Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED) } } ; List <GameEventModel> events = await room.GetAllGameEvents(); // Filter out only the player's events and events that have occurred in the past. // Get current tick to determine events in the past. GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(room.GameConfiguration.UnixTimeStarted), DateTime.UtcNow); // Admins see all events :) if (!dbUserModel.HasClaim(UserClaim.Admin)) { events = events.FindAll(it => it.OccursAtTick <= currentTick.GetTick() || it.IssuedBy == dbUserModel.UserModel.Id); } GetGameRoomEventsResponse response = new GetGameRoomEventsResponse(); response.GameEvents.AddRange(events); response.Status = ResponseFactory.createResponse(ResponseType.SUCCESS); return(response); }
public Task <bool> ValidateCredentials(string username, string password, out DbUserModel user) { user = null; IDBService _dbService = new DBservice(dbHelper); var verifyUser = _dbService.FetchUser(username); if (verifyUser != null) { user = verifyUser; return(Task.FromResult(true)); } return(Task.FromResult(false)); }
public override async Task <GetGroupMessagesResponse> GetGroupMessages(GetGroupMessagesRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new GetGroupMessagesResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new GetGroupMessagesResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; GroupChat groupChat = await room.GetGroupChatById(request.GroupId); if (groupChat == null) { return new GetGroupMessagesResponse() { Status = ResponseFactory.createResponse(ResponseType.CHAT_GROUP_DOES_NOT_EXIST) } } ; if (!groupChat.IsPlayerInGroup(dbUserModel)) { return new GetGroupMessagesResponse() { Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED) } } ; return(new GetGroupMessagesResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), Group = await groupChat.asMessageGroup(request.Pagination) }); }
public override async Task <SendFriendRequestResponse> SendFriendRequest(SendFriendRequestRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new SendFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; DbUserModel friend = await DbUserModel.GetUserFromGuid(request.FriendId); if (friend == null) { return new SendFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST) } } ; if (await friend.HasFriendRequestFrom(dbUserModel)) { return new SendFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.DUPLICATE) } } ; if (await friend.IsBlocked(dbUserModel) || await dbUserModel.IsBlocked(friend)) { return new SendFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.PLAYER_IS_BLOCKED) } } ; // Add request to the other player. await friend.AddFriendRequestFrom(dbUserModel); return(new SendFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS) }); }
static void Main(string[] args) { MongoConnector mongo = new MongoConnector(dbHost, dbPort, false); SubterfugeServer grpcService = new SubterfugeServer(); Server server = new Server { Services = { subterfugeService.BindService(grpcService).Intercept(new LoggerInterceptor()).Intercept(new JwtInterceptor()) }, Ports = { new ServerPort(Hostname, Port, ServerCredentials.Insecure) } }; Console.WriteLine($"Listening on {Port}..."); DbUserModel.CreateSuperUser(); // Creates a super user with admin powers. server.Start(); Shutdown.WaitOne(); server.ShutdownAsync().Wait(); }
public void SuperUserAccountHasAdminClaimsFromRolesEndpoint() { SuperUser superUser = DbUserModel.CreateSuperUser().Result; client.Login(new AuthorizationRequest() { Password = superUser.password, Username = superUser.DbUserModel.UserModel.Username }); GetRolesResponse roleResponse = client.GetRoles(new GetRolesRequest() { }); Assert.IsTrue(roleResponse.Status.IsSuccess); Assert.IsTrue(roleResponse.Claims.Contains(UserClaim.User)); Assert.IsTrue(roleResponse.Claims.Contains(UserClaim.Admin)); }
public override async Task <CreateMessageGroupResponse> CreateMessageGroup(CreateMessageGroupRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new CreateMessageGroupResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; Room room = await Room.GetRoomFromGuid(request.RoomId); if (room == null) { return new CreateMessageGroupResponse() { Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST) } } ; if (room.GameConfiguration.RoomStatus != RoomStatus.Ongoing) { return new CreateMessageGroupResponse() { Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED), } } ; if (!request.UserIdsInGroup.Contains(dbUserModel.UserModel.Id)) { return new CreateMessageGroupResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST) } } ; return(await room.CreateMessageGroup(request.UserIdsInGroup.ToList())); }
public override async Task <UnblockPlayerResponse> UnblockPlayer(UnblockPlayerRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new UnblockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; // Check if player is valid. DbUserModel friend = await DbUserModel.GetUserFromGuid(request.UserIdToBlock); if (friend == null) { return new UnblockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST) } } ; // Check if player is blocked. if (!await dbUserModel.IsBlocked(friend)) { return new UnblockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST) } } ; await dbUserModel.UnblockUser(friend); return(new UnblockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS) }); }
public override async Task <PlayerCurrentGamesResponse> GetPlayerCurrentGames(PlayerCurrentGamesRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new PlayerCurrentGamesResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; PlayerCurrentGamesResponse currentGameResponse = new PlayerCurrentGamesResponse(); List <GameConfiguration> rooms = (await dbUserModel.GetActiveRooms()).Select(it => it.GameConfiguration).ToList(); currentGameResponse.Games.AddRange(rooms); currentGameResponse.Status = ResponseFactory.createResponse(ResponseType.SUCCESS); return(currentGameResponse); }
public override Task <GetRolesResponse> GetRoles(GetRolesRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return(Task.FromResult(new GetRolesResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) })); } var response = new GetRolesResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS) }; response.Claims.AddRange(dbUserModel.UserModel.Claims); return(Task.FromResult(response)); }
public override async Task <OpenLobbiesResponse> GetOpenLobbies(OpenLobbiesRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new OpenLobbiesResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; OpenLobbiesResponse roomResponse = new OpenLobbiesResponse(); List <SubterfugeRemakeService.GameConfiguration> rooms = (await Room.GetOpenLobbies()).Select(it => it.GameConfiguration).ToList(); roomResponse.Rooms.AddRange(rooms); roomResponse.Status = ResponseFactory.createResponse(ResponseType.SUCCESS); return(roomResponse); }
public override async Task <TResponse> UnaryServerHandler <TRequest, TResponse>(TRequest request, ServerCallContext context, UnaryServerMethod <TRequest, TResponse> continuation) { string calledMethod = context.Method.Split('/').Last(); context.UserState["user"] = null; // Do not authorize these methods: string[] whitelist = { "Login", "LoginWithToken", "RegisterAccount", "HealthCheck", }; if (!whitelist.Contains(calledMethod)) { // The endpoint requires authorization before performing. // Get JWT header Metadata.Entry entry = context.RequestHeaders.Get("authorization"); if (entry?.Value != null) { if (JwtManager.ValidateToken(entry.Value, out var uuid)) { // Validate user exists. DbUserModel dbUserModel = await DbUserModel.GetUserFromGuid(uuid); if (dbUserModel != null) { context.UserState["user"] = dbUserModel; } } } } // Do regular request and return var response = await base.UnaryServerHandler(request, context, continuation); return(response); }
public override async Task <BlockPlayerResponse> BlockPlayer(BlockPlayerRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new BlockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; DbUserModel friend = await DbUserModel.GetUserFromGuid(request.UserIdToBlock); if (friend == null) { return new BlockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST) } } ; if (await dbUserModel.IsBlocked(friend)) { return new BlockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.DUPLICATE) } } ; await dbUserModel.BlockUser(friend); return(new BlockPlayerResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS) }); }
public override async Task <GetPlayerSpecialistPackagesResponse> GetPlayerSpecialistPackages(GetPlayerSpecialistPackagesRequest request, ServerCallContext context) { DbUserModel user = context.UserState["user"] as DbUserModel; if (user == null) { return new GetPlayerSpecialistPackagesResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; // Get the requested user from their id DbUserModel player = await DbUserModel.GetUserFromGuid(request.PlayerId); if (player == null) { return(new GetPlayerSpecialistPackagesResponse() { Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST) }); } List <SpecialistPackageModel> results = await player.GetSpecialistPackages(); GetPlayerSpecialistPackagesResponse response = new GetPlayerSpecialistPackagesResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }; foreach (SpecialistPackageModel model in results) { response.PlayerPackages.Add(model.SpecialistPackage); } return(response); } }
public override async Task <DenyFriendRequestResponse> DenyFriendRequest(DenyFriendRequestRequest request, ServerCallContext context) { DbUserModel dbUserModel = context.UserState["user"] as DbUserModel; if (dbUserModel == null) { return new DenyFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED) } } ; DbUserModel friend = await DbUserModel.GetUserFromGuid(request.FriendId); if (friend == null) { return new DenyFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST) } } ; if (!await dbUserModel.HasFriendRequestFrom(friend)) { return new DenyFriendRequestResponse() { Status = ResponseFactory.createResponse(ResponseType.FRIEND_REQUEST_DOES_NOT_EXIST) } } ; return(new DenyFriendRequestResponse() { Status = await dbUserModel.RemoveFriendRequestFrom(friend), }); }
public override async Task <AuthorizationResponse> Login(AuthorizationRequest request, ServerCallContext context) { // Try to get a user DbUserModel dbUserModel = await DbUserModel.GetUserFromUsername(request.Username); if (dbUserModel == null || !JwtManager.VerifyPasswordHash(request.Password, dbUserModel.UserModel.PasswordHash)) { return new AuthorizationResponse() { Status = ResponseFactory.createResponse(ResponseType.INVALID_CREDENTIALS) } } ; string token = JwtManager.GenerateToken(dbUserModel.UserModel.Id); context.ResponseTrailers.Add("Authorization", token); return(new AuthorizationResponse { Token = token, User = dbUserModel.AsUser(), Status = ResponseFactory.createResponse(ResponseType.SUCCESS), }); }