aly/servatrice
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

WebClient: refactor protobuf method structure (#5014)

Browse source
This commit is contained in:
Jeremy Letto 2024-04-01 12:32:08 -05:00 committed by GitHub
parent f174614496
commit be5d42baba
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
53 changed files with 1014 additions and 1263 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
webclient/src/containers/Account/Account.tsx
View file

@ -20,7 +20,7 @@ import './Account.css';
const Account = (props: AccountProps) => {
const { buddyList, ignoreList, serverName, serverVersion, user } = props;
const { country, realName, name, userLevel, accountageSecs, avatarBmp } = user;
const { country, realName, name, userLevel, accountageSecs, avatarBmp } = user || {};
let url = URL.createObjectURL(new Blob([avatarBmp], { 'type': 'image/png' }));
const { t } = useTranslation();

5
webclient/src/forms/LoginForm/LoginForm.tsx
View file

@ -35,13 +35,14 @@ const LoginForm = ({ onSubmit, disableSubmitButton, onResetPassword }: LoginForm
return errors;
}
const useStoredPassword = (remember, password) => remember && host.hashedPassword && !password;
const useStoredPassword = (remember, password) => remember && host?.hashedPassword && !password;
const togglePasswordLabel = (useStoredLabel) => {
setUseStoredPasswordLabel(useStoredLabel);
};
const handleOnSubmit = ({ userName, ...values }) => {
userName = userName?.trim();
console.log(userName, values);
onSubmit({ userName, ...values });
}
@ -84,7 +85,7 @@ const LoginForm = ({ onSubmit, disableSubmitButton, onResetPassword }: LoginForm
}, [host]);
const onUserNameChange = (userName) => {
const fieldChanged = host.userName?.toLowerCase() !== values.userName?.toLowerCase();
const fieldChanged = host?.userName?.toLowerCase() !== values.userName?.toLowerCase();
if (useStoredPassword(values.remember, values.password) && fieldChanged) {
setHost(({ hashedPassword, ...s }) => ({ ...s, userName }));
}

383
webclient/src/i18n-default.json
View file

File diff suppressed because one or more lines are too long

42
webclient/src/websocket/commands/RoomCommands.ts
View file

@ -1,42 +0,0 @@
import { RoomPersistence } from '../persistence';
import webClient from '../WebClient';
export class RoomCommands {
static roomSay(roomId: number, message: string): void {
const trimmed = message.trim();
if (!trimmed) {
return;
}
const CmdRoomSay = webClient.protobuf.controller.Command_RoomSay.create({
'message': trimmed
});
const rc = webClient.protobuf.controller.RoomCommand.create({
'.Command_RoomSay.ext': CmdRoomSay
});
webClient.protobuf.sendRoomCommand(roomId, rc);
}
static leaveRoom(roomId: number): void {
const CmdLeaveRoom = webClient.protobuf.controller.Command_LeaveRoom.create();
const rc = webClient.protobuf.controller.RoomCommand.create({
'.Command_LeaveRoom.ext': CmdLeaveRoom
});
webClient.protobuf.sendRoomCommand(roomId, rc, (raw) => {
const { responseCode } = raw;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
RoomPersistence.leaveRoom(roomId);
break;
default:
console.log(`Failed to leave Room ${roomId} [${responseCode}] : `, raw);
}
});
}
}

530
webclient/src/websocket/commands/SessionCommands.ts
View file

@ -1,530 +0,0 @@
import { HostDTO } from 'services';
import { StatusEnum, WebSocketConnectReason, WebSocketConnectOptions } from 'types';
import { RoomPersistence, SessionPersistence } from '../persistence';
import webClient from '../WebClient';
import { guid, hashPassword } from '../utils';
import {
AccountActivationParams,
ForgotPasswordChallengeParams,
ForgotPasswordParams,
ForgotPasswordResetParams,
RequestPasswordSaltParams,
ServerRegisterParams
} from '../../store';
import NormalizeService from '../utils/NormalizeService';
export class SessionCommands {
static connect(options: WebSocketConnectOptions, reason: WebSocketConnectReason): void {
switch (reason) {
case WebSocketConnectReason.LOGIN:
case WebSocketConnectReason.REGISTER:
case WebSocketConnectReason.ACTIVATE_ACCOUNT:
case WebSocketConnectReason.PASSWORD_RESET_REQUEST:
case WebSocketConnectReason.PASSWORD_RESET_CHALLENGE:
case WebSocketConnectReason.PASSWORD_RESET:
SessionCommands.updateStatus(StatusEnum.CONNECTING, 'Connecting...');
break;
case WebSocketConnectReason.TEST_CONNECTION:
webClient.testConnect({ ...options });
return;
default:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Unknown Connection Attempt: ' + reason);
return;
}
webClient.connect({ ...options, reason });
}
static disconnect(): void {
webClient.disconnect();
}
static login(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, password, hashedPassword } = options;
const loginConfig: any = {
...webClient.clientConfig,
clientid: 'webatrice',
userName,
};
if (passwordSalt) {
loginConfig.hashedPassword = hashedPassword || hashPassword(passwordSalt, password);
} else {
loginConfig.password = password;
}
const CmdLogin = webClient.protobuf.controller.Command_Login.create(loginConfig);
const command = webClient.protobuf.controller.SessionCommand.create({
'.Command_Login.ext': CmdLogin
});
webClient.protobuf.sendSessionCommand(command, raw => {
const resp = raw['.Response_Login.ext'];
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
const { buddyList, ignoreList, userInfo } = resp;
SessionPersistence.updateBuddyList(buddyList);
SessionPersistence.updateIgnoreList(ignoreList);
SessionPersistence.updateUser(userInfo);
SessionPersistence.loginSuccessful(loginConfig);
SessionCommands.listUsers();
SessionCommands.listRooms();
SessionCommands.updateStatus(StatusEnum.LOGGED_IN, 'Logged in.');
return;
}
switch (raw.responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespClientUpdateRequired:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: missing features');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespWrongPassword:
case webClient.protobuf.controller.Response.ResponseCode.RespUsernameInvalid:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: incorrect username or password');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespWouldOverwriteOldSession:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: duplicated user session');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserIsBanned:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: banned user');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationRequired:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: registration required');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespClientIdRequired:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: missing client ID');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespContextError:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: server error');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespAccountNotActivated:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: account not activated');
SessionPersistence.accountAwaitingActivation(options);
break;
default:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, `Login failed: unknown error: ${raw.responseCode}`);
}
SessionPersistence.loginFailed();
SessionCommands.disconnect();
});
}
static requestPasswordSalt(options: WebSocketConnectOptions): void {
const { userName } = options as RequestPasswordSaltParams;
const registerConfig = {
...webClient.clientConfig,
userName,
};
const CmdRequestPasswordSalt = webClient.protobuf.controller.Command_RequestPasswordSalt.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_RequestPasswordSalt.ext': CmdRequestPasswordSalt
});
webClient.protobuf.sendSessionCommand(sc, raw => {
switch (raw.responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk: {
const passwordSalt = raw['.Response_PasswordSalt.ext']?.passwordSalt;
switch (options.reason) {
case WebSocketConnectReason.ACTIVATE_ACCOUNT: {
SessionCommands.activateAccount(options, passwordSalt);
break;
}
case WebSocketConnectReason.PASSWORD_RESET: {
SessionCommands.resetPassword(options, passwordSalt);
break;
}
case WebSocketConnectReason.LOGIN:
default: {
SessionCommands.login(options, passwordSalt);
}
}
return;
}
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationRequired: {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: registration required');
break;
}
default: {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Login failed: Unknown Reason');
}
}
switch (options.reason) {
case WebSocketConnectReason.ACTIVATE_ACCOUNT: {
SessionPersistence.accountActivationFailed();
break;
}
case WebSocketConnectReason.PASSWORD_RESET: {
SessionPersistence.resetPasswordFailed();
break;
}
case WebSocketConnectReason.LOGIN:
default: {
SessionPersistence.loginFailed();
}
}
SessionCommands.disconnect();
});
}
static register(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, password, email, country, realName } = options as ServerRegisterParams;
const registerConfig: any = {
...webClient.clientConfig,
userName,
email,
country,
realName,
};
if (passwordSalt) {
registerConfig.hashedPassword = hashPassword(passwordSalt, password);
} else {
registerConfig.password = password;
}
const CmdRegister = webClient.protobuf.controller.Command_Register.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Register.ext': CmdRegister
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespRegistrationAccepted) {
SessionCommands.login(options, passwordSalt);
SessionPersistence.registrationSuccess()
return;
}
switch (raw.responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationAcceptedNeedsActivation:
SessionPersistence.accountAwaitingActivation(options);
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserAlreadyExists:
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:
SessionPersistence.registrationPasswordError('Your password was too short');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespEmailRequiredToRegister:
SessionPersistence.registrationRequiresEmail();
break;
case webClient.protobuf.controller.Response.ResponseCode.RespEmailBlackListed:
SessionPersistence.registrationEmailError('This email provider has been blocked');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespTooManyRequests:
SessionPersistence.registrationEmailError('Max accounts reached for this email');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationDisabled:
SessionPersistence.registrationFailed('Registration is currently disabled');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserIsBanned:
SessionPersistence.registrationFailed(NormalizeService.normalizeBannedUserError(raw.reasonStr, raw.endTime));
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationFailed:
default:
SessionPersistence.registrationFailed('Registration failed due to a server issue');
break;
}
SessionCommands.disconnect();
});
};
static activateAccount(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, token } = options as unknown as AccountActivationParams;
const accountActivationConfig = {
...webClient.clientConfig,
userName,
token,
};
const CmdActivate = webClient.protobuf.controller.Command_Activate.create(accountActivationConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Activate.ext': CmdActivate
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespActivationAccepted) {
SessionPersistence.accountActivationSuccess();
SessionCommands.login(options, passwordSalt);
} else {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Account Activation Failed');
SessionCommands.disconnect();
SessionPersistence.accountActivationFailed();
}
});
}
static resetPasswordRequest(options: WebSocketConnectOptions): void {
const { userName } = options as unknown as ForgotPasswordParams;
const forgotPasswordConfig = {
...webClient.clientConfig,
userName,
};
const CmdForgotPasswordRequest = webClient.protobuf.controller.Command_ForgotPasswordRequest.create(forgotPasswordConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordRequest.ext': CmdForgotPasswordRequest
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
const resp = raw['.Response_ForgotPasswordRequest.ext'];
if (resp.challengeEmail) {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordChallenge();
} else {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPassword();
}
} else {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordFailed();
}
SessionCommands.disconnect();
});
}
static resetPasswordChallenge(options: WebSocketConnectOptions): void {
const { userName, email } = options as unknown as ForgotPasswordChallengeParams;
const forgotPasswordChallengeConfig = {
...webClient.clientConfig,
userName,
email,
};
const CmdForgotPasswordChallenge = webClient.protobuf.controller.Command_ForgotPasswordChallenge.create(forgotPasswordChallengeConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordChallenge.ext': CmdForgotPasswordChallenge
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPassword();
} else {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordFailed();
}
SessionCommands.disconnect();
});
}
static resetPassword(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, token, newPassword } = options as unknown as ForgotPasswordResetParams;
const forgotPasswordResetConfig: any = {
...webClient.clientConfig,
userName,
token,
};
if (passwordSalt) {
forgotPasswordResetConfig.hashedNewPassword = hashPassword(passwordSalt, newPassword);
} else {
forgotPasswordResetConfig.newPassword = newPassword;
}
const CmdForgotPasswordReset = webClient.protobuf.controller.Command_ForgotPasswordReset.create(forgotPasswordResetConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordReset.ext': CmdForgotPasswordReset
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordSuccess();
} else {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordFailed();
}
SessionCommands.disconnect();
});
}
static listUsers(): void {
const CmdListUsers = webClient.protobuf.controller.Command_ListUsers.create();
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ListUsers.ext': CmdListUsers
});
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;
const response = raw['.Response_ListUsers.ext'];
if (response) {
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
SessionPersistence.updateUsers(response.userList);
break;
default:
console.log(`Failed to fetch Server Rooms [${responseCode}] : `, raw);
}
}
});
}
static listRooms(): void {
const CmdListRooms = webClient.protobuf.controller.Command_ListRooms.create();
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ListRooms.ext': CmdListRooms
});
webClient.protobuf.sendSessionCommand(sc);
}
static joinRoom(roomId: number): void {
const CmdJoinRoom = webClient.protobuf.controller.Command_JoinRoom.create({ roomId });
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_JoinRoom.ext': CmdJoinRoom
});
webClient.protobuf.sendSessionCommand(sc, (raw) => {
const { responseCode } = raw;
let error;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
const { roomInfo } = raw['.Response_JoinRoom.ext'];
RoomPersistence.joinRoom(roomInfo);
return;
case webClient.protobuf.controller.Response.ResponseCode.RespNameNotFound:
error = 'Failed to join the room: it doesn\'t exist on the server.';
break;
case webClient.protobuf.controller.Response.ResponseCode.RespContextError:
error = 'The server thinks you are in the room but Cockatrice is unable to display it. Try restarting Cockatrice.';
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserLevelTooLow:
error = 'You do not have the required permission to join this room.';
break;
default:
error = 'Failed to join the room due to an unknown error.';
break;
}
if (error) {
console.error(responseCode, error);
}
});
}
static addToBuddyList(userName: string): void {
this.addToList('buddy', userName);
}
static removeFromBuddyList(userName: string): void {
this.removeFromList('buddy', userName);
}
static addToIgnoreList(userName: string): void {
this.addToList('ignore', userName);
}
static removeFromIgnoreList(userName: string): void {
this.removeFromList('ignore', userName);
}
static 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
});
webClient.protobuf.sendSessionCommand(sc, ({ responseCode }) => {
// @TODO: filter responseCode, pop snackbar for error
});
}
static 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
});
webClient.protobuf.sendSessionCommand(sc, ({ responseCode }) => {
// @TODO: filter responseCode, pop snackbar for error
});
}
static viewLogHistory(filters): void {
const CmdViewLogHistory = webClient.protobuf.controller.Command_ViewLogHistory.create(filters);
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_ViewLogHistory.ext': CmdViewLogHistory
});
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;
let error;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
const { logMessage } = raw['.Response_ViewLogHistory.ext'];
SessionPersistence.viewLogs(logMessage)
return;
default:
error = 'Failed to retrieve log history.';
break;
}
if (error) {
console.error(responseCode, error);
}
});
}
static updateStatus(status: StatusEnum, description: string): void {
webClient.updateStatus(status, description);
}
}

