public override async Task <ViewFriendRequestsResponse> ViewFriendRequests(ViewFriendRequestsRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new ViewFriendRequestsResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
ViewFriendRequestsResponse response = new ViewFriendRequestsResponse();
List <User> users = (await user.GetFriendRequests()).ConvertAll(input => input.asUser());
response.IncomingFriends.AddRange(users);
response.Status = ResponseFactory.createResponse(ResponseType.SUCCESS);
return(response);
}
public override async Task <PlayerCurrentGamesResponse> GetPlayerCurrentGames(PlayerCurrentGamesRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new PlayerCurrentGamesResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
PlayerCurrentGamesResponse currentGameResponse = new PlayerCurrentGamesResponse();
List <Room> rooms = (await user.GetActiveRooms()).ConvertAll(it => it.asRoom().Result);
currentGameResponse.Games.AddRange(rooms);
currentGameResponse.Status = ResponseFactory.createResponse(ResponseType.SUCCESS);
return(currentGameResponse);
}
public override async Task <OpenLobbiesResponse> GetOpenLobbies(OpenLobbiesRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new OpenLobbiesResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
OpenLobbiesResponse roomResponse = new OpenLobbiesResponse();
List <Room> rooms = (await RedisRoomModel.GetOpenLobbies()).ConvertAll(it => it.asRoom().Result);
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.
RedisUserModel user = await RedisUserModel.GetUserFromGuid(uuid);
if (user != null)
{
context.UserState["user"] = user;
}
}
}
}
// 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)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new BlockPlayerResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
RedisUserModel friend = await RedisUserModel.GetUserFromGuid(request.UserIdToBlock);
if (friend == null)
{
return new BlockPlayerResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST)
}
}
;
if (await user.IsBlocked(friend))
{
return new BlockPlayerResponse()
{
Status = ResponseFactory.createResponse(ResponseType.DUPLICATE)
}
}
;
await user.BlockUser(friend);
return(new BlockPlayerResponse()
{
Status = ResponseFactory.createResponse(ResponseType.SUCCESS)
});
}
public override async Task <DenyFriendRequestResponse> DenyFriendRequest(DenyFriendRequestRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new DenyFriendRequestResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
RedisUserModel friend = await RedisUserModel.GetUserFromGuid(request.FriendId);
if (friend == null)
{
return new DenyFriendRequestResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST)
}
}
;
if (!await user.HasFriendRequestFrom(friend))
{
return new DenyFriendRequestResponse()
{
Status = ResponseFactory.createResponse(ResponseType.FRIEND_REQUEST_DOES_NOT_EXIST)
}
}
;
return(new DenyFriendRequestResponse()
{
Status = await user.RemoveFriendRequestFrom(friend),
});
}
public override async Task <AuthorizationResponse> Login(AuthorizationRequest request, ServerCallContext context)
{
// Try to get a user
RedisUserModel user = await RedisUserModel.GetUserFromUsername(request.Username);
if (user == null || !JwtManager.VerifyPasswordHash(request.Password, user.UserModel.PasswordHash))
{
return new AuthorizationResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_CREDENTIALS)
}
}
;
string token = JwtManager.GenerateToken(user.UserModel.Id);
context.ResponseTrailers.Add("Authorization", token);
return(new AuthorizationResponse
{
Token = token,
User = user.asUser(),
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
});
}
public override async Task <GetMessageGroupsResponse> GetMessageGroups(GetMessageGroupsRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new GetMessageGroupsResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
RedisRoomModel room = await RedisRoomModel.GetRoomFromGuid(request.RoomId);
if (room == null)
{
return new GetMessageGroupsResponse()
{
Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST)
}
}
;
List <GroupChatModel> groupChats = await room.GetPlayerGroupChats(user);
GetMessageGroupsResponse response = new GetMessageGroupsResponse();
foreach (var groupModel in groupChats)
{
response.MessageGroups.Add(await groupModel.asMessageGroup());
}
response.Status = ResponseFactory.createResponse(ResponseType.SUCCESS);
return(response);
}
public override async Task <StartGameEarlyResponse> StartGameEarly(StartGameEarlyRequest request, ServerCallContext context)
{
RedisUserModel user = context.UserState["user"] as RedisUserModel;
if (user == null)
{
return new StartGameEarlyResponse()
{
Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
}
}
;
RedisRoomModel room = await RedisRoomModel.GetRoomFromGuid(request.RoomId);
if (room == null)
{
return new StartGameEarlyResponse()
{
Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST)
}
}
;
if (room.RoomModel.CreatorId == user.UserModel.Id)
{
return(new StartGameEarlyResponse()
{
Status = await room.StartGame(),
});
}
return(new StartGameEarlyResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED),
});
}
public SuperUser CreateSuperUser()
{
return(RedisUserModel.CreateSuperUser().Result);
}
