gitea-mirror/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2025-12-05 20:39:59 -08:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup (#5057)

Browse Source 
* Add Types

* Add Types
This commit is contained in:
Zach H
2024-06-17 00:32:36 -04:00
committed by GitHub
parent 0994d10410
commit c4bf9eb61c
61 changed files with 207 additions and 737 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
webclient/src/api/ModeratorService.tsx
View File

@@ -1,4 +1,5 @@
import { ModeratorCommands } from 'websocket';
import { LogFilters } from 'types';
export default class ModeratorService {
static banFromServer(minutes: number, userName?: string, address?: string, reason?: string,
@@ -18,7 +19,7 @@ export default class ModeratorService {
ModeratorCommands.getWarnList(modName, userName, userClientid);
}
static viewLogHistory(filters): void {
static viewLogHistory(filters: LogFilters): void {
ModeratorCommands.viewLogHistory(filters);
}

3
webclient/src/containers/Logs/Logs.tsx
View File

@@ -7,6 +7,7 @@ import { ModeratorService } from 'api';
import { AuthGuard, ModGuard } from 'components';
import { SearchForm } from 'forms';
import { ServerDispatch, ServerSelectors, ServerStateLogs } from 'store';
import { LogFilters } from 'types';
import LogResults from './LogResults';
import './Logs.css';
@@ -24,7 +25,7 @@ class Logs extends Component<LogsTypes> {
ServerDispatch.clearLogs();
}
onSubmit(fields) {
onSubmit(fields: LogFilters) {
const trimmedFields: any = this.trimFields(fields);
const { userName, ipAddress, gameName, gameId, message, logLocation } = trimmedFields;

2
webclient/src/types/index.ts
View File

@@ -12,3 +12,5 @@ export * from './forms';
export * from './message';
export * from './settings';
export * from './languages';
export * from './logs';
export * from './session';

8
webclient/src/types/logs.ts Normal file
View File

@@ -0,0 +1,8 @@
export interface LogFilters {
userName: string;
ipAddress: string;
gameName: string;
gameId: string;
message: string;
logLocation: string;
}

7
webclient/src/types/session.ts Normal file
View File

@@ -0,0 +1,7 @@
export enum NotificationType {
UNKNOWN = 0,
PROMOTED = 1,
WARNING = 2,
IDLEWARNING = 3,
CUSTOM = 4,
};

5
webclient/src/websocket/commands/admin/adjustMod.ts
View File

@@ -3,10 +3,7 @@ import { AdminPersistence } from '../../persistence';
export function adjustMod(userName: string, shouldBeMod?: boolean, shouldBeJudge?: boolean): void {
const command = webClient.protobuf.controller.Command_AdjustMod.create({ userName, shouldBeMod, shouldBeJudge });
const sc = webClient.protobuf.controller.AdminCommand.create({
'.Command_AdjustMod.ext': command
});
const sc = webClient.protobuf.controller.AdminCommand.create({ '.Command_AdjustMod.ext': command });
webClient.protobuf.sendAdminCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/admin/reloadConfig.ts
View File

@@ -3,10 +3,7 @@ import { AdminPersistence } from '../../persistence';
export function reloadConfig(): void {
const command = webClient.protobuf.controller.Command_ReloadConfig.create();
const sc = webClient.protobuf.controller.AdminCommand.create({
'.Command_ReloadConfig.ext': command
});
const sc = webClient.protobuf.controller.AdminCommand.create({ '.Command_ReloadConfig.ext': command });
webClient.protobuf.sendAdminCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/admin/shutdownServer.ts
View File

@@ -3,10 +3,7 @@ import { AdminPersistence } from '../../persistence';
export function shutdownServer(reason: string, minutes: number): void {
const command = webClient.protobuf.controller.Command_ShutdownServer.create({ reason, minutes });
const sc = webClient.protobuf.controller.AdminCommand.create({
'.Command_ShutdownServer.ext': command
});
const sc = webClient.protobuf.controller.AdminCommand.create({ '.Command_ShutdownServer.ext': command });
webClient.protobuf.sendAdminCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/admin/updateServerMessage.ts
View File

@@ -3,10 +3,7 @@ import { AdminPersistence } from '../../persistence';
export function updateServerMessage(): void {
const command = webClient.protobuf.controller.Command_UpdateServerMessage.create();
const sc = webClient.protobuf.controller.AdminCommand.create({
'.Command_UpdateServerMessage.ext': command
});
const sc = webClient.protobuf.controller.AdminCommand.create({ '.Command_UpdateServerMessage.ext': command });
webClient.protobuf.sendAdminCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/moderator/banFromServer.ts
View File

@@ -6,10 +6,7 @@ export function banFromServer(minutes: number, userName?: string, address?: stri
const command = webClient.protobuf.controller.Command_BanFromServer.create({
minutes, userName, address, reason, visibleReason, clientid, removeMessages
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_BanFromServer.ext': command
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({ '.Command_BanFromServer.ext': command });
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/moderator/getBanHistory.ts
View File

@@ -3,10 +3,7 @@ import { ModeratorPersistence } from '../../persistence';
export function getBanHistory(userName: string): void {
const command = webClient.protobuf.controller.Command_GetBanHistory.create({ userName });
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_GetBanHistory.ext': command
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({ '.Command_GetBanHistory.ext': command });
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/moderator/getWarnHistory.ts
View File

@@ -3,10 +3,7 @@ import { ModeratorPersistence } from '../../persistence';
export function getWarnHistory(userName: string): void {
const command = webClient.protobuf.controller.Command_GetWarnHistory.create({ userName });
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_GetWarnHistory.ext': command
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({ '.Command_GetWarnHistory.ext': command });
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/moderator/getWarnList.ts
View File

@@ -3,10 +3,7 @@ import { ModeratorPersistence } from '../../persistence';
export function getWarnList(modName: string, userName: string, userClientid: string): void {
const command = webClient.protobuf.controller.Command_GetWarnList.create({ modName, userName, userClientid });
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_GetWarnList.ext': command
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({ '.Command_GetWarnList.ext': command });
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;

8
webclient/src/websocket/commands/moderator/viewLogHistory.ts
View File

@@ -1,12 +1,10 @@
import webClient from '../../WebClient';
import { ModeratorPersistence } from '../../persistence';
import { LogFilters } from 'types';
export function viewLogHistory(filters): void {
export function viewLogHistory(filters: LogFilters): void {
const command = webClient.protobuf.controller.Command_ViewLogHistory.create(filters);
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_ViewLogHistory.ext': command
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({ '.Command_ViewLogHistory.ext': command });
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/moderator/warnUser.ts
View File

@@ -3,10 +3,7 @@ import { ModeratorPersistence } from '../../persistence';
export function warnUser(userName: string, reason: string, clientid?: string, removeMessage?: boolean): void {
const command = webClient.protobuf.controller.Command_BanFromServer.create({ userName, reason, clientid, removeMessage });
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_WarnUser.ext': command
});
const sc = webClient.protobuf.controller.ModeratorCommand.create({ '.Command_WarnUser.ext': command });
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;

75
webclient/src/websocket/commands/room/RoomCommands.spec.ts
View File

@@ -1,75 +0,0 @@
import { RoomPersistence } from '../../persistence';
import webClient from '../../WebClient';
import { leaveRoom, roomSay } from './';
describe.skip('RoomCommands', () => {
const roomId = 1;
let sendRoomCommandSpy;
beforeEach(() => {
sendRoomCommandSpy = jest.spyOn(webClient.protobuf, 'sendRoomCommand').mockImplementation(() => {});
webClient.protobuf.controller.RoomCommand = { create: args => args };
});
afterEach(() => {
jest.restoreAllMocks();
});
describe('roomSay', () => {
beforeEach(() => {
webClient.protobuf.controller.Command_RoomSay = { create: args => args };
});
it('should call protobuf controller methods and sendCommand', () => {
const message = ' message ';
roomSay(roomId, message);
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalled();
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalledWith(roomId, {
'.Command_RoomSay.ext': { message: message.trim() }
});
});
it('should not call sendRoomCommand if trimmed message is empty', () => {
const message = ' ';
roomSay(roomId, message);
expect(webClient.protobuf.sendRoomCommand).not.toHaveBeenCalled();
});
});
describe('leaveRoom', () => {
beforeEach(() => {
webClient.protobuf.controller.Command_LeaveRoom = { create: () => ({}) };
});
it('should call protobuf controller methods and sendCommand', () => {
leaveRoom(roomId);
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalled();
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalledWith(
roomId,
{ '.Command_LeaveRoom.ext': {} },
expect.any(Function)
);
});
it('should call RoomPersistence.leaveRoom if RespOk', () => {
const RespOk = 'ok';
webClient.protobuf.controller.Response = { ResponseCode: { RespOk } };
sendRoomCommandSpy.mockImplementation((_, __, callback) => {
callback({ responseCode: RespOk })
});
jest.spyOn(RoomPersistence, 'leaveRoom').mockImplementation(() => {});
leaveRoom(roomId);
expect(RoomPersistence.leaveRoom).toHaveBeenCalledWith(roomId);
});
});
});

7
webclient/src/websocket/commands/room/leaveRoom.ts
View File

@@ -2,11 +2,8 @@ import { RoomPersistence } from '../../persistence';
import webClient from '../../WebClient';
export function leaveRoom(roomId: number): void {
const CmdLeaveRoom = webClient.protobuf.controller.Command_LeaveRoom.create();
const rc = webClient.protobuf.controller.RoomCommand.create({
'.Command_LeaveRoom.ext': CmdLeaveRoom
});
const command = webClient.protobuf.controller.Command_LeaveRoom.create();
const rc = webClient.protobuf.controller.RoomCommand.create({ '.Command_LeaveRoom.ext': command });
webClient.protobuf.sendRoomCommand(roomId, rc, (raw) => {
const { responseCode } = raw;

9
webclient/src/websocket/commands/room/roomSay.ts
View File

@@ -7,13 +7,8 @@ export function roomSay(roomId: number, message: string): void {
return;
}
const CmdRoomSay = webClient.protobuf.controller.Command_RoomSay.create({
'message': trimmed
});
const rc = webClient.protobuf.controller.RoomCommand.create({
'.Command_RoomSay.ext': CmdRoomSay
});
const command = webClient.protobuf.controller.Command_RoomSay.create({ 'message': trimmed });
const rc = webClient.protobuf.controller.RoomCommand.create({ '.Command_RoomSay.ext': command });
webClient.protobuf.sendRoomCommand(roomId, rc);
}

5
webclient/src/websocket/commands/session/accountEdit.ts
View File

@@ -3,10 +3,7 @@ import { SessionPersistence } from '../../persistence';
export function accountEdit(passwordCheck: string, realName?: string, email?: string, country?: string): void {
const command = webClient.protobuf.controller.Command_AccountEdit.create({ passwordCheck, realName, email, country });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_AccountEdit.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_AccountEdit.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

9
webclient/src/websocket/commands/session/accountImage.ts
View File

@@ -1,14 +1,9 @@
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import { common } from 'protobufjs';
import IBytesValue = common.IBytesValue;
export function accountImage(image: IBytesValue): void {
export function accountImage(image: unknown): void {
const command = webClient.protobuf.controller.Command_AccountImage.create({ image });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_AccountImage.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_AccountImage.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/session/accountPassword.ts
View File

@@ -3,10 +3,7 @@ import { SessionPersistence } from '../../persistence';
export function accountPassword(oldPassword: string, newPassword: string, hashedNewPassword: string): void {
const command = webClient.protobuf.controller.Command_AccountPassword.create({ oldPassword, newPassword, hashedNewPassword });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_AccountPassword.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_AccountPassword.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

7
webclient/src/websocket/commands/session/activate.ts
View File

@@ -15,11 +15,8 @@ export function activate(options: WebSocketConnectOptions, passwordSalt?: string
token,
};
const CmdActivate = webClient.protobuf.controller.Command_Activate.create(accountActivationConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Activate.ext': CmdActivate
});
const command = webClient.protobuf.controller.Command_Activate.create(accountActivationConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_Activate.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespActivationAccepted) {

16
webclient/src/websocket/commands/session/addToList.ts
View File

@@ -1,4 +1,5 @@
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
export function addToBuddyList(userName: string): void {
addToList('buddy', userName);
@@ -9,13 +10,16 @@ export function addToIgnoreList(userName: string): void {
}
export function addToList(list: string, userName: string): void {
const CmdAddToList = webClient.protobuf.controller.Command_AddToList.create({ list, userName });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_AddToList.ext': CmdAddToList
});
const command = webClient.protobuf.controller.Command_AddToList.create({ list, userName });
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_AddToList.ext': command });
webClient.protobuf.sendSessionCommand(sc, ({ responseCode }) => {
// @TODO: filter responseCode, pop snackbar for error
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
SessionPersistence.addToList(list, userName);
break;
default:
console.error('Failed to add to list', responseCode);
}
});
}

7
webclient/src/websocket/commands/session/forgotPasswordChallenge.ts
View File

@@ -14,11 +14,8 @@ export function forgotPasswordChallenge(options: WebSocketConnectOptions): void
email,
};
const CmdForgotPasswordChallenge = webClient.protobuf.controller.Command_ForgotPasswordChallenge.create(forgotPasswordChallengeConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordChallenge.ext': CmdForgotPasswordChallenge
});
const command = webClient.protobuf.controller.Command_ForgotPasswordChallenge.create(forgotPasswordChallengeConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_ForgotPasswordChallenge.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {

7
webclient/src/websocket/commands/session/forgotPasswordRequest.ts
View File

@@ -22,11 +22,8 @@ export function forgotPasswordRequest(options: WebSocketConnectOptions, password
forgotPasswordResetConfig.newPassword = newPassword;
}
const CmdForgotPasswordReset = webClient.protobuf.controller.Command_ForgotPasswordReset.create(forgotPasswordResetConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordReset.ext': CmdForgotPasswordReset
});
const command = webClient.protobuf.controller.Command_ForgotPasswordReset.create(forgotPasswordResetConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_ForgotPasswordReset.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {

5
webclient/src/websocket/commands/session/getGamesOfUser.ts
View File

@@ -3,10 +3,7 @@ import { SessionPersistence } from '../../persistence';
export function getGamesOfUser(userName: string): void {
const command = webClient.protobuf.controller.Command_GetGamesOfUser.create({ userName });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_GetGamesOfUser.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_GetGamesOfUser.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

5
webclient/src/websocket/commands/session/getUserInfo.ts
View File

@@ -3,10 +3,7 @@ import { SessionPersistence } from '../../persistence';
export function getUserInfo(userName: string): void {
const command = webClient.protobuf.controller.Command_GetUserInfo.create({ userName });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_GetUserInfo.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_GetUserInfo.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

9
webclient/src/websocket/commands/session/joinRoom.ts
View File

@@ -2,16 +2,13 @@ import webClient from '../../WebClient';
import { RoomPersistence } from '../../persistence';
export function joinRoom(roomId: number): void {
const CmdJoinRoom = webClient.protobuf.controller.Command_JoinRoom.create({ roomId });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_JoinRoom.ext': CmdJoinRoom
});
const command = webClient.protobuf.controller.Command_JoinRoom.create({ roomId });
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_JoinRoom.ext': command });
webClient.protobuf.sendSessionCommand(sc, (raw) => {
const { responseCode } = raw;
let error;
let error: string;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:

7
webclient/src/websocket/commands/session/listRooms.ts
View File

@@ -1,11 +1,8 @@
import webClient from '../../WebClient';
export function listRooms(): void {
const CmdListRooms = webClient.protobuf.controller.Command_ListRooms.create();
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ListRooms.ext': CmdListRooms
});
const command = webClient.protobuf.controller.Command_ListRooms.create();
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_ListRooms.ext': command });
webClient.protobuf.sendSessionCommand(sc);
}

7
webclient/src/websocket/commands/session/listUsers.ts
View File

@@ -2,11 +2,8 @@ import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
export function listUsers(): void {
const CmdListUsers = webClient.protobuf.controller.Command_ListUsers.create();
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ListUsers.ext': CmdListUsers
});
const command = webClient.protobuf.controller.Command_ListUsers.create();
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_ListUsers.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

9
webclient/src/websocket/commands/session/login.ts
View File

@@ -25,13 +25,10 @@ export function login(options: WebSocketConnectOptions, passwordSalt?: string):
loginConfig.password = password;
}
const CmdLogin = webClient.protobuf.controller.Command_Login.create(loginConfig);
const command = webClient.protobuf.controller.Command_Login.create(loginConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_Login.ext': command });
const command = webClient.protobuf.controller.SessionCommand.create({
'.Command_Login.ext': CmdLogin
});
webClient.protobuf.sendSessionCommand(command, raw => {
webClient.protobuf.sendSessionCommand(sc, raw => {
const resp = raw['.Response_Login.ext'];
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {

5
webclient/src/websocket/commands/session/message.ts
View File

@@ -3,10 +3,7 @@ import { SessionPersistence } from '../../persistence';
export function message(userName: string, message: string): void {
const command = webClient.protobuf.controller.Command_Message.create({ userName, message });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Message.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_Message.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;

6
webclient/src/websocket/commands/session/ping.ts
View File

@@ -1,12 +1,8 @@
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
export function ping(pingReceived: Function): void {
const command = webClient.protobuf.controller.Command_Ping.create();
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Ping.ext': command
});
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_Ping.ext': command });
webClient.protobuf.sendSessionCommand(sc, pingReceived);
}

10
webclient/src/websocket/commands/session/register.ts
View File

@@ -25,11 +25,8 @@ export function register(options: WebSocketConnectOptions, passwordSalt?: string
registerConfig.password = password;
}
const CmdRegister = webClient.protobuf.controller.Command_Register.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Register.ext': CmdRegister
});
const command = webClient.protobuf.controller.Command_Register.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_Register.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespRegistrationAccepted) {
@@ -46,7 +43,6 @@ export function register(options: WebSocketConnectOptions, passwordSalt?: string
SessionPersistence.registrationUserNameError('Username is taken');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUsernameInvalid:
console.error('ResponseCode.RespUsernameInvalid', raw.reasonStr);
SessionPersistence.registrationUserNameError('Invalid username');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespPasswordTooShort:
@@ -65,7 +61,7 @@ export function register(options: WebSocketConnectOptions, passwordSalt?: string
SessionPersistence.registrationFailed('Registration is currently disabled');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserIsBanned:
SessionPersistence.registrationFailed(NormalizeService.normalizeBannedUserError(raw.reasonStr, raw.endTime));
SessionPersistence.registrationFailed(raw.reasonStr, raw.endTime);
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationFailed:
default:

16
webclient/src/websocket/commands/session/removeFromList.ts
View File

@@ -1,4 +1,5 @@
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
export function removeFromBuddyList(userName: string): void {
removeFromList('buddy', userName);
@@ -9,13 +10,16 @@ export function removeFromIgnoreList(userName: string): void {
}
export function removeFromList(list: string, userName: string): void {
const CmdRemoveFromList = webClient.protobuf.controller.Command_RemoveFromList.create({ list, userName });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_RemoveFromList.ext': CmdRemoveFromList
});
const command = webClient.protobuf.controller.Command_RemoveFromList.create({ list, userName });
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_RemoveFromList.ext': command });
webClient.protobuf.sendSessionCommand(sc, ({ responseCode }) => {
// @TODO: filter responseCode, pop snackbar for error
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
SessionPersistence.removeFromList(list, userName);
break;
default:
console.error('Failed to remove from list', responseCode);
}
});
}

7
webclient/src/websocket/commands/session/requestPasswordSalt.ts
View File

@@ -20,11 +20,8 @@ export function requestPasswordSalt(options: WebSocketConnectOptions): void {
userName,
};
const CmdRequestPasswordSalt = webClient.protobuf.controller.Command_RequestPasswordSalt.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_RequestPasswordSalt.ext': CmdRequestPasswordSalt
});
const command = webClient.protobuf.controller.Command_RequestPasswordSalt.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_RequestPasswordSalt.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
switch (raw.responseCode) {

7
webclient/src/websocket/commands/session/resetPasswordRequest.ts
View File

@@ -14,11 +14,8 @@ export function resetPasswordRequest(options: WebSocketConnectOptions): void {
userName,
};
const CmdForgotPasswordRequest = webClient.protobuf.controller.Command_ForgotPasswordRequest.create(forgotPasswordConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordRequest.ext': CmdForgotPasswordRequest
});
const command = webClient.protobuf.controller.Command_ForgotPasswordRequest.create(forgotPasswordConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({ '.Command_ForgotPasswordRequest.ext': command });
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {

66
webclient/src/websocket/events/room/RoomEvents.spec.ts
View File

@@ -1,66 +0,0 @@
import { Message } from 'types';
import { RoomPersistence } from '../../persistence';
import {
RoomEvent,
JoinRoomData,
LeaveRoomData,
ListGamesData,
} from './interfaces';
import { RoomEvents } from '.';
describe.skip('RoomEvents', () => {
it('.Event_JoinRoom.ext should call RoomPersistence.userJoined', () => {
jest.spyOn(RoomPersistence, 'userJoined').mockImplementation(() => {});
const data: JoinRoomData = { userInfo: {} as any };
const event: RoomEvent = { roomEvent: { roomId: 1 } };
RoomEvents['.Event_JoinRoom.ext'](data, event);
expect(RoomPersistence.userJoined).toHaveBeenCalledWith(
event.roomEvent.roomId,
data.userInfo
);
});
it('.Event_LeaveRoom.ext should call RoomPersistence.userLeft', () => {
jest.spyOn(RoomPersistence, 'userLeft').mockImplementation(() => {});
const data: LeaveRoomData = { name: '' };
const event: RoomEvent = { roomEvent: { roomId: 1 } };
RoomEvents['.Event_LeaveRoom.ext'](data, event);
expect(RoomPersistence.userLeft).toHaveBeenCalledWith(
event.roomEvent.roomId,
data.name
);
});
it('.Event_ListGames.ext should call RoomPersistence.updateGames', () => {
jest.spyOn(RoomPersistence, 'updateGames').mockImplementation(() => {});
const data: ListGamesData = { gameList: [] };
const event: RoomEvent = { roomEvent: { roomId: 1 } };
RoomEvents['.Event_ListGames.ext'](data, event);
expect(RoomPersistence.updateGames).toHaveBeenCalledWith(
event.roomEvent.roomId,
data.gameList
);
});
it('.Event_RoomSay.ext should call RoomPersistence.addMessage', () => {
jest.spyOn(RoomPersistence, 'addMessage').mockImplementation(() => {});
const data: Message = {} as any;
const event: RoomEvent = { roomEvent: { roomId: 1 } };
RoomEvents['.Event_RoomSay.ext'](data, event);
expect(RoomPersistence.addMessage).toHaveBeenCalledWith(
event.roomEvent.roomId,
data
);
});
});

2
webclient/src/websocket/events/room/index.ts
View File

@@ -7,9 +7,9 @@ import { roomSay } from './roomSay';
import { removeMessages } from './removeMessages';
export const RoomEvents: ProtobufEvents = {
'.Event_JoinRoom.ext': joinRoom,
'.Event_LeaveRoom.ext': leaveRoom,
'.Event_ListGames.ext': listGames,
'.Event_RemoveMessages.ext': removeMessages,
'.Event_RoomSay.ext': roomSay,
'.Event_JoinRoom.ext': joinRoom,
};

12
webclient/src/websocket/events/room/interfaces.ts
View File

@@ -1,11 +1,5 @@
import { Game, User } from 'types';
export interface RoomEvent {
roomEvent: {
roomId: number;
}
}
export interface JoinRoomData {
userInfo: User;
}
@@ -22,3 +16,9 @@ export interface RemoveMessagesData {
name: string;
amount: number;
}
export interface RoomEvent {
roomEvent: {
roomId: number;
}
}

4
webclient/src/websocket/events/room/joinRoom.ts
View File

@@ -1,8 +1,6 @@
import { RoomPersistence } from '../../persistence';
import { JoinRoomData, RoomEvent } from './interfaces';
export function joinRoom({ userInfo }: JoinRoomData, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
export function joinRoom({ userInfo }: JoinRoomData, { roomEvent: { roomId } }: RoomEvent): void {
RoomPersistence.userJoined(roomId, userInfo);
}

3
webclient/src/websocket/events/room/leaveRoom.ts
View File

@@ -1,7 +1,6 @@
import { RoomPersistence } from '../../persistence';
import { LeaveRoomData, RoomEvent } from './interfaces';
export function leaveRoom({ name }: LeaveRoomData, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
export function leaveRoom({ name }: LeaveRoomData, { roomEvent: { roomId } }: RoomEvent): void {
RoomPersistence.userLeft(roomId, name);
}

3
webclient/src/websocket/events/room/listGames.ts
View File

@@ -1,7 +1,6 @@
import { RoomPersistence } from '../../persistence';
import { ListGamesData, RoomEvent } from './interfaces';
export function listGames({ gameList }: ListGamesData, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
export function listGames({ gameList }: ListGamesData, { roomEvent: { roomId } }: RoomEvent): void {
RoomPersistence.updateGames(roomId, gameList);
}

2
webclient/src/websocket/events/room/removeMessages.ts
View File

@@ -1,6 +1,6 @@
import { RoomPersistence } from '../../persistence';
import { RemoveMessagesData, RoomEvent } from './interfaces';
export function removeMessages({ name, amount }: RemoveMessagesData, { roomEvent: { roomId } }: RoomEvent) {
export function removeMessages({ name, amount }: RemoveMessagesData, { roomEvent: { roomId } }: RoomEvent): void {
RoomPersistence.removeMessages(roomId, name, amount);
}

3
webclient/src/websocket/events/room/roomSay.ts
View File

@@ -3,7 +3,6 @@ import { Message } from 'types';
import { RoomPersistence } from '../../persistence';
import { RoomEvent } from './interfaces';
export function roomSay(message: Message, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
export function roomSay(message: Message, { roomEvent: { roomId } }: RoomEvent): void {
RoomPersistence.addMessage(roomId, message);
}

393
webclient/src/websocket/events/session/SessionEvents.spec.ts
View File

@@ -1,393 +0,0 @@
import { StatusEnum, WebSocketConnectReason } from 'types';
import { SessionCommands } from '../../commands';
import { RoomPersistence, SessionPersistence } from '../../persistence';
import webClient from '../../WebClient';
import {
AddToListData,
ConnectionClosedData,
ListRoomsData,
RemoveFromListData,
ServerIdentificationData,
ServerMessageData,
UserJoinedData,
UserLeftData,
} from './interfaces';
import { SessionEvents } from '.';
describe.skip('SessionEvents', () => {
const roomId = 1;
beforeEach(() => {
jest.spyOn(SessionCommands, 'updateStatus').mockImplementation(() => {});
});
describe('.Event_AddToList.ext', () => {
it('should call SessionPersistence.addToBuddyList if buddy listName', () => {
jest.spyOn(SessionPersistence, 'addToBuddyList').mockImplementation(() => {});
const data: AddToListData = { listName: 'buddy', userInfo: {} as any };
SessionEvents['.Event_AddToList.ext'](data);
expect(SessionPersistence.addToBuddyList).toHaveBeenCalledWith(
data.userInfo
);
});
it('should call SessionPersistence.addToIgnoreList if ignore listName', () => {
jest.spyOn(SessionPersistence, 'addToIgnoreList').mockImplementation(() => {});
const data: AddToListData = { listName: 'ignore', userInfo: {} as any };
SessionEvents['.Event_AddToList.ext'](data);
expect(SessionPersistence.addToIgnoreList).toHaveBeenCalledWith(
data.userInfo
);
});
it('should call console.log if unknown listName', () => {
jest.spyOn(console, 'log').mockImplementation(() => {});
const data: AddToListData = { listName: 'unknown', userInfo: {} as any };
SessionEvents['.Event_AddToList.ext'](data);
expect(console.log).toHaveBeenCalledWith(
`Attempted to add to unknown list: ${data.listName}`
);
});
});
describe('.Event_ConnectionClosed.ext', () => {
describe('with reasonStr', () => {
it('should call SessionCommands.updateStatus', () => {
const data: ConnectionClosedData = { endTime: 0, reason: 0, reasonStr: 'reasonStr' };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
data.reasonStr
);
});
});
describe('without reasonStr', () => {
beforeEach(() => {
webClient.protobuf.controller.Event_ConnectionClosed = { CloseReason: {} };
});
describe('USER_LIMIT_REACHED', () => {
it('should call SessionCommands.updateStatus', () => {
const USER_LIMIT_REACHED = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.USER_LIMIT_REACHED = USER_LIMIT_REACHED;
const data: ConnectionClosedData = { endTime: 0, reason: USER_LIMIT_REACHED, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'The server has reached its maximum user capacity'
);
});
});
describe('TOO_MANY_CONNECTIONS', () => {
it('should call SessionCommands.updateStatus', () => {
const TOO_MANY_CONNECTIONS = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.TOO_MANY_CONNECTIONS = TOO_MANY_CONNECTIONS;
const data: ConnectionClosedData = { endTime: 0, reason: TOO_MANY_CONNECTIONS, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'There are too many concurrent connections from your address'
);
});
});
describe('BANNED', () => {
it('should call SessionCommands.updateStatus', () => {
const BANNED = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.BANNED = BANNED;
const data: ConnectionClosedData = { endTime: 0, reason: BANNED, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'You are banned'
);
});
});
describe('DEMOTED', () => {
it('should call SessionCommands.updateStatus', () => {
const DEMOTED = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.DEMOTED = DEMOTED;
const data: ConnectionClosedData = { endTime: 0, reason: DEMOTED, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'You were demoted'
);
});
});
describe('SERVER_SHUTDOWN', () => {
it('should call SessionCommands.updateStatus', () => {
const SERVER_SHUTDOWN = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.SERVER_SHUTDOWN = SERVER_SHUTDOWN;
const data: ConnectionClosedData = { endTime: 0, reason: SERVER_SHUTDOWN, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'Scheduled server shutdown'
);
});
});
describe('USERNAMEINVALID', () => {
it('should call SessionCommands.updateStatus', () => {
const USERNAMEINVALID = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.USERNAMEINVALID = USERNAMEINVALID;
const data: ConnectionClosedData = { endTime: 0, reason: USERNAMEINVALID, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'Invalid username'
);
});
});
describe('LOGGEDINELSEWERE', () => {
it('should call SessionCommands.updateStatus', () => {
const LOGGEDINELSEWERE = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.LOGGEDINELSEWERE = LOGGEDINELSEWERE;
const data: ConnectionClosedData = { endTime: 0, reason: LOGGEDINELSEWERE, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'You have been logged out due to logging in at another location'
);
});
});
describe('OTHER', () => {
it('should call SessionCommands.updateStatus', () => {
const OTHER = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.OTHER = OTHER;
const data: ConnectionClosedData = { endTime: 0, reason: OTHER, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'Unknown reason'
);
});
});
describe('UNKNOWN', () => {
it('should call SessionCommands.updateStatus', () => {
const UNKNOWN = 1;
webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.UNKNOWN = UNKNOWN;
const data: ConnectionClosedData = { endTime: 0, reason: UNKNOWN, reasonStr: null };
SessionEvents['.Event_ConnectionClosed.ext'](data);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
'Unknown reason'
);
});
});
});
});
describe('.Event_ListRooms.ext', () => {
beforeEach(() => {
webClient.clientOptions.autojoinrooms = false;
jest.spyOn(RoomPersistence, 'updateRooms').mockImplementation(() => {});
});
it('should call RoomPersistence.updateRooms', () => {
const data: ListRoomsData = { roomList: [{ roomId, autoJoin: false } as any] };
SessionEvents['.Event_ListRooms.ext'](data);
expect(RoomPersistence.updateRooms).toHaveBeenCalledWith(data.roomList);
});
it('should call SessionCommands.joinRoom if webClient and room is configured for autojoin', () => {
webClient.clientOptions.autojoinrooms = true;
jest.spyOn(SessionCommands, 'joinRoom').mockImplementation(() => {});
const data: ListRoomsData = { roomList: [{ roomId, autoJoin: true } as any, { roomId: 2, autoJoin: false } as any] };
SessionEvents['.Event_ListRooms.ext'](data);
expect(SessionCommands.joinRoom).toHaveBeenCalledTimes(1);
expect(SessionCommands.joinRoom).toHaveBeenCalledWith(data.roomList[0].roomId);
});
});
describe('.Event_RemoveFromList.ext', () => {
it('should call SessionPersistence.removeFromBuddyList if buddy listName', () => {
jest.spyOn(SessionPersistence, 'removeFromBuddyList').mockImplementation(() => {});
const data: RemoveFromListData = { listName: 'buddy', userName: '' };
SessionEvents['.Event_RemoveFromList.ext'](data);
expect(SessionPersistence.removeFromBuddyList).toHaveBeenCalledWith(
data.userName
);
});
it('should call SessionPersistence.removeFromIgnoreList if ignore listName', () => {
jest.spyOn(SessionPersistence, 'removeFromIgnoreList').mockImplementation(() => {});
const data: RemoveFromListData = { listName: 'ignore', userName: '' };
SessionEvents['.Event_RemoveFromList.ext'](data);
expect(SessionPersistence.removeFromIgnoreList).toHaveBeenCalledWith(
data.userName
);
});
it('should call console.log if unknown listName', () => {
jest.spyOn(console, 'log').mockImplementation(() => {});
const data: RemoveFromListData = { listName: 'unknown', userName: '' };
SessionEvents['.Event_RemoveFromList.ext'](data);
expect(console.log).toHaveBeenCalledWith(
`Attempted to remove from unknown list: ${data.listName}`
);
});
});
describe('.Event_ServerIdentification.ext', () => {
let data: ServerIdentificationData;
let event;
beforeEach(() => {
webClient.protocolVersion = 0;
event = SessionEvents['.Event_ServerIdentification.ext'];
data = {
serverName: 'serverName',
serverVersion: 'serverVersion',
protocolVersion: 0,
serverOptions: 0
};
jest.spyOn(SessionPersistence, 'updateInfo').mockImplementation(() => {});
webClient.protobuf.controller.Event_ServerIdentification = { ServerOptions: { SupportsPasswordHash: 1 } };
webClient.options = {};
});
it('update status/info and login', () => {
jest.spyOn(SessionCommands, 'login').mockImplementation(() => {});
webClient.options.reason = WebSocketConnectReason.LOGIN;
event(data);
expect(SessionPersistence.updateInfo).toHaveBeenCalledWith(data.serverName, data.serverVersion);
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(StatusEnum.LOGGING_IN, expect.any(String));
expect(SessionCommands.login).toHaveBeenCalled();
});
it('should update stat/info and register', () => {
jest.spyOn(SessionCommands, 'register').mockImplementation(() => {});
webClient.options.reason = WebSocketConnectReason.REGISTER;
event(data);
expect(SessionPersistence.updateInfo).toHaveBeenCalledWith(data.serverName, data.serverVersion);
expect(SessionCommands.register).toHaveBeenCalled();
});
it('should update stat/info and activate account', () => {
jest.spyOn(SessionCommands, 'activate').mockImplementation(() => {});
webClient.options.reason = WebSocketConnectReason.ACTIVATE_ACCOUNT;
event(data);
expect(SessionPersistence.updateInfo).toHaveBeenCalledWith(data.serverName, data.serverVersion);
expect(SessionCommands.activate).toHaveBeenCalled();
});
it('should disconnect if protocolVersion mismatched', () => {
jest.spyOn(SessionCommands, 'login').mockImplementation(() => {});
jest.spyOn(SessionCommands, 'disconnect').mockImplementation(() => {});
webClient.protocolVersion = 0;
const data: ServerIdentificationData = {
serverName: '',
serverVersion: '',
protocolVersion: 1,
serverOptions: 0
};
event(data);
expect(SessionCommands.disconnect).toHaveBeenCalled();
expect(SessionCommands.updateStatus).toHaveBeenCalledWith(
StatusEnum.DISCONNECTED,
`Protocol version mismatch: ${data.protocolVersion}`
);
expect(SessionCommands.login).not.toHaveBeenCalled();
});
});
describe('.Event_ServerMessage.ext', () => {
it('should call SessionPersistence.serverMessage', () => {
jest.spyOn(SessionPersistence, 'serverMessage').mockImplementation(() => {});
const data: ServerMessageData = { message: 'message' };
SessionEvents['.Event_ServerMessage.ext'](data);
expect(SessionPersistence.serverMessage).toHaveBeenCalledWith(
data.message
);
});
});
describe('.Event_UserJoined.ext', () => {
it('should call SessionPersistence.userJoined', () => {
jest.spyOn(SessionPersistence, 'userJoined').mockImplementation(() => {});
const data: UserJoinedData = { userInfo: {} as any };
SessionEvents['.Event_UserJoined.ext'](data);
expect(SessionPersistence.userJoined).toHaveBeenCalledWith(
data.userInfo
);
});
});
describe('.Event_UserLeft.ext', () => {
it('should call SessionPersistence.userLeft', () => {
jest.spyOn(SessionPersistence, 'userLeft').mockImplementation(() => {});
const data: UserLeftData = { name: '' };
SessionEvents['.Event_UserLeft.ext'](data);
expect(SessionPersistence.userLeft).toHaveBeenCalledWith(
data.name
);
});
});
});

2
webclient/src/websocket/events/session/addToList.ts
View File

@@ -1,7 +1,7 @@
import { SessionPersistence } from '../../persistence';
import { AddToListData } from './interfaces';
export function addToList({ listName, userInfo }: AddToListData) {
export function addToList({ listName, userInfo }: AddToListData): void {
switch (listName) {
case 'buddy': {
SessionPersistence.addToBuddyList(userInfo);

4
webclient/src/websocket/events/session/connectionClosed.ts
View File

@@ -3,8 +3,8 @@ import webClient from '../../WebClient';
import { updateStatus } from '../../commands/session';
import { ConnectionClosedData } from './interfaces';
export function connectionClosed({ reason, reasonStr }: ConnectionClosedData) {
let message;
export function connectionClosed({ reason, reasonStr }: ConnectionClosedData): void {
let message: string;
// @TODO (5)
if (reasonStr) {

2
webclient/src/websocket/events/session/gameJoined.ts
View File

@@ -1,6 +1,6 @@
import { SessionPersistence } from '../../persistence';
import { GameJoinedData } from './interfaces';
export function gameJoined(gameJoined: GameJoinedData) {
export function gameJoined(gameJoined: GameJoinedData): void {
SessionPersistence.gameJoined(gameJoined);
}

48
webclient/src/websocket/events/session/interfaces.ts
View File

@@ -1,8 +1,4 @@
import { Game, Room, User } from 'types';
export interface SessionEvent {
sessionEvent: {}
}
import { Game, NotificationType, Room, User } from 'types';
export interface AddToListData {
listName: string;
@@ -15,10 +11,37 @@ export interface ConnectionClosedData {
reasonStr: string;
}
export interface GameJoinedData {
gameInfo: Game;
playerId: number;
spectator: boolean;
resuming: boolean;
judge: boolean;
}
export interface ListRoomsData {
roomList: Room[];
}
export interface NotifyUserData {
type: NotificationType;
warningReason: string;
customTitle: string;
customContent: string;
}
export interface PlayerGamePropertiesData {
playerId: number;
userInfo: User;
spectator: boolean;
conceded: boolean;
readyStart: boolean;
deckHash: string;
pingSeconds: number;
sideboardLocked: boolean;
judge: boolean;
}
export interface RemoveFromListData {
listName: string;
userName: string;
@@ -35,6 +58,11 @@ export interface ServerMessageData {
message: string;
}
export interface ServerShutdownData {
reason: string;
minutes: number;
}
export interface UserJoinedData {
userInfo: User;
}
@@ -43,10 +71,8 @@ export interface UserLeftData {
name: string;
}
export interface GameJoinedData {
gameInfo: Game;
playerId: number;
spectator: boolean;
resuming: boolean;
judge: boolean;
export interface UserMessageData {
senderName: string;
receiverName: string;
message: string;
}

2
webclient/src/websocket/events/session/listRooms.ts
View File

@@ -3,7 +3,7 @@ import { joinRoom } from '../../commands/session';
import { RoomPersistence } from '../../persistence';
import { ListRoomsData } from './interfaces';
export function listRooms({ roomList }: ListRoomsData) {
export function listRooms({ roomList }: ListRoomsData): void {
RoomPersistence.updateRooms(roomList);
if (webClient.clientOptions.autojoinrooms) {

8
webclient/src/websocket/events/session/notifyUser.ts
View File

@@ -1,3 +1,7 @@
export function notifyUser(payload) {
console.info('Event_NotifyUser', payload);
import { SessionPersistence } from '../../persistence';
import { NotifyUserData } from './interfaces';
export function notifyUser(payload: NotifyUserData): void {
SessionPersistence.notifyUser(payload);
}

7
webclient/src/websocket/events/session/playerPropertiesChanges.ts
View File

@@ -1,3 +1,6 @@
export function playerPropertiesChanges(payload) {
console.info('Event_PlayerPropertiesChanges', payload);
import { PlayerGamePropertiesData } from './interfaces';
import { SessionPersistence } from '../../persistence';
export function playerPropertiesChanges(payload: PlayerGamePropertiesData): void {
SessionPersistence.playerPropertiesChanged(payload);
}

2
webclient/src/websocket/events/session/removeFromList.ts
View File

@@ -1,7 +1,7 @@
import { SessionPersistence } from '../../persistence';
import { RemoveFromListData } from './interfaces';
export function removeFromList({ listName, userName }: RemoveFromListData) {
export function removeFromList({ listName, userName }: RemoveFromListData): void {
switch (listName) {
case 'buddy': {
SessionPersistence.removeFromBuddyList(userName);

2
webclient/src/websocket/events/session/serverIdentification.ts
View File

@@ -16,7 +16,7 @@ import { generateSalt, passwordSaltSupported } from '../../utils';
import { ServerIdentificationData } from './interfaces';
import { SessionPersistence } from '../../persistence';
export function serverIdentification(info: ServerIdentificationData) {
export function serverIdentification(info: ServerIdentificationData): void {
const { serverName, serverVersion, protocolVersion, serverOptions } = info;
if (protocolVersion !== webClient.protocolVersion) {
updateStatus(StatusEnum.DISCONNECTED, `Protocol version mismatch: ${protocolVersion}`);

2
webclient/src/websocket/events/session/serverMessage.ts
View File

@@ -1,6 +1,6 @@
import { SessionPersistence } from '../../persistence';
import { ServerMessageData } from './interfaces';
export function serverMessage({ message }: ServerMessageData) {
export function serverMessage({ message }: ServerMessageData): void {
SessionPersistence.serverMessage(message);
}

8
webclient/src/websocket/events/session/serverShutdown.ts
View File

@@ -1,3 +1,7 @@
export function serverShutdown(payload) {
console.info('Event_ServerShutdown', payload);
import { SessionPersistence } from '../../persistence';
import { ServerShutdownData } from './interfaces';
export function serverShutdown(payload: ServerShutdownData): void {
SessionPersistence.serverShutdown(payload);
}

2
webclient/src/websocket/events/session/userJoined.ts
View File

@@ -1,6 +1,6 @@
import { SessionPersistence } from '../../persistence';
import { UserJoinedData } from './interfaces';
export function userJoined({ userInfo }: UserJoinedData) {
export function userJoined({ userInfo }: UserJoinedData): void {
SessionPersistence.userJoined(userInfo);
}

2
webclient/src/websocket/events/session/userLeft.ts
View File

@@ -1,6 +1,6 @@
import { SessionPersistence } from '../../persistence';
import { UserLeftData } from './interfaces';
export function userLeft({ name }: UserLeftData) {
export function userLeft({ name }: UserLeftData): void {
SessionPersistence.userLeft(name);
}

9
webclient/src/websocket/events/session/userMessage.ts
View File

@@ -1,3 +1,8 @@
export function userMessage(payload) {
console.info('Event_UserMessage', payload);
import { SessionPersistence } from '../../persistence';
import { UserMessageData } from './interfaces';
export function userMessage(payload: UserMessageData): void {
SessionPersistence.userMessage(payload);
}

40
webclient/src/websocket/persistence/SessionPersistence.ts
View File

@@ -1,9 +1,15 @@
import { ServerDispatch } from 'store';
import { Log, StatusEnum, User, WebSocketConnectOptions } from 'types';
import { StatusEnum, User, WebSocketConnectOptions } from 'types';
import { sanitizeHtml } from 'websocket/utils';
import {
GameJoinedData,
NotifyUserData,
PlayerGamePropertiesData,
ServerShutdownData,
UserMessageData
} from '../events/session/interfaces';
import NormalizeService from '../utils/NormalizeService';
import { GameJoinedData } from '../events/session/interfaces';
export class SessionPersistence {
static initialized() {
@@ -114,8 +120,10 @@ export class SessionPersistence {
ServerDispatch.registrationSuccess();
}
static registrationFailed(error: string) {
ServerDispatch.registrationFailed(error);
static registrationFailed(reason: string, endTime?: number) {
const reasonMsg = endTime ? NormalizeService.normalizeBannedUserError(reason, endTime) : reason;
ServerDispatch.registrationFailed(reasonMsg);
}
static registrationEmailError(error: string) {
@@ -173,4 +181,28 @@ export class SessionPersistence {
static gameJoined(gameJoinedData: GameJoinedData): void {
console.log('gameJoined', gameJoinedData);
}
static notifyUser(payload: NotifyUserData): void {
console.log('notifyUser', payload);
}
static playerPropertiesChanged(payload: PlayerGamePropertiesData): void {
console.log('playerPropertiesChanged', payload);
}
static serverShutdown(payload: ServerShutdownData): void {
console.log('serverShutdown', payload);
}
static userMessage(payload: UserMessageData): void {
console.log('userMessage', payload);
}
static addToList(list: string, userName: string): void {
console.log('addToList', list, userName);
}
static removeFromList(list: string, userName: string): void {
console.log('removeFromList', list, userName);
}
}