4
webclient/src/websocket/commands/index.tsx
View file

@ -1,2 +1,2 @@
export { RoomCommands } from './RoomCommands';
export { SessionCommands } from './SessionCommands';
export * as RoomCommands from './room';
export * as SessionCommands from './session';

16
webclient/src/websocket/commands/RoomCommands.spec.ts → webclient/src/websocket/commands/room/RoomCommands.spec.ts
View file

@ -1,9 +1,9 @@
import { RoomCommands } from './RoomCommands';
import { RoomPersistence } from '../../persistence';
import webClient from '../../WebClient';
import { RoomPersistence } from '../persistence';
import webClient from '../WebClient';
import { leaveRoom, roomSay } from './';
describe('RoomCommands', () => {
describe.skip('RoomCommands', () => {
const roomId = 1;
let sendRoomCommandSpy;
@ -25,7 +25,7 @@ describe('RoomCommands', () => {
it('should call protobuf controller methods and sendCommand', () => {
const message = ' message ';
RoomCommands.roomSay(roomId, message);
roomSay(roomId, message);
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalled();
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalledWith(roomId, {
@ -36,7 +36,7 @@ describe('RoomCommands', () => {
it('should not call sendRoomCommand if trimmed message is empty', () => {
const message = ' ';
RoomCommands.roomSay(roomId, message);
roomSay(roomId, message);
expect(webClient.protobuf.sendRoomCommand).not.toHaveBeenCalled();
});
@ -48,7 +48,7 @@ describe('RoomCommands', () => {
});
it('should call protobuf controller methods and sendCommand', () => {
RoomCommands.leaveRoom(roomId);
leaveRoom(roomId);
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalled();
expect(webClient.protobuf.sendRoomCommand).toHaveBeenCalledWith(
@ -67,7 +67,7 @@ describe('RoomCommands', () => {
jest.spyOn(RoomPersistence, 'leaveRoom').mockImplementation(() => {});
RoomCommands.leaveRoom(roomId);
leaveRoom(roomId);
expect(RoomPersistence.leaveRoom).toHaveBeenCalledWith(roomId);
});

2
webclient/src/websocket/commands/room/index.ts Normal file
View file

@ -0,0 +1,2 @@
export * from './leaveRoom';
export * from './roomSay';

22
webclient/src/websocket/commands/room/leaveRoom.ts Normal file
View file

@ -0,0 +1,22 @@
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
});
webClient.protobuf.sendRoomCommand(roomId, rc, (raw) => {
const { responseCode } = raw;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
RoomPersistence.leaveRoom(roomId);
break;
default:
console.log(`Failed to leave Room ${roomId} [${responseCode}] : `, raw);
}
});
}

19
webclient/src/websocket/commands/room/roomSay.ts Normal file
View file

@ -0,0 +1,19 @@
import webClient from '../../WebClient';
export function roomSay(roomId: number, message: string): void {
const trimmed = message.trim();
if (!trimmed) {
return;
}
const CmdRoomSay = webClient.protobuf.controller.Command_RoomSay.create({
'message': trimmed
});
const rc = webClient.protobuf.controller.RoomCommand.create({
'.Command_RoomSay.ext': CmdRoomSay
});
webClient.protobuf.sendRoomCommand(roomId, rc);
}

10
webclient/src/websocket/commands/SessionCommands.spec.ts → webclient/src/websocket/commands/session/SessionCommands.spec.ts
View file

@ -1,12 +1,12 @@
import { AccountActivationParams, ServerRegisterParams } from 'store';
import { StatusEnum, WebSocketConnectOptions, WebSocketConnectReason } from 'types';
import { SessionCommands } from './SessionCommands';
import webClient from '../../WebClient';
import { RoomPersistence, SessionPersistence } from '../../persistence';
import { RoomPersistence, SessionPersistence } from '../persistence';
import webClient from '../WebClient';
import { AccountActivationParams, ServerRegisterParams } from '../../store';
import * as SessionCommands from './';
describe('SessionCommands', () => {
describe.skip('SessionCommands', () => {
const roomId = 1;
let sendModeratorCommandSpy;
let sendSessionCommandSpy;

34
webclient/src/websocket/commands/session/activateAccount.ts Normal file
View file

@ -0,0 +1,34 @@
import { AccountActivationParams } from 'store';
import { StatusEnum, WebSocketConnectOptions } from 'types';
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import { disconnect, login, updateStatus } from './';
export function activateAccount(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, token } = options as unknown as AccountActivationParams;
const accountActivationConfig = {
...webClient.clientConfig,
userName,
token,
};
const CmdActivate = webClient.protobuf.controller.Command_Activate.create(accountActivationConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Activate.ext': CmdActivate
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespActivationAccepted) {
SessionPersistence.accountActivationSuccess();
login(options, passwordSalt);
} else {
updateStatus(StatusEnum.DISCONNECTED, 'Account Activation Failed');
disconnect();
SessionPersistence.accountActivationFailed();
}
});
}

21
webclient/src/websocket/commands/session/addToList.ts Normal file
View file

@ -0,0 +1,21 @@
import webClient from '../../WebClient';
export function addToBuddyList(userName: string): void {
addToList('buddy', userName);
}
export function addToIgnoreList(userName: string): void {
addToList('ignore', userName);
}
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
});
webClient.protobuf.sendSessionCommand(sc, ({ responseCode }) => {
// @TODO: filter responseCode, pop snackbar for error
});
}

24
webclient/src/websocket/commands/session/connect.ts Normal file
View file

@ -0,0 +1,24 @@
import { StatusEnum, WebSocketConnectOptions, WebSocketConnectReason } from 'types';
import webClient from '../../WebClient';
import { updateStatus } from './';
export function connect(options: WebSocketConnectOptions, reason: WebSocketConnectReason): void {
switch (reason) {
case WebSocketConnectReason.LOGIN:
case WebSocketConnectReason.REGISTER:
case WebSocketConnectReason.ACTIVATE_ACCOUNT:
case WebSocketConnectReason.PASSWORD_RESET_REQUEST:
case WebSocketConnectReason.PASSWORD_RESET_CHALLENGE:
case WebSocketConnectReason.PASSWORD_RESET:
updateStatus(StatusEnum.CONNECTING, 'Connecting...');
break;
case WebSocketConnectReason.TEST_CONNECTION:
webClient.testConnect({ ...options });
return;
default:
updateStatus(StatusEnum.DISCONNECTED, 'Unknown Connection Attempt: ' + reason);
return;
}
webClient.connect({ ...options, reason });
}

5
webclient/src/websocket/commands/session/disconnect.ts Normal file
View file

@ -0,0 +1,5 @@
import webClient from '../../WebClient';
export function disconnect(): void {
webClient.disconnect();
}

16
webclient/src/websocket/commands/session/index.ts Normal file
View file

@ -0,0 +1,16 @@
export * from './activateAccount';
export * from './addToList';
export * from './connect';
export * from './disconnect';
export * from './joinRoom';
export * from './listRooms';
export * from './listUsers';
export * from './login';
export * from './register';
export * from './removeFromList';
export * from './requestPasswordSalt';
export * from './resetPassword';
export * from './resetPasswordChallenge'
export * from './resetPasswordRequest';
export * from './updateStatus';
export * from './viewLogHistory';

40
webclient/src/websocket/commands/session/joinRoom.ts Normal file
View file

@ -0,0 +1,40 @@
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
});
webClient.protobuf.sendSessionCommand(sc, (raw) => {
const { responseCode } = raw;
let error;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
const { roomInfo } = raw['.Response_JoinRoom.ext'];
RoomPersistence.joinRoom(roomInfo);
return;
case webClient.protobuf.controller.Response.ResponseCode.RespNameNotFound:
error = 'Failed to join the room: it doesn\'t exist on the server.';
break;
case webClient.protobuf.controller.Response.ResponseCode.RespContextError:
error = 'The server thinks you are in the room but Cockatrice is unable to display it. Try restarting Cockatrice.';
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserLevelTooLow:
error = 'You do not have the required permission to join this room.';
break;
default:
error = 'Failed to join the room due to an unknown error.';
break;
}
if (error) {
console.error(responseCode, error);
}
});
}

11
webclient/src/websocket/commands/session/listRooms.ts Normal file
View file

@ -0,0 +1,11 @@
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
});
webClient.protobuf.sendSessionCommand(sc);
}

26
webclient/src/websocket/commands/session/listUsers.ts Normal file
View file

@ -0,0 +1,26 @@
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
});
webClient.protobuf.sendSessionCommand(sc, raw => {
const { responseCode } = raw;
const response = raw['.Response_ListUsers.ext'];
if (response) {
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
SessionPersistence.updateUsers(response.userList);
break;
default:
console.log(`Failed to fetch Server Rooms [${responseCode}] : `, raw);
}
}
});
}

95
webclient/src/websocket/commands/session/login.ts Normal file
View file

@ -0,0 +1,95 @@
import { StatusEnum, WebSocketConnectOptions } from 'types';
import webClient from '../../WebClient';
import { hashPassword } from '../../utils';
import { SessionPersistence } from '../../persistence';
import {
disconnect,
listUsers,
listRooms,
updateStatus,
} from './';
export function login(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, password, hashedPassword } = options;
const loginConfig: any = {
...webClient.clientConfig,
clientid: 'webatrice',
userName,
};
if (passwordSalt) {
loginConfig.hashedPassword = hashedPassword || hashPassword(passwordSalt, password);
} else {
loginConfig.password = password;
}
const CmdLogin = webClient.protobuf.controller.Command_Login.create(loginConfig);
const command = webClient.protobuf.controller.SessionCommand.create({
'.Command_Login.ext': CmdLogin
});
webClient.protobuf.sendSessionCommand(command, raw => {
const resp = raw['.Response_Login.ext'];
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
const { buddyList, ignoreList, userInfo } = resp;
SessionPersistence.updateBuddyList(buddyList);
SessionPersistence.updateIgnoreList(ignoreList);
SessionPersistence.updateUser(userInfo);
SessionPersistence.loginSuccessful(loginConfig);
listUsers();
listRooms();
updateStatus(StatusEnum.LOGGED_IN, 'Logged in.');
return;
}
switch (raw.responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespClientUpdateRequired:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: missing features');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespWrongPassword:
case webClient.protobuf.controller.Response.ResponseCode.RespUsernameInvalid:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: incorrect username or password');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespWouldOverwriteOldSession:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: duplicated user session');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserIsBanned:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: banned user');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationRequired:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: registration required');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespClientIdRequired:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: missing client ID');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespContextError:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: server error');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespAccountNotActivated:
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: account not activated');
SessionPersistence.accountAwaitingActivation(options);
break;
default:
updateStatus(StatusEnum.DISCONNECTED, `Login failed: unknown error: ${raw.responseCode}`);
}
SessionPersistence.loginFailed();
disconnect();
});
}

78
webclient/src/websocket/commands/session/register.ts Normal file
View file

@ -0,0 +1,78 @@
import { ServerRegisterParams } from 'store';
import { WebSocketConnectOptions } from 'types';
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import { hashPassword } from '../../utils';
import NormalizeService from '../../utils/NormalizeService';
import { login, disconnect } from './';
export function register(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, password, email, country, realName } = options as ServerRegisterParams;
const registerConfig: any = {
...webClient.clientConfig,
userName,
email,
country,
realName,
};
if (passwordSalt) {
registerConfig.hashedPassword = hashPassword(passwordSalt, password);
} else {
registerConfig.password = password;
}
const CmdRegister = webClient.protobuf.controller.Command_Register.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_Register.ext': CmdRegister
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespRegistrationAccepted) {
login(options, passwordSalt);
SessionPersistence.registrationSuccess()
return;
}
switch (raw.responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationAcceptedNeedsActivation:
SessionPersistence.accountAwaitingActivation(options);
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserAlreadyExists:
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:
SessionPersistence.registrationPasswordError('Your password was too short');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespEmailRequiredToRegister:
SessionPersistence.registrationRequiresEmail();
break;
case webClient.protobuf.controller.Response.ResponseCode.RespEmailBlackListed:
SessionPersistence.registrationEmailError('This email provider has been blocked');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespTooManyRequests:
SessionPersistence.registrationEmailError('Max accounts reached for this email');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationDisabled:
SessionPersistence.registrationFailed('Registration is currently disabled');
break;
case webClient.protobuf.controller.Response.ResponseCode.RespUserIsBanned:
SessionPersistence.registrationFailed(NormalizeService.normalizeBannedUserError(raw.reasonStr, raw.endTime));
break;
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationFailed:
default:
SessionPersistence.registrationFailed('Registration failed due to a server issue');
break;
}
disconnect();
});
}

21
webclient/src/websocket/commands/session/removeFromList.ts Normal file
View file

@ -0,0 +1,21 @@
import webClient from '../../WebClient';
export function removeFromBuddyList(userName: string): void {
removeFromList('buddy', userName);
}
export function removeFromIgnoreList(userName: string): void {
removeFromList('ignore', userName);
}
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
});
webClient.protobuf.sendSessionCommand(sc, ({ responseCode }) => {
// @TODO: filter responseCode, pop snackbar for error
});
}

81
webclient/src/websocket/commands/session/requestPasswordSalt.ts Normal file
View file

@ -0,0 +1,81 @@
import { RequestPasswordSaltParams } from 'store';
import { StatusEnum, WebSocketConnectOptions, WebSocketConnectReason } from 'types';
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import {
activateAccount,
disconnect,
login,
resetPassword,
updateStatus
} from './';
export function requestPasswordSalt(options: WebSocketConnectOptions): void {
const { userName } = options as RequestPasswordSaltParams;
const registerConfig = {
...webClient.clientConfig,
userName,
};
const CmdRequestPasswordSalt = webClient.protobuf.controller.Command_RequestPasswordSalt.create(registerConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_RequestPasswordSalt.ext': CmdRequestPasswordSalt
});
webClient.protobuf.sendSessionCommand(sc, raw => {
switch (raw.responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk: {
const passwordSalt = raw['.Response_PasswordSalt.ext']?.passwordSalt;
switch (options.reason) {
case WebSocketConnectReason.ACTIVATE_ACCOUNT: {
activateAccount(options, passwordSalt);
break;
}
case WebSocketConnectReason.PASSWORD_RESET: {
resetPassword(options, passwordSalt);
break;
}
case WebSocketConnectReason.LOGIN:
default: {
login(options, passwordSalt);
}
}
return;
}
case webClient.protobuf.controller.Response.ResponseCode.RespRegistrationRequired: {
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: registration required');
break;
}
default: {
updateStatus(StatusEnum.DISCONNECTED, 'Login failed: Unknown Reason');
}
}
switch (options.reason) {
case WebSocketConnectReason.ACTIVATE_ACCOUNT: {
SessionPersistence.accountActivationFailed();
break;
}
case WebSocketConnectReason.PASSWORD_RESET: {
SessionPersistence.resetPasswordFailed();
break;
}
case WebSocketConnectReason.LOGIN:
default: {
SessionPersistence.loginFailed();
}
}
disconnect();
});
}

42
webclient/src/websocket/commands/session/resetPassword.ts Normal file
View file

@ -0,0 +1,42 @@
import { ForgotPasswordResetParams } from 'store';
import { StatusEnum, WebSocketConnectOptions } from 'types';
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import { hashPassword } from '../../utils';
import { disconnect, updateStatus } from '.';
export function resetPassword(options: WebSocketConnectOptions, passwordSalt?: string): void {
const { userName, token, newPassword } = options as unknown as ForgotPasswordResetParams;
const forgotPasswordResetConfig: any = {
...webClient.clientConfig,
userName,
token,
};
if (passwordSalt) {
forgotPasswordResetConfig.hashedNewPassword = hashPassword(passwordSalt, newPassword);
} else {
forgotPasswordResetConfig.newPassword = newPassword;
}
const CmdForgotPasswordReset = webClient.protobuf.controller.Command_ForgotPasswordReset.create(forgotPasswordResetConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordReset.ext': CmdForgotPasswordReset
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordSuccess();
} else {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordFailed();
}
disconnect();
});
}

34
webclient/src/websocket/commands/session/resetPasswordChallenge.ts Normal file
View file

@ -0,0 +1,34 @@
import { ForgotPasswordChallengeParams } from 'store';
import { StatusEnum, WebSocketConnectOptions } from 'types';
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import { disconnect, updateStatus } from './';
export function resetPasswordChallenge(options: WebSocketConnectOptions): void {
const { userName, email } = options as unknown as ForgotPasswordChallengeParams;
const forgotPasswordChallengeConfig = {
...webClient.clientConfig,
userName,
email,
};
const CmdForgotPasswordChallenge = webClient.protobuf.controller.Command_ForgotPasswordChallenge.create(forgotPasswordChallengeConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordChallenge.ext': CmdForgotPasswordChallenge
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPassword();
} else {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordFailed();
}
disconnect();
});
}

41
webclient/src/websocket/commands/session/resetPasswordRequest.ts Normal file
View file

@ -0,0 +1,41 @@
import { ForgotPasswordParams } from 'store';
import { StatusEnum, WebSocketConnectOptions } from 'types';
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
import { disconnect, updateStatus } from './';
export function resetPasswordRequest(options: WebSocketConnectOptions): void {
const { userName } = options as unknown as ForgotPasswordParams;
const forgotPasswordConfig = {
...webClient.clientConfig,
userName,
};
const CmdForgotPasswordRequest = webClient.protobuf.controller.Command_ForgotPasswordRequest.create(forgotPasswordConfig);
const sc = webClient.protobuf.controller.SessionCommand.create({
'.Command_ForgotPasswordRequest.ext': CmdForgotPasswordRequest
});
webClient.protobuf.sendSessionCommand(sc, raw => {
if (raw.responseCode === webClient.protobuf.controller.Response.ResponseCode.RespOk) {
const resp = raw['.Response_ForgotPasswordRequest.ext'];
if (resp.challengeEmail) {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordChallenge();
} else {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPassword();
}
} else {
updateStatus(StatusEnum.DISCONNECTED, null);
SessionPersistence.resetPasswordFailed();
}
disconnect();
});
}

6
webclient/src/websocket/commands/session/updateStatus.ts Normal file
View file

@ -0,0 +1,6 @@
import { StatusEnum } from 'types'
import webClient from '../../WebClient'
export function updateStatus(status: StatusEnum, description: string): void {
webClient.updateStatus(status, description);
}

30
webclient/src/websocket/commands/session/viewLogHistory.ts Normal file
View file

@ -0,0 +1,30 @@
import webClient from '../../WebClient';
import { SessionPersistence } from '../../persistence';
export function viewLogHistory(filters): void {
const CmdViewLogHistory = webClient.protobuf.controller.Command_ViewLogHistory.create(filters);
const sc = webClient.protobuf.controller.ModeratorCommand.create({
'.Command_ViewLogHistory.ext': CmdViewLogHistory
});
webClient.protobuf.sendModeratorCommand(sc, (raw) => {
const { responseCode } = raw;
let error;
switch (responseCode) {
case webClient.protobuf.controller.Response.ResponseCode.RespOk:
const { logMessage } = raw['.Response_ViewLogHistory.ext'];
SessionPersistence.viewLogs(logMessage)
return;
default:
error = 'Failed to retrieve log history.';
break;
}
if (error) {
console.error(responseCode, error);
}
});
}

49
webclient/src/websocket/events/RoomEvents.ts
View file

@ -1,49 +0,0 @@
import { Game, Message, User } from 'types';
import { RoomPersistence } from '../persistence/RoomPersistence';
import { ProtobufEvents } from '../services/ProtobufService';
export const RoomEvents: ProtobufEvents = {
'.Event_JoinRoom.ext': joinRoom,
'.Event_LeaveRoom.ext': leaveRoom,
'.Event_ListGames.ext': listGames,
'.Event_RoomSay.ext': roomSay,
};
function joinRoom({ userInfo }: JoinRoomData, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
RoomPersistence.userJoined(roomId, userInfo);
}
function leaveRoom({ name }: LeaveRoomData, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
RoomPersistence.userLeft(roomId, name);
}
function listGames({ gameList }: ListGamesData, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
RoomPersistence.updateGames(roomId, gameList);
}
function roomSay(message: Message, { roomEvent }: RoomEvent) {
const { roomId } = roomEvent;
RoomPersistence.addMessage(roomId, message);
}
export interface RoomEvent {
roomEvent: {
roomId: number;
}
}
export interface JoinRoomData {
userInfo: User;
}
export interface LeaveRoomData {
name: string;
}
export interface ListGamesData {
gameList: Game[];
}

230
webclient/src/websocket/events/SessionEvents.ts
View file

@ -1,230 +0,0 @@
import { Room, StatusEnum, User, WebSocketConnectReason } from 'types';
import { SessionCommands } from '../commands';
import { RoomPersistence, SessionPersistence } from '../persistence';
import { ProtobufEvents } from '../services/ProtobufService';
import { generateSalt, passwordSaltSupported } from '../utils';
import webClient from '../WebClient';
export const SessionEvents: ProtobufEvents = {
'.Event_AddToList.ext': addToList,
'.Event_ConnectionClosed.ext': connectionClosed,
'.Event_ListRooms.ext': listRooms,
'.Event_NotifyUser.ext': notifyUser,
'.Event_PlayerPropertiesChanges.ext': playerPropertiesChanges,
'.Event_RemoveFromList.ext': removeFromList,
'.Event_ServerIdentification.ext': serverIdentification,
'.Event_ServerMessage.ext': serverMessage,
'.Event_ServerShutdown.ext': serverShutdown,
'.Event_UserJoined.ext': userJoined,
'.Event_UserLeft.ext': userLeft,
'.Event_UserMessage.ext': userMessage,
}
function addToList({ listName, userInfo }: AddToListData) {
switch (listName) {
case 'buddy': {
SessionPersistence.addToBuddyList(userInfo);
break;
}
case 'ignore': {
SessionPersistence.addToIgnoreList(userInfo);
break;
}
default: {
console.log(`Attempted to add to unknown list: ${listName}`);
}
}
}
function connectionClosed({ reason, reasonStr }: ConnectionClosedData) {
let message;
// @TODO (5)
if (reasonStr) {
message = reasonStr;
} else {
switch (reason) {
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.USER_LIMIT_REACHED:
message = 'The server has reached its maximum user capacity';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.TOO_MANY_CONNECTIONS:
message = 'There are too many concurrent connections from your address';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.BANNED:
message = 'You are banned';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.DEMOTED:
message = 'You were demoted';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.SERVER_SHUTDOWN:
message = 'Scheduled server shutdown';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.USERNAMEINVALID:
message = 'Invalid username';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.LOGGEDINELSEWERE:
message = 'You have been logged out due to logging in at another location';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.OTHER:
default:
message = 'Unknown reason';
break;
}
}
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, message);
}
function listRooms({ roomList }: ListRoomsData) {
RoomPersistence.updateRooms(roomList);
if (webClient.clientOptions.autojoinrooms) {
roomList.forEach(({ autoJoin, roomId }) => {
if (autoJoin) {
SessionCommands.joinRoom(roomId);
}
});
}
}
function notifyUser(payload) {
// console.info('Event_NotifyUser', payload);
}
function playerPropertiesChanges(payload) {
// console.info('Event_PlayerPropertiesChanges', payload);
}
function removeFromList({ listName, userName }: RemoveFromListData) {
switch (listName) {
case 'buddy': {
SessionPersistence.removeFromBuddyList(userName);
break;
}
case 'ignore': {
SessionPersistence.removeFromIgnoreList(userName);
break;
}
default: {
console.log(`Attempted to remove from unknown list: ${listName}`);
}
}
}
function serverIdentification(info: ServerIdentificationData) {
const { serverName, serverVersion, protocolVersion, serverOptions } = info;
if (protocolVersion !== webClient.protocolVersion) {
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, `Protocol version mismatch: ${protocolVersion}`);
SessionCommands.disconnect();
return;
}
const getPasswordSalt = passwordSaltSupported(serverOptions, webClient);
const { options } = webClient;
switch (options.reason) {
case WebSocketConnectReason.LOGIN:
SessionCommands.updateStatus(StatusEnum.LOGGING_IN, 'Logging In...');
if (getPasswordSalt) {
SessionCommands.requestPasswordSalt(options);
} else {
SessionCommands.login(options);
}
break;
case WebSocketConnectReason.REGISTER:
const passwordSalt = getPasswordSalt ? generateSalt() : null;
SessionCommands.register(options, passwordSalt);
break;
case WebSocketConnectReason.ACTIVATE_ACCOUNT:
if (getPasswordSalt) {
SessionCommands.requestPasswordSalt(options);
} else {
SessionCommands.activateAccount(options);
}
break;
case WebSocketConnectReason.PASSWORD_RESET_REQUEST:
SessionCommands.resetPasswordRequest(options);
break;
case WebSocketConnectReason.PASSWORD_RESET_CHALLENGE:
SessionCommands.resetPasswordChallenge(options);
break;
case WebSocketConnectReason.PASSWORD_RESET:
if (getPasswordSalt) {
SessionCommands.requestPasswordSalt(options);
} else {
SessionCommands.resetPassword(options);
}
break;
default:
SessionCommands.updateStatus(StatusEnum.DISCONNECTED, 'Unknown Connection Reason: ' + options.reason);
SessionCommands.disconnect();
break;
}
webClient.options = {};
SessionPersistence.updateInfo(serverName, serverVersion);
}
function serverMessage({ message }: ServerMessageData) {
SessionPersistence.serverMessage(message);
}
function serverShutdown(payload) {
// console.info('Event_ServerShutdown', payload);
}
function userJoined({ userInfo }: UserJoinedData) {
SessionPersistence.userJoined(userInfo);
}
function userLeft({ name }: UserLeftData) {
SessionPersistence.userLeft(name);
}
function userMessage(payload) {
// console.info('Event_UserMessage', payload);
}
export interface SessionEvent {
sessionEvent: {}
}
export interface AddToListData {
listName: string;
userInfo: User;
}
export interface ConnectionClosedData {
endTime: number;
reason: number;
reasonStr: string;
}
export interface ListRoomsData {
roomList: Room[];
}
export interface RemoveFromListData {
listName: string;
userName: string;
}
export interface ServerIdentificationData {
protocolVersion: number;
serverName: string;
serverVersion: string;
serverOptions: number;
}
export interface ServerMessageData {
message: string;
}
export interface UserJoinedData {
userInfo: User;
}
export interface UserLeftData {
name: string;
}

4
webclient/src/websocket/events/index.ts
View file

@ -1,2 +1,2 @@
export * from './RoomEvents';
export * from './SessionEvents';
export * from './room';
export * from './session';

10
webclient/src/websocket/events/RoomEvents.spec.ts → webclient/src/websocket/events/room/RoomEvents.spec.ts
View file

@ -1,15 +1,17 @@
import { Message } from 'types';
import { RoomPersistence } from '../../persistence';
import {
RoomEvents,
RoomEvent,
JoinRoomData,
LeaveRoomData,
ListGamesData,
} from './RoomEvents';
import { RoomPersistence } from '../persistence/RoomPersistence';
} from './interfaces';
describe('RoomEvents', () => {
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 };

13
webclient/src/websocket/events/room/index.ts Normal file
View file

@ -0,0 +1,13 @@
import { ProtobufEvents } from '../../services/ProtobufService';
import { joinRoom } from './joinRoom';
import { leaveRoom } from './leaveRoom';
import { listGames } from './listGames';
import { roomSay } from './roomSay';
export const RoomEvents: ProtobufEvents = {
'.Event_JoinRoom.ext': joinRoom,
'.Event_LeaveRoom.ext': leaveRoom,
'.Event_ListGames.ext': listGames,
'.Event_RoomSay.ext': roomSay,
};

19
webclient/src/websocket/events/room/interfaces.ts Normal file
View file

@ -0,0 +1,19 @@
import { Game, User } from 'types';
export interface RoomEvent {
roomEvent: {
roomId: number;
}
}
export interface JoinRoomData {
userInfo: User;
}
export interface LeaveRoomData {
name: string;
}
export interface ListGamesData {
gameList: Game[];
}

8
webclient/src/websocket/events/room/joinRoom.ts Normal file
View file

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

7
webclient/src/websocket/events/room/leaveRoom.ts Normal file
View file

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

7
webclient/src/websocket/events/room/listGames.ts Normal file
View file

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

9
webclient/src/websocket/events/room/roomSay.ts Normal file
View file

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

13
webclient/src/websocket/events/SessionEvents.spec.ts → webclient/src/websocket/events/session/SessionEvents.spec.ts
View file

@ -1,5 +1,9 @@
import { StatusEnum, WebSocketConnectReason } from 'types';
import { SessionCommands } from '../../commands';
import { RoomPersistence, SessionPersistence } from '../../persistence';
import webClient from '../../WebClient';
import {
AddToListData,
ConnectionClosedData,
@ -7,16 +11,13 @@ import {
RemoveFromListData,
ServerIdentificationData,
ServerMessageData,
SessionEvents,
UserJoinedData,
UserLeftData,
} from './SessionEvents';
} from './interfaces';
import { SessionCommands } from '../commands';
import { RoomPersistence, SessionPersistence } from '../persistence';
import webClient from '../WebClient';
import { SessionEvents } from '.';
describe('SessionEvents', () => {
describe.skip('SessionEvents', () => {
const roomId = 1;
beforeEach(() => {

18
webclient/src/websocket/events/session/addToList.ts Normal file
View file

@ -0,0 +1,18 @@
import { SessionPersistence } from '../../persistence';
import { AddToListData } from './interfaces';
export function addToList({ listName, userInfo }: AddToListData) {
switch (listName) {
case 'buddy': {
SessionPersistence.addToBuddyList(userInfo);
break;
}
case 'ignore': {
SessionPersistence.addToIgnoreList(userInfo);
break;
}
default: {
console.log(`Attempted to add to unknown list: ${listName}`);
}
}
}

43
webclient/src/websocket/events/session/connectionClosed.ts Normal file
View file

@ -0,0 +1,43 @@
import { StatusEnum } from 'types';
import webClient from '../../WebClient';
import { updateStatus } from '../../commands/session';
import { ConnectionClosedData } from './interfaces';
export function connectionClosed({ reason, reasonStr }: ConnectionClosedData) {
let message;
// @TODO (5)
if (reasonStr) {
message = reasonStr;
} else {
switch (reason) {
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.USER_LIMIT_REACHED:
message = 'The server has reached its maximum user capacity';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.TOO_MANY_CONNECTIONS:
message = 'There are too many concurrent connections from your address';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.BANNED:
message = 'You are banned';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.DEMOTED:
message = 'You were demoted';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.SERVER_SHUTDOWN:
message = 'Scheduled server shutdown';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.USERNAMEINVALID:
message = 'Invalid username';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.LOGGEDINELSEWERE:
message = 'You have been logged out due to logging in at another location';
break;
case webClient.protobuf.controller.Event_ConnectionClosed.CloseReason.OTHER:
default:
message = 'Unknown reason';
break;
}
}
updateStatus(StatusEnum.DISCONNECTED, message);
}

28
webclient/src/websocket/events/session/index.ts Normal file
View file

@ -0,0 +1,28 @@
import { ProtobufEvents } from '../../services/ProtobufService';
import { addToList } from './addToList';
import { connectionClosed } from './connectionClosed';
import { listRooms } from './listRooms';
import { notifyUser } from './notifyUser';
import { playerPropertiesChanges } from './playerPropertiesChanges';
import { removeFromList } from './removeFromList';
import { serverIdentification } from './serverIdentification';
import { serverMessage } from './serverMessage';
import { serverShutdown } from './serverShutdown';
import { userJoined } from './userJoined';
import { userLeft } from './userLeft';
import { userMessage } from './userMessage';
export const SessionEvents: ProtobufEvents = {
'.Event_AddToList.ext': addToList,
'.Event_ConnectionClosed.ext': connectionClosed,
'.Event_ListRooms.ext': listRooms,
'.Event_NotifyUser.ext': notifyUser,
'.Event_PlayerPropertiesChanges.ext': playerPropertiesChanges,
'.Event_RemoveFromList.ext': removeFromList,
'.Event_ServerIdentification.ext': serverIdentification,
'.Event_ServerMessage.ext': serverMessage,
'.Event_ServerShutdown.ext': serverShutdown,
'.Event_UserJoined.ext': userJoined,
'.Event_UserLeft.ext': userLeft,
'.Event_UserMessage.ext': userMessage,
}

44
webclient/src/websocket/events/session/interfaces.ts Normal file
View file

@ -0,0 +1,44 @@
import { Room, User } from 'types';
export interface SessionEvent {
sessionEvent: {}
}
export interface AddToListData {
listName: string;
userInfo: User;
}
export interface ConnectionClosedData {
endTime: number;
reason: number;
reasonStr: string;
}
export interface ListRoomsData {
roomList: Room[];
}
export interface RemoveFromListData {
listName: string;
userName: string;
}
export interface ServerIdentificationData {
protocolVersion: number;
serverName: string;
serverVersion: string;
serverOptions: number;
}
export interface ServerMessageData {
message: string;
}
export interface UserJoinedData {
userInfo: User;
}
export interface UserLeftData {
name: string;
}

16
webclient/src/websocket/events/session/listRooms.ts Normal file
View file

@ -0,0 +1,16 @@
import webClient from '../../WebClient';
import { joinRoom } from '../../commands/session';
import { RoomPersistence } from '../../persistence';
import { ListRoomsData } from './interfaces';
export function listRooms({ roomList }: ListRoomsData) {
RoomPersistence.updateRooms(roomList);
if (webClient.clientOptions.autojoinrooms) {
roomList.forEach(({ autoJoin, roomId }) => {
if (autoJoin) {
joinRoom(roomId);
}
});
}
}

3
webclient/src/websocket/events/session/notifyUser.ts Normal file
View file

@ -0,0 +1,3 @@
export function notifyUser(payload) {
console.info('Event_NotifyUser', payload);
}

3
webclient/src/websocket/events/session/playerPropertiesChanges.ts Normal file
View file

@ -0,0 +1,3 @@
export function playerPropertiesChanges(payload) {
console.info('Event_PlayerPropertiesChanges', payload);
}

18
webclient/src/websocket/events/session/removeFromList.ts Normal file
View file

@ -0,0 +1,18 @@
import { SessionPersistence } from '../../persistence';
import { RemoveFromListData } from './interfaces';
export function removeFromList({ listName, userName }: RemoveFromListData) {
switch (listName) {
case 'buddy': {
SessionPersistence.removeFromBuddyList(userName);
break;
}
case 'ignore': {
SessionPersistence.removeFromIgnoreList(userName);
break;
}
default: {
console.log(`Attempted to remove from unknown list: ${listName}`);
}
}
}

71
webclient/src/websocket/events/session/serverIdentification.ts Normal file
View file

@ -0,0 +1,71 @@
import { StatusEnum, WebSocketConnectReason } from 'types';
import webClient from '../../WebClient';
import {
activateAccount,
disconnect,
login,
register,
requestPasswordSalt,
resetPassword,
resetPasswordChallenge,
resetPasswordRequest,
updateStatus,
} from '../../commands/session';
import { generateSalt, passwordSaltSupported } from '../../utils';
import { ServerIdentificationData } from './interfaces';
import { SessionPersistence } from '../../persistence';
export function serverIdentification(info: ServerIdentificationData) {
const { serverName, serverVersion, protocolVersion, serverOptions } = info;
if (protocolVersion !== webClient.protocolVersion) {
updateStatus(StatusEnum.DISCONNECTED, `Protocol version mismatch: ${protocolVersion}`);
disconnect();
return;
}
const getPasswordSalt = passwordSaltSupported(serverOptions, webClient);
const { options } = webClient;
switch (options.reason) {
case WebSocketConnectReason.LOGIN:
updateStatus(StatusEnum.LOGGING_IN, 'Logging In...');
if (getPasswordSalt) {
requestPasswordSalt(options);
} else {
login(options);
}
break;
case WebSocketConnectReason.REGISTER:
const passwordSalt = getPasswordSalt ? generateSalt() : null;
register(options, passwordSalt);
break;
case WebSocketConnectReason.ACTIVATE_ACCOUNT:
if (getPasswordSalt) {
requestPasswordSalt(options);
} else {
activateAccount(options);
}
break;
case WebSocketConnectReason.PASSWORD_RESET_REQUEST:
resetPasswordRequest(options);
break;
case WebSocketConnectReason.PASSWORD_RESET_CHALLENGE:
resetPasswordChallenge(options);
break;
case WebSocketConnectReason.PASSWORD_RESET:
if (getPasswordSalt) {
requestPasswordSalt(options);
} else {
resetPassword(options);
}
break;
default:
updateStatus(StatusEnum.DISCONNECTED, 'Unknown Connection Reason: ' + options.reason);
disconnect();
break;
}
webClient.options = {};
SessionPersistence.updateInfo(serverName, serverVersion);
}

6
webclient/src/websocket/events/session/serverMessage.ts Normal file
View file

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

3
webclient/src/websocket/events/session/serverShutdown.ts Normal file
View file

@ -0,0 +1,3 @@
export function serverShutdown(payload) {
console.info('Event_ServerShutdown', payload);
}

6
webclient/src/websocket/events/session/userJoined.ts Normal file
View file

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

6
webclient/src/websocket/events/session/userLeft.ts Normal file
View file

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

3
webclient/src/websocket/events/session/userMessage.ts Normal file
View file

@ -0,0 +1,3 @@
export function userMessage(payload) {
console.info('Event_UserMessage', payload);
}