TeaSpeak/TeaWeb
TeaSpeak/TeaWeb
1
0
Fork 0
Code Issues 1 Pull requests Activity

Reset all js files and start from zero, this time more structured

Browse source
This commit is contained in:
WolverinDEV 2020-03-29 12:54:15 +02:00
parent 5f0c1b303a
commit 447e84ed0f
111 changed files with 3946 additions and 4237 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
shared/js/BrowserIPC.ts
View file

@ -1,8 +1,8 @@
export interface Window {
interface Window {
BroadcastChannel: BroadcastChannel;
}
export namespace bipc {
namespace bipc {
export interface BroadcastMessage {
timestamp: number;
receiver: string;

26
shared/js/ConnectionHandler.ts
View file

@ -1,6 +1,6 @@
/// <reference path="log.ts" />
/// <reference path="proto.ts" />
/// <reference path="channel-tree/view.ts" />
/// <reference path="ui/view.ts" />
/// <reference path="settings.ts" />
/// <reference path="FileManager.ts" />
/// <reference path="permission/PermissionManager.ts" />
@ -8,17 +8,7 @@
/// <reference path="ui/frames/ControlBar.ts" />
/// <reference path="connection/ConnectionBase.ts" />
import {ChannelTree} from "./channel-tree/view";
import {LocalClientEntry} from "./channel-tree/client";
import {ServerAddress} from "./channel-tree/server";
import {ChannelEntry} from "./channel-tree/channel";
import {AbstractServerConnection} from "./connection/ConnectionBase";
import {PermissionManager} from "./permission/PermissionManager";
import {GroupManager} from "./permission/GroupManager";
import {ServerSettings} from "./settings";
import {Hostbanner} from "./ui/frames/hostbanner";
export enum DisconnectReason {
enum DisconnectReason {
HANDLER_DESTROYED,
REQUESTED,
DNS_FAILED,
@ -38,7 +28,7 @@ export enum DisconnectReason {
UNKNOWN
}
export enum ConnectionState {
enum ConnectionState {
UNCONNECTED,
CONNECTING,
INITIALISING,
@ -46,7 +36,7 @@ export enum ConnectionState {
DISCONNECTING
}
export enum ViewReasonId {
enum ViewReasonId {
VREASON_USER_ACTION = 0,
VREASON_MOVED = 1,
VREASON_SYSTEM = 2,
@ -61,7 +51,7 @@ export enum ViewReasonId {
VREASON_SERVER_SHUTDOWN = 11
}
export interface VoiceStatus {
interface VoiceStatus {
input_hardware: boolean;
input_muted: boolean;
output_muted: boolean;
@ -78,7 +68,7 @@ export interface VoiceStatus {
queries_visible: boolean;
}
export interface ConnectParameters {
interface ConnectParameters {
nickname?: string;
channel?: {
target: string | number;
@ -89,10 +79,10 @@ export interface ConnectParameters {
auto_reconnect_attempt?: boolean;
}
export class ConnectionHandler {
class ConnectionHandler {
channelTree: ChannelTree;
serverConnection: AbstractServerConnection;
serverConnection: connection.AbstractServerConnection;
fileManager: FileManager;

19
shared/js/FileManager.ts
View file

@ -1,26 +1,21 @@
import {ChannelEntry} from "./channel-tree/channel";
import {AbstractCommandHandler, ServerCommand} from "./connection/ConnectionBase";
import {ConnectionHandler} from "./ConnectionHandler";
import {CommandResult} from "./connection/ServerConnectionDeclaration";
import {log, LogCategory} from "./log";
import {ClientEntry} from "./channel-tree/client";
import {hex} from "./crypto/hex";
/// <reference path="connection/CommandHandler.ts" />
/// <reference path="connection/ConnectionBase.ts" />
export class FileEntry {
class FileEntry {
name: string;
datetime: number;
type: number;
size: number;
}
export class FileListRequest {
class FileListRequest {
path: string;
entries: FileEntry[];
callback: (entries: FileEntry[]) => void;
}
export namespace transfer {
namespace transfer {
export interface TransferKey {
client_transfer_id: number;
server_transfer_id: number;
@ -157,7 +152,7 @@ class RequestFileUpload implements transfer.UploadTransfer {
}
}
class FileManager extends AbstractCommandHandler {
class FileManager extends connection.AbstractCommandHandler {
handle: ConnectionHandler;
icons: IconManager;
avatars: AvatarManager;
@ -196,7 +191,7 @@ class FileManager extends AbstractCommandHandler {
this.avatars = undefined;
}
handle_command(command: ServerCommand): boolean {
handle_command(command: connection.ServerCommand): boolean {
switch (command.command) {
case "notifyfilelist":
this.notifyFileList(command.arguments);

8
shared/js/MessageFormatter.ts
View file

@ -1,10 +1,4 @@
import {Settings, settings} from "./settings";
import {contextmenu} from "./ui/elements/context_menu";
import {image_preview} from "./ui/frames/image_preview";
import {guid} from "./crypto/uid";
declare const xbbcode;
export namespace messages.formatter {
namespace messages.formatter {
export namespace bbcode {
const sanitizer_escaped = (key: string) => "[-- sescaped: " + key + " --]";
const sanitizer_escaped_regex = /\[-- sescaped: ([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}) --]/;

4
shared/js/PPTListener.ts
View file

@ -1,4 +1,4 @@
export enum KeyCode {
enum KeyCode {
KEY_CANCEL = 3,
KEY_HELP = 6,
KEY_BACK_SPACE = 8,
@ -118,7 +118,7 @@ export enum KeyCode {
KEY_META = 224
}
export namespace ppt {
namespace ppt {
export enum EventType {
KEY_PRESS,
KEY_RELEASE,

12
shared/js/bookmarks.ts
View file

@ -1,6 +1,14 @@
import {profiles} from "./profiles/ConnectionProfile";
namespace bookmarks {
function guid() {
function s4() {
return Math
.floor((1 + Math.random()) * 0x10000)
.toString(16)
.substring(1);
}
return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
}
export namespace bookmarks {
export const boorkmak_connect = (mark: Bookmark, new_tab?: boolean) => {
const profile = profiles.find_profile(mark.connect_profile) || profiles.default_profile();
if(profile.valid()) {

2120
shared/js/connection/CommandHandler.ts
View file

File diff suppressed because it is too large Load diff

842
shared/js/connection/CommandHelper.ts
View file

@ -1,460 +1,448 @@
import {
ClientNameInfo,
CommandResult,
ErrorID,
Playlist, PlaylistInfo, PlaylistSong,
QueryList,
QueryListEntry, ServerGroupClient
} from "./ServerConnectionDeclaration";
import {ChannelEntry} from "../channel-tree/channel";
import {ChatType} from "../ui/frames/chat";
import {ClientEntry} from "../channel-tree/client";
import {AbstractCommandHandler, ServerCommand, SingleCommandHandler} from "./ConnectionBase";
import {log, LogCategory} from "../log";
namespace connection {
export class CommandHelper extends AbstractCommandHandler {
private _who_am_i: any;
private _awaiters_unique_ids: {[unique_id: string]:((resolved: ClientNameInfo) => any)[]} = {};
private _awaiters_unique_dbid: {[database_id: number]:((resolved: ClientNameInfo) => any)[]} = {};
export class CommandHelper extends AbstractCommandHandler {
private _who_am_i: any;
private _awaiters_unique_ids: {[unique_id: string]:((resolved: ClientNameInfo) => any)[]} = {};
private _awaiters_unique_dbid: {[database_id: number]:((resolved: ClientNameInfo) => any)[]} = {};
constructor(connection) {
super(connection);
constructor(connection) {
super(connection);
this.volatile_handler_boss = false;
this.ignore_consumed = true;
}
initialize() {
this.connection.command_handler_boss().register_handler(this);
}
destroy() {
if(this.connection) {
const hboss = this.connection.command_handler_boss();
hboss && hboss.unregister_handler(this);
}
this._awaiters_unique_ids = undefined;
}
handle_command(command: ServerCommand): boolean {
if(command.command == "notifyclientnamefromuid")
this.handle_notifyclientnamefromuid(command.arguments);
if(command.command == "notifyclientgetnamefromdbid")
this.handle_notifyclientgetnamefromdbid(command.arguments);
else
return false;
return true;
}
joinChannel(channel: ChannelEntry, password?: string) : Promise<CommandResult> {
return this.connection.send_command("clientmove", {
"clid": this.connection.client.getClientId(),
"cid": channel.getChannelId(),
"cpw": password || ""
});
}
sendMessage(message: string, type: ChatType, target?: ChannelEntry | ClientEntry) : Promise<CommandResult> {
if(type == ChatType.SERVER)
return this.connection.send_command("sendtextmessage", {"targetmode": 3, "target": 0, "msg": message});
else if(type == ChatType.CHANNEL)
return this.connection.send_command("sendtextmessage", {"targetmode": 2, "target": (target as ChannelEntry).getChannelId(), "msg": message});
else if(type == ChatType.CLIENT)
return this.connection.send_command("sendtextmessage", {"targetmode": 1, "target": (target as ClientEntry).clientId(), "msg": message});
}
updateClient(key: string, value: string) : Promise<CommandResult> {
let data = {};
data[key] = value;
return this.connection.send_command("clientupdate", data);
}
async info_from_uid(..._unique_ids: string[]) : Promise<ClientNameInfo[]> {
const response: ClientNameInfo[] = [];
const request = [];
const unique_ids = new Set(_unique_ids);
if(!unique_ids.size) return [];
const unique_id_resolvers: {[unique_id: string]: (resolved: ClientNameInfo) => any} = {};
for(const unique_id of unique_ids) {
request.push({'cluid': unique_id});
(this._awaiters_unique_ids[unique_id] || (this._awaiters_unique_ids[unique_id] = []))
.push(unique_id_resolvers[unique_id] = info => response.push(info));
this.volatile_handler_boss = false;
this.ignore_consumed = true;
}
try {
await this.connection.send_command("clientgetnamefromuid", request);
} catch(error) {
if(error instanceof CommandResult && error.id == ErrorID.EMPTY_RESULT) {
/* nothing */
} else {
throw error;
initialize() {
this.connection.command_handler_boss().register_handler(this);
}
destroy() {
if(this.connection) {
const hboss = this.connection.command_handler_boss();
hboss && hboss.unregister_handler(this);
}
} finally {
/* cleanup */
for(const unique_id of Object.keys(unique_id_resolvers))
(this._awaiters_unique_ids[unique_id] || []).remove(unique_id_resolvers[unique_id]);
this._awaiters_unique_ids = undefined;
}
return response;
}
private handle_notifyclientgetnamefromdbid(json: any[]) {
for(const entry of json) {
const info: ClientNameInfo = {
client_unique_id: entry["cluid"],
client_nickname: entry["clname"],
client_database_id: parseInt(entry["cldbid"])
};
const functions = this._awaiters_unique_dbid[info.client_database_id] || [];
delete this._awaiters_unique_dbid[info.client_database_id];
for(const fn of functions)
fn(info);
}
}
async info_from_cldbid(..._cldbid: number[]) : Promise<ClientNameInfo[]> {
const response: ClientNameInfo[] = [];
const request = [];
const unique_cldbid = new Set(_cldbid);
if(!unique_cldbid.size) return [];
const unique_cldbid_resolvers: {[dbid: number]: (resolved: ClientNameInfo) => any} = {};
for(const cldbid of unique_cldbid) {
request.push({'cldbid': cldbid});
(this._awaiters_unique_dbid[cldbid] || (this._awaiters_unique_dbid[cldbid] = []))
.push(unique_cldbid_resolvers[cldbid] = info => response.push(info));
handle_command(command: connection.ServerCommand): boolean {
if(command.command == "notifyclientnamefromuid")
this.handle_notifyclientnamefromuid(command.arguments);
if(command.command == "notifyclientgetnamefromdbid")
this.handle_notifyclientgetnamefromdbid(command.arguments);
else
return false;
return true;
}
try {
await this.connection.send_command("clientgetnamefromdbid", request);
} catch(error) {
if(error instanceof CommandResult && error.id == ErrorID.EMPTY_RESULT) {
/* nothing */
} else {
throw error;
}
} finally {
/* cleanup */
for(const cldbid of Object.keys(unique_cldbid_resolvers))
(this._awaiters_unique_dbid[cldbid] || []).remove(unique_cldbid_resolvers[cldbid]);
joinChannel(channel: ChannelEntry, password?: string) : Promise<CommandResult> {
return this.connection.send_command("clientmove", {
"clid": this.connection.client.getClientId(),
"cid": channel.getChannelId(),
"cpw": password || ""
});
}
return response;
}
private handle_notifyclientnamefromuid(json: any[]) {
for(const entry of json) {
const info: ClientNameInfo = {
client_unique_id: entry["cluid"],
client_nickname: entry["clname"],
client_database_id: parseInt(entry["cldbid"])
};
const functions = this._awaiters_unique_ids[entry["cluid"]] || [];
delete this._awaiters_unique_ids[entry["cluid"]];
for(const fn of functions)
fn(info);
sendMessage(message: string, type: ChatType, target?: ChannelEntry | ClientEntry) : Promise<CommandResult> {
if(type == ChatType.SERVER)
return this.connection.send_command("sendtextmessage", {"targetmode": 3, "target": 0, "msg": message});
else if(type == ChatType.CHANNEL)
return this.connection.send_command("sendtextmessage", {"targetmode": 2, "target": (target as ChannelEntry).getChannelId(), "msg": message});
else if(type == ChatType.CLIENT)
return this.connection.send_command("sendtextmessage", {"targetmode": 1, "target": (target as ClientEntry).clientId(), "msg": message});
}
}
request_query_list(server_id: number = undefined) : Promise<QueryList> {
return new Promise<QueryList>((resolve, reject) => {
const single_handler = {
command: "notifyquerylist",
function: command => {
const json = command.arguments;
const result = {} as QueryList;
result.flag_all = json[0]["flag_all"];
result.flag_own = json[0]["flag_own"];
result.queries = [];
for(const entry of json) {
const rentry = {} as QueryListEntry;
rentry.bounded_server = parseInt(entry["client_bound_server"]);
rentry.username = entry["client_login_name"];
rentry.unique_id = entry["client_unique_identifier"];
result.queries.push(rentry);
}
resolve(result);
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
updateClient(key: string, value: string) : Promise<CommandResult> {
let data = {};
if(server_id !== undefined)
data["server_id"] = server_id;
data[key] = value;
return this.connection.send_command("clientupdate", data);
}
this.connection.send_command("querylist", data).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
async info_from_uid(..._unique_ids: string[]) : Promise<ClientNameInfo[]> {
const response: ClientNameInfo[] = [];
const request = [];
const unique_ids = new Set(_unique_ids);
if(!unique_ids.size) return [];
if(error instanceof CommandResult) {
if(error.id == ErrorID.EMPTY_RESULT) {
resolve(undefined);
return;
}
}
reject(error);
});
});
}
const unique_id_resolvers: {[unique_id: string]: (resolved: ClientNameInfo) => any} = {};
request_playlist_list() : Promise<Playlist[]> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistlist",
function: command => {
const json = command.arguments;
const result: Playlist[] = [];
for(const entry of json) {
try {
result.push({
playlist_id: parseInt(entry["playlist_id"]),
playlist_bot_id: parseInt(entry["playlist_bot_id"]),
playlist_title: entry["playlist_title"],
playlist_type: parseInt(entry["playlist_type"]),
playlist_owner_dbid: parseInt(entry["playlist_owner_dbid"]),
playlist_owner_name: entry["playlist_owner_name"],
for(const unique_id of unique_ids) {
request.push({'cluid': unique_id});
(this._awaiters_unique_ids[unique_id] || (this._awaiters_unique_ids[unique_id] = []))
.push(unique_id_resolvers[unique_id] = info => response.push(info));
}
needed_power_modify: parseInt(entry["needed_power_modify"]),
needed_power_permission_modify: parseInt(entry["needed_power_permission_modify"]),
needed_power_delete: parseInt(entry["needed_power_delete"]),
needed_power_song_add: parseInt(entry["needed_power_song_add"]),
needed_power_song_move: parseInt(entry["needed_power_song_move"]),
needed_power_song_remove: parseInt(entry["needed_power_song_remove"])
});
} catch(error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse playlist entry: %o"), error);
}
}
resolve(result);
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistlist").catch(error => {
this.handler_boss.remove_single_handler(single_handler);
if(error instanceof CommandResult) {
if(error.id == ErrorID.EMPTY_RESULT) {
resolve([]);
return;
}
}
reject(error);
})
});
}
request_playlist_songs(playlist_id: number) : Promise<PlaylistSong[]> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistsonglist",
function: command => {
const json = command.arguments;
if(json[0]["playlist_id"] != playlist_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for playlist songs"));
return false;
}
const result: PlaylistSong[] = [];
for(const entry of json) {
try {
result.push({
song_id: parseInt(entry["song_id"]),
song_invoker: entry["song_invoker"],
song_previous_song_id: parseInt(entry["song_previous_song_id"]),
song_url: entry["song_url"],
song_url_loader: entry["song_url_loader"],
song_loaded: entry["song_loaded"] == true || entry["song_loaded"] == "1",
song_metadata: entry["song_metadata"]
});
} catch(error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse playlist song entry: %o"), error);
}
}
resolve(result);
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistsonglist", {playlist_id: playlist_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
if(error instanceof CommandResult) {
if(error.id == ErrorID.EMPTY_RESULT) {
resolve([]);
return;
}
}
reject(error);
})
});
}
request_playlist_client_list(playlist_id: number) : Promise<number[]> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistclientlist",
function: command => {
const json = command.arguments;
if(json[0]["playlist_id"] != playlist_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for playlist clients"));
return false;
}
const result: number[] = [];
for(const entry of json)
result.push(parseInt(entry["cldbid"]));
resolve(result.filter(e => !isNaN(e)));
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistclientlist", {playlist_id: playlist_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
try {
await this.connection.send_command("clientgetnamefromuid", request);
} catch(error) {
if(error instanceof CommandResult && error.id == ErrorID.EMPTY_RESULT) {
resolve([]);
return;
/* nothing */
} else {
throw error;
}
reject(error);
})
});
}
} finally {
/* cleanup */
for(const unique_id of Object.keys(unique_id_resolvers))
(this._awaiters_unique_ids[unique_id] || []).remove(unique_id_resolvers[unique_id]);
}
async request_clients_by_server_group(group_id: number) : Promise<ServerGroupClient[]> {
//servergroupclientlist sgid=2
//notifyservergroupclientlist sgid=6 cldbid=2 client_nickname=WolverinDEV client_unique_identifier=xxjnc14LmvTk+Lyrm8OOeo4tOqw=
return new Promise<ServerGroupClient[]>((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyservergroupclientlist",
function: command => {
if (command.arguments[0]["sgid"] != group_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for server group client list"));
return false;
}
return response;
}
private handle_notifyclientgetnamefromdbid(json: any[]) {
for(const entry of json) {
const info: ClientNameInfo = {
client_unique_id: entry["cluid"],
client_nickname: entry["clname"],
client_database_id: parseInt(entry["cldbid"])
};
const functions = this._awaiters_unique_dbid[info.client_database_id] || [];
delete this._awaiters_unique_dbid[info.client_database_id];
for(const fn of functions)
fn(info);
}
}
async info_from_cldbid(..._cldbid: number[]) : Promise<ClientNameInfo[]> {
const response: ClientNameInfo[] = [];
const request = [];
const unique_cldbid = new Set(_cldbid);
if(!unique_cldbid.size) return [];
const unique_cldbid_resolvers: {[dbid: number]: (resolved: ClientNameInfo) => any} = {};
for(const cldbid of unique_cldbid) {
request.push({'cldbid': cldbid});
(this._awaiters_unique_dbid[cldbid] || (this._awaiters_unique_dbid[cldbid] = []))
.push(unique_cldbid_resolvers[cldbid] = info => response.push(info));
}
try {
await this.connection.send_command("clientgetnamefromdbid", request);
} catch(error) {
if(error instanceof CommandResult && error.id == ErrorID.EMPTY_RESULT) {
/* nothing */
} else {
throw error;
}
} finally {
/* cleanup */
for(const cldbid of Object.keys(unique_cldbid_resolvers))
(this._awaiters_unique_dbid[cldbid] || []).remove(unique_cldbid_resolvers[cldbid]);
}
return response;
}
private handle_notifyclientnamefromuid(json: any[]) {
for(const entry of json) {
const info: ClientNameInfo = {
client_unique_id: entry["cluid"],
client_nickname: entry["clname"],
client_database_id: parseInt(entry["cldbid"])
};
const functions = this._awaiters_unique_ids[entry["cluid"]] || [];
delete this._awaiters_unique_ids[entry["cluid"]];
for(const fn of functions)
fn(info);
}
}
request_query_list(server_id: number = undefined) : Promise<QueryList> {
return new Promise<QueryList>((resolve, reject) => {
const single_handler = {
command: "notifyquerylist",
function: command => {
const json = command.arguments;
const result = {} as QueryList;
result.flag_all = json[0]["flag_all"];
result.flag_own = json[0]["flag_own"];
result.queries = [];
for(const entry of json) {
const rentry = {} as QueryListEntry;
rentry.bounded_server = parseInt(entry["client_bound_server"]);
rentry.username = entry["client_login_name"];
rentry.unique_id = entry["client_unique_identifier"];
result.queries.push(rentry);
}
try {
const result: ServerGroupClient[] = [];
for(const entry of command.arguments)
result.push({
client_database_id: parseInt(entry["cldbid"]),
client_nickname: entry["client_nickname"],
client_unique_identifier: entry["client_unique_identifier"]
});
resolve(result);
} catch (error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse server group client list: %o"), error);
reject("failed to parse info");
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
let data = {};
if(server_id !== undefined)
data["server_id"] = server_id;
this.connection.send_command("servergroupclientlist", {sgid: group_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
reject(error);
})
});
}
this.connection.send_command("querylist", data).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
request_playlist_info(playlist_id: number) : Promise<PlaylistInfo> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistinfo",
function: command => {
const json = command.arguments[0];
if (json["playlist_id"] != playlist_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for playlist info"));
if(error instanceof CommandResult) {
if(error.id == ErrorID.EMPTY_RESULT) {
resolve(undefined);
return;
}
}
reject(error);
});
});
}
request_playlist_list() : Promise<Playlist[]> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistlist",
function: command => {
const json = command.arguments;
const result: Playlist[] = [];
for(const entry of json) {
try {
result.push({
playlist_id: parseInt(entry["playlist_id"]),
playlist_bot_id: parseInt(entry["playlist_bot_id"]),
playlist_title: entry["playlist_title"],
playlist_type: parseInt(entry["playlist_type"]),
playlist_owner_dbid: parseInt(entry["playlist_owner_dbid"]),
playlist_owner_name: entry["playlist_owner_name"],
needed_power_modify: parseInt(entry["needed_power_modify"]),
needed_power_permission_modify: parseInt(entry["needed_power_permission_modify"]),
needed_power_delete: parseInt(entry["needed_power_delete"]),
needed_power_song_add: parseInt(entry["needed_power_song_add"]),
needed_power_song_move: parseInt(entry["needed_power_song_move"]),
needed_power_song_remove: parseInt(entry["needed_power_song_remove"])
});
} catch(error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse playlist entry: %o"), error);
}
}
resolve(result);
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistlist").catch(error => {
this.handler_boss.remove_single_handler(single_handler);
if(error instanceof CommandResult) {
if(error.id == ErrorID.EMPTY_RESULT) {
resolve([]);
return;
}
}
reject(error);
})
});
}
request_playlist_songs(playlist_id: number) : Promise<PlaylistSong[]> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistsonglist",
function: command => {
const json = command.arguments;
if(json[0]["playlist_id"] != playlist_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for playlist songs"));
return false;
}
const result: PlaylistSong[] = [];
for(const entry of json) {
try {
result.push({
song_id: parseInt(entry["song_id"]),
song_invoker: entry["song_invoker"],
song_previous_song_id: parseInt(entry["song_previous_song_id"]),
song_url: entry["song_url"],
song_url_loader: entry["song_url_loader"],
song_loaded: entry["song_loaded"] == true || entry["song_loaded"] == "1",
song_metadata: entry["song_metadata"]
});
} catch(error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse playlist song entry: %o"), error);
}
}
resolve(result);
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistsonglist", {playlist_id: playlist_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
if(error instanceof CommandResult) {
if(error.id == ErrorID.EMPTY_RESULT) {
resolve([]);
return;
}
}
reject(error);
})
});
}
request_playlist_client_list(playlist_id: number) : Promise<number[]> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistclientlist",
function: command => {
const json = command.arguments;
if(json[0]["playlist_id"] != playlist_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for playlist clients"));
return false;
}
const result: number[] = [];
for(const entry of json)
result.push(parseInt(entry["cldbid"]));
resolve(result.filter(e => !isNaN(e)));
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistclientlist", {playlist_id: playlist_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
if(error instanceof CommandResult && error.id == ErrorID.EMPTY_RESULT) {
resolve([]);
return;
}
try {
//resolve
resolve({
playlist_id: parseInt(json["playlist_id"]),
playlist_title: json["playlist_title"],
playlist_description: json["playlist_description"],
playlist_type: parseInt(json["playlist_type"]),
playlist_owner_dbid: parseInt(json["playlist_owner_dbid"]),
playlist_owner_name: json["playlist_owner_name"],
playlist_flag_delete_played: json["playlist_flag_delete_played"] == true || json["playlist_flag_delete_played"] == "1",
playlist_flag_finished: json["playlist_flag_finished"] == true || json["playlist_flag_finished"] == "1",
playlist_replay_mode: parseInt(json["playlist_replay_mode"]),
playlist_current_song_id: parseInt(json["playlist_current_song_id"]),
playlist_max_songs: parseInt(json["playlist_max_songs"])
});
} catch (error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse playlist info: %o"), error);
reject("failed to parse info");
}
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistinfo", {playlist_id: playlist_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
reject(error);
})
});
}
/**
* @deprecated
* Its just a workaround for the query management.
* There is no garante that the whoami trick will work forever
*/
current_virtual_server_id() : Promise<number> {
if(this._who_am_i)
return Promise.resolve(parseInt(this._who_am_i["virtualserver_id"]));
return new Promise<number>((resolve, reject) => {
const single_handler: SingleCommandHandler = {
function: command => {
if(command.command != "" && command.command.indexOf("=") == -1)
return false;
this._who_am_i = command.arguments[0];
resolve(parseInt(this._who_am_i["virtualserver_id"]));
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("whoami").catch(error => {
this.handler_boss.remove_single_handler(single_handler);
reject(error);
reject(error);
})
});
});
}
async request_clients_by_server_group(group_id: number) : Promise<ServerGroupClient[]> {
//servergroupclientlist sgid=2
//notifyservergroupclientlist sgid=6 cldbid=2 client_nickname=WolverinDEV client_unique_identifier=xxjnc14LmvTk+Lyrm8OOeo4tOqw=
return new Promise<ServerGroupClient[]>((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyservergroupclientlist",
function: command => {
if (command.arguments[0]["sgid"] != group_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for server group client list"));
return false;
}
try {
const result: ServerGroupClient[] = [];
for(const entry of command.arguments)
result.push({
client_database_id: parseInt(entry["cldbid"]),
client_nickname: entry["client_nickname"],
client_unique_identifier: entry["client_unique_identifier"]
});
resolve(result);
} catch (error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse server group client list: %o"), error);
reject("failed to parse info");
}
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("servergroupclientlist", {sgid: group_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
reject(error);
})
});
}
request_playlist_info(playlist_id: number) : Promise<PlaylistInfo> {
return new Promise((resolve, reject) => {
const single_handler: SingleCommandHandler = {
command: "notifyplaylistinfo",
function: command => {
const json = command.arguments[0];
if (json["playlist_id"] != playlist_id) {
log.error(LogCategory.NETWORKING, tr("Received invalid notification for playlist info"));
return;
}
try {
//resolve
resolve({
playlist_id: parseInt(json["playlist_id"]),
playlist_title: json["playlist_title"],
playlist_description: json["playlist_description"],
playlist_type: parseInt(json["playlist_type"]),
playlist_owner_dbid: parseInt(json["playlist_owner_dbid"]),
playlist_owner_name: json["playlist_owner_name"],
playlist_flag_delete_played: json["playlist_flag_delete_played"] == true || json["playlist_flag_delete_played"] == "1",
playlist_flag_finished: json["playlist_flag_finished"] == true || json["playlist_flag_finished"] == "1",
playlist_replay_mode: parseInt(json["playlist_replay_mode"]),
playlist_current_song_id: parseInt(json["playlist_current_song_id"]),
playlist_max_songs: parseInt(json["playlist_max_songs"])
});
} catch (error) {
log.error(LogCategory.NETWORKING, tr("Failed to parse playlist info: %o"), error);
reject("failed to parse info");
}
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("playlistinfo", {playlist_id: playlist_id}).catch(error => {
this.handler_boss.remove_single_handler(single_handler);
reject(error);
})
});
}
/**
* @deprecated
* Its just a workaround for the query management.
* There is no garante that the whoami trick will work forever
*/
current_virtual_server_id() : Promise<number> {
if(this._who_am_i)
return Promise.resolve(parseInt(this._who_am_i["virtualserver_id"]));
return new Promise<number>((resolve, reject) => {
const single_handler: SingleCommandHandler = {
function: command => {
if(command.command != "" && command.command.indexOf("=") == -1)
return false;
this._who_am_i = command.arguments[0];
resolve(parseInt(this._who_am_i["virtualserver_id"]));
return true;
}
};
this.handler_boss.register_single_handler(single_handler);
this.connection.send_command("whoami").catch(error => {
this.handler_boss.remove_single_handler(single_handler);
reject(error);
});
});
}
}
}

368
shared/js/connection/ConnectionBase.ts
View file

@ -1,222 +1,216 @@
import {ConnectionHandler, ConnectionState} from "../ConnectionHandler";
import {ServerAddress} from "../channel-tree/server";
import {CommandResult} from "./ServerConnectionDeclaration";
import {RecorderProfile} from "../voice/RecorderProfile";
import {CommandHelper} from "./CommandHelper";
import {connection} from "./HandshakeHandler";
import HandshakeHandler = connection.HandshakeHandler;
namespace connection {
export interface CommandOptions {
flagset?: string[]; /* default: [] */
process_result?: boolean; /* default: true */
export interface CommandOptions {
flagset?: string[]; /* default: [] */
process_result?: boolean; /* default: true */
timeout?: number /* default: 1000 */;
}
export const CommandOptionDefaults: CommandOptions = {
flagset: [],
process_result: true,
timeout: 1000
};
export type ConnectionStateListener = (old_state: ConnectionState, new_state: ConnectionState) => any;
export abstract class AbstractServerConnection {
readonly client: ConnectionHandler;
readonly command_helper: CommandHelper;
protected constructor(client: ConnectionHandler) {
this.client = client;
this.command_helper = new CommandHelper(this);
timeout?: number /* default: 1000 */;
}
/* resolved as soon a connection has been established. This does not means that the authentication had yet been done! */
abstract connect(address: ServerAddress, handshake: HandshakeHandler, timeout?: number) : Promise<void>;
abstract connected() : boolean;
abstract disconnect(reason?: string) : Promise<void>;
abstract support_voice() : boolean;
abstract voice_connection() : voice.AbstractVoiceConnection | undefined;
abstract command_handler_boss() : AbstractCommandHandlerBoss;
abstract send_command(command: string, data?: any | any[], options?: CommandOptions) : Promise<CommandResult>;
abstract get onconnectionstatechanged() : ConnectionStateListener;
abstract set onconnectionstatechanged(listener: ConnectionStateListener);
abstract remote_address() : ServerAddress; /* only valid when connected */
abstract handshake_handler() : HandshakeHandler; /* only valid when connected */
abstract ping() : {
native: number,
javascript?: number
export const CommandOptionDefaults: CommandOptions = {
flagset: [],
process_result: true,
timeout: 1000
};
}
export namespace voice {
export enum PlayerState {
PREBUFFERING,
PLAYING,
BUFFERING,
STOPPING,
STOPPED
export type ConnectionStateListener = (old_state: ConnectionState, new_state: ConnectionState) => any;
export abstract class AbstractServerConnection {
readonly client: ConnectionHandler;
readonly command_helper: CommandHelper;
protected constructor(client: ConnectionHandler) {
this.client = client;
this.command_helper = new CommandHelper(this);
}
/* resolved as soon a connection has been established. This does not means that the authentication had yet been done! */
abstract connect(address: ServerAddress, handshake: HandshakeHandler, timeout?: number) : Promise<void>;
abstract connected() : boolean;
abstract disconnect(reason?: string) : Promise<void>;
abstract support_voice() : boolean;
abstract voice_connection() : voice.AbstractVoiceConnection | undefined;
abstract command_handler_boss() : AbstractCommandHandlerBoss;
abstract send_command(command: string, data?: any | any[], options?: CommandOptions) : Promise<CommandResult>;
abstract get onconnectionstatechanged() : ConnectionStateListener;
abstract set onconnectionstatechanged(listener: ConnectionStateListener);
abstract remote_address() : ServerAddress; /* only valid when connected */
abstract handshake_handler() : HandshakeHandler; /* only valid when connected */
abstract ping() : {
native: number,
javascript?: number
};
}
export type LatencySettings = {
min_buffer: number; /* milliseconds */
max_buffer: number; /* milliseconds */
export namespace voice {
export enum PlayerState {
PREBUFFERING,
PLAYING,
BUFFERING,
STOPPING,
STOPPED
}
export type LatencySettings = {
min_buffer: number; /* milliseconds */
max_buffer: number; /* milliseconds */
}
export interface VoiceClient {
client_id: number;
callback_playback: () => any;
callback_stopped: () => any;
callback_state_changed: (new_state: PlayerState) => any;
get_state() : PlayerState;
get_volume() : number;
set_volume(volume: number) : void;
abort_replay();
support_latency_settings() : boolean;
reset_latency_settings();
latency_settings(settings?: LatencySettings) : LatencySettings;
support_flush() : boolean;
flush();
}
export abstract class AbstractVoiceConnection {
readonly connection: AbstractServerConnection;
protected constructor(connection: AbstractServerConnection) {
this.connection = connection;
}
abstract connected() : boolean;
abstract encoding_supported(codec: number) : boolean;
abstract decoding_supported(codec: number) : boolean;
abstract register_client(client_id: number) : VoiceClient;
abstract available_clients() : VoiceClient[];
abstract unregister_client(client: VoiceClient) : Promise<void>;
abstract voice_recorder() : RecorderProfile;
abstract acquire_voice_recorder(recorder: RecorderProfile | undefined) : Promise<void>;
abstract get_encoder_codec() : number;
abstract set_encoder_codec(codec: number);
}
}
export interface VoiceClient {
client_id: number;
callback_playback: () => any;
callback_stopped: () => any;
callback_state_changed: (new_state: PlayerState) => any;
get_state() : PlayerState;
get_volume() : number;
set_volume(volume: number) : void;
abort_replay();
support_latency_settings() : boolean;
reset_latency_settings();
latency_settings(settings?: LatencySettings) : LatencySettings;
support_flush() : boolean;
flush();
export class ServerCommand {
command: string;
arguments: any[];
}
export abstract class AbstractVoiceConnection {
export abstract class AbstractCommandHandler {
readonly connection: AbstractServerConnection;
handler_boss: AbstractCommandHandlerBoss | undefined;
volatile_handler_boss: boolean = false; /* if true than the command handler could be registered twice to two or more handlers */
ignore_consumed: boolean = false;
protected constructor(connection: AbstractServerConnection) {
this.connection = connection;
}
abstract connected() : boolean;
abstract encoding_supported(codec: number) : boolean;
abstract decoding_supported(codec: number) : boolean;
abstract register_client(client_id: number) : VoiceClient;
abstract available_clients() : VoiceClient[];
abstract unregister_client(client: VoiceClient) : Promise<void>;
abstract voice_recorder() : RecorderProfile;
abstract acquire_voice_recorder(recorder: RecorderProfile | undefined) : Promise<void>;
abstract get_encoder_codec() : number;
abstract set_encoder_codec(codec: number);
}
}
export class ServerCommand {
command: string;
arguments: any[];
}
export abstract class AbstractCommandHandler {
readonly connection: AbstractServerConnection;
handler_boss: AbstractCommandHandlerBoss | undefined;
volatile_handler_boss: boolean = false; /* if true than the command handler could be registered twice to two or more handlers */
ignore_consumed: boolean = false;
protected constructor(connection: AbstractServerConnection) {
this.connection = connection;
/**
* @return If the command should be consumed
*/
abstract handle_command(command: ServerCommand) : boolean;
}
/**
* @return If the command should be consumed
*/
abstract handle_command(command: ServerCommand) : boolean;
}
export interface SingleCommandHandler {
name?: string;
command?: string;
timeout?: number;
export interface SingleCommandHandler {
name?: string;
command?: string;
timeout?: number;
/* if the return is true then the command handler will be removed */
function: (command: ServerCommand) => boolean;
}
export abstract class AbstractCommandHandlerBoss {
readonly connection: AbstractServerConnection;
protected command_handlers: AbstractCommandHandler[] = [];
/* TODO: Timeout */
protected single_command_handler: SingleCommandHandler[] = [];
protected constructor(connection: AbstractServerConnection) {
this.connection = connection;
/* if the return is true then the command handler will be removed */
function: (command: ServerCommand) => boolean;
}
destroy() {
this.command_handlers = undefined;
this.single_command_handler = undefined;
}
export abstract class AbstractCommandHandlerBoss {
readonly connection: AbstractServerConnection;
protected command_handlers: AbstractCommandHandler[] = [];
/* TODO: Timeout */
protected single_command_handler: SingleCommandHandler[] = [];
register_handler(handler: AbstractCommandHandler) {
if(!handler.volatile_handler_boss && handler.handler_boss)
throw "handler already registered";
this.command_handlers.remove(handler); /* just to be sure */
this.command_handlers.push(handler);
handler.handler_boss = this;
}
unregister_handler(handler: AbstractCommandHandler) {
if(!handler.volatile_handler_boss && handler.handler_boss !== this) {
console.warn(tr("Tried to unregister command handler which does not belong to the handler boss"));
return;
protected constructor(connection: AbstractServerConnection) {
this.connection = connection;
}
this.command_handlers.remove(handler);
handler.handler_boss = undefined;
}
destroy() {
this.command_handlers = undefined;
this.single_command_handler = undefined;
}
register_handler(handler: AbstractCommandHandler) {
if(!handler.volatile_handler_boss && handler.handler_boss)
throw "handler already registered";
register_single_handler(handler: SingleCommandHandler) {
this.single_command_handler.push(handler);
}
this.command_handlers.remove(handler); /* just to be sure */
this.command_handlers.push(handler);
handler.handler_boss = this;
}
remove_single_handler(handler: SingleCommandHandler) {
this.single_command_handler.remove(handler);
}
handlers() : AbstractCommandHandler[] {
return this.command_handlers;
}
invoke_handle(command: ServerCommand) : boolean {
let flag_consumed = false;
for(const handler of this.command_handlers) {
try {
if(!flag_consumed || handler.ignore_consumed)
flag_consumed = flag_consumed || handler.handle_command(command);
} catch(error) {
console.error(tr("Failed to invoke command handler. Invocation results in an exception: %o"), error);
unregister_handler(handler: AbstractCommandHandler) {
if(!handler.volatile_handler_boss && handler.handler_boss !== this) {
console.warn(tr("Tried to unregister command handler which does not belong to the handler boss"));
return;
}
this.command_handlers.remove(handler);
handler.handler_boss = undefined;
}
for(const handler of [...this.single_command_handler]) {
if(handler.command && handler.command != command.command)
continue;
try {
if(handler.function(command))
this.single_command_handler.remove(handler);
} catch(error) {
console.error(tr("Failed to invoke single command handler. Invocation results in an exception: %o"), error);
register_single_handler(handler: SingleCommandHandler) {
this.single_command_handler.push(handler);
}
remove_single_handler(handler: SingleCommandHandler) {
this.single_command_handler.remove(handler);
}
handlers() : AbstractCommandHandler[] {
return this.command_handlers;
}
invoke_handle(command: ServerCommand) : boolean {
let flag_consumed = false;
for(const handler of this.command_handlers) {
try {
if(!flag_consumed || handler.ignore_consumed)
flag_consumed = flag_consumed || handler.handle_command(command);
} catch(error) {
console.error(tr("Failed to invoke command handler. Invocation results in an exception: %o"), error);
}
}
}
return flag_consumed;
for(const handler of [...this.single_command_handler]) {
if(handler.command && handler.command != command.command)
continue;
try {
if(handler.function(command))
this.single_command_handler.remove(handler);
} catch(error) {
console.error(tr("Failed to invoke single command handler. Invocation results in an exception: %o"), error);
}
}
return flag_consumed;
}
}
}

19
shared/js/connection/HandshakeHandler.ts
View file

@ -1,15 +1,4 @@
import {AbstractServerConnection} from "./ConnectionBase";
import {ConnectParameters, DisconnectReason} from "../ConnectionHandler";
import {profiles} from "../profiles/ConnectionProfile";
import {profiles as iprofiles} from "../profiles/Identity";
import {profiles as tiprofiles} from "../profiles/identities/TeamSpeakIdentity";
import {native_client} from "../main";
import {settings} from "../settings";
import {CommandResult} from "./ServerConnectionDeclaration";
export namespace connection {
import identities = iprofiles.identities;
namespace connection {
export interface HandshakeIdentityHandler {
connection: AbstractServerConnection;
@ -59,7 +48,7 @@ export namespace connection {
on_teamspeak() {
const type = this.profile.selected_type();
if(type == identities.IdentitifyType.TEAMSPEAK)
if(type == profiles.identities.IdentitifyType.TEAMSPEAK)
this.handshake_finished();
else {
@ -133,8 +122,8 @@ export namespace connection {
}
/* required to keep compatibility */
if(this.profile.selected_type() === identities.IdentitifyType.TEAMSPEAK) {
data["client_key_offset"] = (this.profile.selected_identity() as tiprofiles.identities.TeaSpeakIdentity).hash_number;
if(this.profile.selected_type() === profiles.identities.IdentitifyType.TEAMSPEAK) {
data["client_key_offset"] = (this.profile.selected_identity() as profiles.identities.TeaSpeakIdentity).hash_number;
}
this.connection.send_command("clientinit", data).catch(error => {

22
shared/js/connection/ServerConnectionDeclaration.ts
View file

@ -1,6 +1,4 @@
import {LaterPromise} from "../utils/helpers";
export enum ErrorID {
enum ErrorID {
NOT_IMPLEMENTED = 0x2,
COMMAND_NOT_FOUND = 0x100,
@ -17,7 +15,7 @@ export enum ErrorID {
CONVERSATION_IS_PRIVATE = 0x2202
}
export class CommandResult {
class CommandResult {
success: boolean;
id: number;
message: string;
@ -37,39 +35,39 @@ export class CommandResult {
}
}
export interface ClientNameInfo {
interface ClientNameInfo {
//cluid=tYzKUryn\/\/Y8VBMf8PHUT6B1eiE= name=Exp clname=Exp cldbid=9
client_unique_id: string;
client_nickname: string;
client_database_id: number;
}
export interface ClientNameFromUid {
interface ClientNameFromUid {
promise: LaterPromise<ClientNameInfo[]>,
keys: string[],
response: ClientNameInfo[]
}
export interface ServerGroupClient {
interface ServerGroupClient {
client_nickname: string;
client_unique_identifier: string;
client_database_id: number;
}
export interface QueryListEntry {
interface QueryListEntry {
username: string;
unique_id: string;
bounded_server: number;
}
export interface QueryList {
interface QueryList {
flag_own: boolean;
flag_all: boolean;
queries: QueryListEntry[];
}
export interface Playlist {
interface Playlist {
playlist_id: number;
playlist_bot_id: number;
playlist_title: string;
@ -85,7 +83,7 @@ export interface Playlist {
needed_power_song_remove: number;
}
export interface PlaylistInfo {
interface PlaylistInfo {
playlist_id: number,
playlist_title: string,
playlist_description: string,
@ -102,7 +100,7 @@ export interface PlaylistInfo {
playlist_max_songs: number
}
export interface PlaylistSong {
interface PlaylistSong {
song_id: number;
song_previous_song_id: number;
song_invoker: string;

2
shared/js/crypto/asn1.ts
View file

@ -14,7 +14,7 @@
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
export namespace asn1 {
namespace asn1 {
declare class Int10 {
constructor(value?: any);

2
shared/js/crypto/crc32.ts
View file

@ -1,4 +1,4 @@
export class Crc32 {
class Crc32 {
private static readonly lookup = [
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,

2
shared/js/crypto/hex.ts
View file

@ -1,4 +1,4 @@
export namespace hex {
namespace hex {
export function encode(buffer) {
let hexCodes = [];
let view = new DataView(buffer);

2
shared/js/crypto/sha.ts
View file

@ -10,7 +10,7 @@ interface Window {
}
*/
export namespace sha {
namespace sha {
/*
* [js-sha1]{@link https://github.com/emn178/js-sha1}
*

8
shared/js/crypto/uid.ts
View file

@ -1,8 +0,0 @@
export function guid() {
function s4() {
return Math.floor((1 + Math.random()) * 0x10000)
.toString(16)
.substring(1);
}
return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
}

2
shared/js/dns.ts
View file

@ -1,4 +1,4 @@
export namespace dns {
namespace dns {
export interface AddressTarget {
target_ip: string;
target_port?: number;

6
shared/js/events.ts
View file

@ -1,8 +1,4 @@
import {guid} from "./crypto/uid";
import {PlaylistSong} from "./connection/ServerConnectionDeclaration";
import {MusicClientEntry, SongInfo} from "./channel-tree/client";
export namespace events {
namespace events {
export interface EventConvert<All> {
as<T extends keyof All>() : All[T];
}

3
shared/js/i18n/country.ts
View file

@ -1,4 +1,5 @@
export namespace i18n {
namespace i18n {
interface CountryInfo {
name: string;
alpha_2: string;

15
shared/js/i18n/localize.ts
View file

@ -1,10 +1,13 @@
import {guid} from "../crypto/uid";
import {log, LogCategory} from "../log";
import {MessageHelper} from "../ui/frames/chat";
import {StaticSettings} from "../settings";
import {createErrorModal} from "../ui/elements/modal";
function guid() {
function s4() {
return Math.floor((1 + Math.random()) * 0x10000)
.toString(16)
.substring(1);
}
return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
}
export namespace i18n {
namespace i18n {
export interface TranslationKey {
message: string;
line?: number;

6
shared/js/log.ts
View file

@ -1,8 +1,6 @@
//Used by CertAccept popup
import {settings} from "./settings";
export enum LogCategory {
enum LogCategory {
CHANNEL,
CHANNEL_PROPERTIES, /* separating channel and channel properties because on channel init logging is a big bottleneck */
CLIENT,
@ -21,7 +19,7 @@ export enum LogCategory {
DNS
}
export namespace log {
namespace log {
export enum LogType {
TRACE,
DEBUG,

46
shared/js/main.ts
View file

@ -1,18 +1,19 @@
/// <reference path="ui/frames/chat.ts" />
/// <reference path="ui/modal/ModalConnect.ts" />
/// <reference path="ui/modal/ModalCreateChannel.ts" />
/// <reference path="ui/modal/ModalBanClient.ts" />
/// <reference path="ui/modal/ModalYesNo.ts" />
/// <reference path="ui/modal/ModalBanList.ts" />
/// <reference path="settings.ts" />
/// <reference path="log.ts" />
/// <reference path="PPTListener.ts" />
import spawnYesNo = Modals.spawnYesNo;
import {ConnectionHandler} from "./ConnectionHandler";
import {bipc} from "./BrowserIPC";
import {log, LogCategory} from "./log";
import {profiles} from "./profiles/ConnectionProfile";
import {Modals} from "./ui/modal/ModalConnect";
import {settings, Settings} from "./settings";
import {i18n} from "./i18n/localize";
import {createInfoModal} from "./ui/elements/modal";
import {MessageHelper} from "./ui/frames/chat";
export const js_render = window.jsrender || $;
export const native_client = window.require !== undefined;
const js_render = window.jsrender || $;
const native_client = window.require !== undefined;
export function getUserMediaFunctionPromise() : (constraints: MediaStreamConstraints) => Promise<MediaStream> {
function getUserMediaFunctionPromise() : (constraints: MediaStreamConstraints) => Promise<MediaStream> {
if('mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices)
return constraints => navigator.mediaDevices.getUserMedia(constraints);
@ -23,12 +24,11 @@ export function getUserMediaFunctionPromise() : (constraints: MediaStreamConstra
return constraints => new Promise<MediaStream>((resolve, reject) => _callbacked_function(constraints, resolve, reject));
}
export interface Window {
interface Window {
open_connected_question: () => Promise<boolean>;
}
export declare const nodeRequire: typeof require;
export function setup_close() {
function setup_close() {
window.onbeforeunload = event => {
if(profiles.requires_save())
profiles.save();
@ -50,7 +50,7 @@ export function setup_close() {
}));
const exit = () => {
const {remote} = nodeRequire('electron');
const {remote} = require('electron');
remote.getCurrentWindow().close();
};
@ -80,8 +80,8 @@ export function setup_close() {
};
}
export declare function moment(...arguments) : any;
export function setup_jsrender() : boolean {
declare function moment(...arguments) : any;
function setup_jsrender() : boolean {
if(!js_render) {
loader.critical_error("Missing jsrender extension!");
return false;
@ -115,7 +115,7 @@ export function setup_jsrender() : boolean {
return true;
}
export async function initialize() {
async function initialize() {
Settings.initialize();
try {
@ -129,7 +129,7 @@ export async function initialize() {
bipc.setup();
}
export async function initialize_app() {
async function initialize_app() {
try { //Initialize main template
const main = $("#tmpl_main").renderTag({
multi_session: !settings.static_global(Settings.KEY_DISABLE_MULTI_SESSION),
@ -180,7 +180,7 @@ export async function initialize_app() {
setup_close();
}
export function str2ab8(str) {
function str2ab8(str) {
const buf = new ArrayBuffer(str.length);
const bufView = new Uint8Array(buf);
for (let i = 0, strLen = str.length; i < strLen; i++) {
@ -190,7 +190,7 @@ export function str2ab8(str) {
}
/* FIXME Dont use atob, because it sucks for non UTF-8 tings */
export function arrayBufferBase64(base64: string) {
function arrayBufferBase64(base64: string) {
base64 = atob(base64);
const buf = new ArrayBuffer(base64.length);
const bufView = new Uint8Array(buf);
@ -200,7 +200,7 @@ export function arrayBufferBase64(base64: string) {
return buf;
}
export function base64_encode_ab(source: ArrayBufferLike) {
function base64_encode_ab(source: ArrayBufferLike) {
const encodings = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let base64 = "";

21
shared/js/permission/GroupManager.ts
View file

@ -1,24 +1,17 @@
/// <reference path="../connection/ConnectionBase.ts" />
import {LaterPromise} from "../utils/helpers";
import {PermissionManager, PermissionValue} from "./PermissionManager";
import {AbstractCommandHandler, ServerCommand} from "../connection/ConnectionBase";
import {ConnectionHandler} from "../ConnectionHandler";
import {log, LogCategory} from "../log";
import {CommandResult} from "../connection/ServerConnectionDeclaration";
export enum GroupType {
enum GroupType {
QUERY,
TEMPLATE,
NORMAL
}
export enum GroupTarget {
enum GroupTarget {
SERVER,
CHANNEL
}
export class GroupProperties {
class GroupProperties {
iconid: number = 0;
sortid: number = 0;
@ -26,12 +19,12 @@ export class GroupProperties {
namemode: number = 0;
}
export class GroupPermissionRequest {
class GroupPermissionRequest {
group_id: number;
promise: LaterPromise<PermissionValue[]>;
}
export class Group {
class Group {
properties: GroupProperties = new GroupProperties();
readonly handle: GroupManager;
@ -70,7 +63,7 @@ export class Group {
}
}
export class GroupManager extends AbstractCommandHandler {
class GroupManager extends connection.AbstractCommandHandler {
readonly handle: ConnectionHandler;
serverGroups: Group[] = [];
@ -90,7 +83,7 @@ export class GroupManager extends AbstractCommandHandler {
this.channelGroups = undefined;
}
handle_command(command: ServerCommand): boolean {
handle_command(command: connection.ServerCommand): boolean {
switch (command.command) {
case "notifyservergrouplist":
case "notifychannelgrouplist":

27
shared/js/permission/PermissionManager.ts
View file

@ -2,14 +2,7 @@
/// <reference path="../connection/ConnectionBase.ts" />
/// <reference path="../i18n/localize.ts" />
import {ConnectionHandler} from "../ConnectionHandler";
import {log, LogCategory} from "../log";
import {LaterPromise} from "../utils/helpers";
import {AbstractCommandHandler, ServerCommand} from "../connection/ConnectionBase";
import LogType = log.LogType;
import {CommandResult, ErrorID} from "../connection/ServerConnectionDeclaration";
export enum PermissionType {
enum PermissionType {
B_SERVERINSTANCE_HELP_VIEW = "b_serverinstance_help_view",
B_SERVERINSTANCE_VERSION_VIEW = "b_serverinstance_version_view",
B_SERVERINSTANCE_INFO_VIEW = "b_serverinstance_info_view",
@ -359,7 +352,7 @@ export enum PermissionType {
I_FT_QUOTA_MB_UPLOAD_PER_CLIENT = "i_ft_quota_mb_upload_per_client"
}
export class PermissionInfo {
class PermissionInfo {
name: string;
id: number;
description: string;
@ -370,21 +363,21 @@ export class PermissionInfo {
}
}
export class PermissionGroup {
class PermissionGroup {
begin: number;
end: number;
deep: number;
name: string;
}
export class GroupedPermissions {
class GroupedPermissions {
group: PermissionGroup;
permissions: PermissionInfo[];
children: GroupedPermissions[];
parent: GroupedPermissions;
}
export class PermissionValue {
class PermissionValue {
readonly type: PermissionInfo;
value: number;
flag_skip: boolean;
@ -418,13 +411,13 @@ export class PermissionValue {
}
}
export class NeededPermissionValue extends PermissionValue {
class NeededPermissionValue extends PermissionValue {
constructor(type, value) {
super(type, value);
}
}
export namespace permissions {
namespace permissions {
export type PermissionRequestKeys = {
client_id?: number;
channel_id?: number;
@ -480,13 +473,13 @@ export namespace permissions {
}
}
export type RequestLists =
type RequestLists =
"requests_channel_permissions" |
"requests_client_permissions" |
"requests_client_channel_permissions" |
"requests_playlist_permissions" |
"requests_playlist_client_permissions";
export class PermissionManager extends AbstractCommandHandler {
class PermissionManager extends connection.AbstractCommandHandler {
readonly handle: ConnectionHandler;
permissionList: PermissionInfo[] = [];
@ -610,7 +603,7 @@ export class PermissionManager extends AbstractCommandHandler {
this._cacheNeededPermissions = undefined;
}
handle_command(command: ServerCommand): boolean {
handle_command(command: connection.ServerCommand): boolean {
switch (command.command) {
case "notifyclientneededpermissions":
this.onNeededPermissions(command.arguments);

477
shared/js/profiles/ConnectionProfile.ts
View file

@ -1,260 +1,251 @@
import {MessageHelper} from "../ui/frames/chat";
import {createErrorModal} from "../ui/elements/modal";
import {guid} from "../crypto/uid";
import {decode_identity, IdentitifyType, Identity} from "./Identity";
import {static_forum_identity} from "./identities/TeaForumIdentity";
import {TeaSpeakIdentity} from "./identities/TeamSpeakIdentity";
import {AbstractServerConnection} from "../connection/ConnectionBase";
import {connection} from "../connection/HandshakeHandler";
namespace profiles {
export class ConnectionProfile {
id: string;
import HandshakeIdentityHandler = connection.HandshakeIdentityHandler;
profile_name: string;
default_username: string;
default_password: string;
export class ConnectionProfile {
id: string;
selected_identity_type: string = "unset";
identities: { [key: string]: identities.Identity } = {};
profile_name: string;
default_username: string;
default_password: string;
selected_identity_type: string = "unset";
identities: { [key: string]: Identity } = {};
constructor(id: string) {
this.id = id;
}
connect_username(): string {
if (this.default_username && this.default_username !== "Another TeaSpeak user")
return this.default_username;
let selected = this.selected_identity();
let name = selected ? selected.fallback_name() : undefined;
return name || "Another TeaSpeak user";
}
selected_identity(current_type?: IdentitifyType): Identity {
if (!current_type)
current_type = this.selected_type();
if (current_type === undefined)
return undefined;
if (current_type == IdentitifyType.TEAFORO) {
return static_forum_identity();
} else if (current_type == IdentitifyType.TEAMSPEAK || current_type == IdentitifyType.NICKNAME) {
return this.identities[IdentitifyType[current_type].toLowerCase()];
constructor(id: string) {
this.id = id;
}
connect_username(): string {
if (this.default_username && this.default_username !== "Another TeaSpeak user")
return this.default_username;
let selected = this.selected_identity();
let name = selected ? selected.fallback_name() : undefined;
return name || "Another TeaSpeak user";
}
selected_identity(current_type?: identities.IdentitifyType): identities.Identity {
if (!current_type)
current_type = this.selected_type();
if (current_type === undefined)
return undefined;
if (current_type == identities.IdentitifyType.TEAFORO) {
return identities.static_forum_identity();
} else if (current_type == identities.IdentitifyType.TEAMSPEAK || current_type == identities.IdentitifyType.NICKNAME) {
return this.identities[identities.IdentitifyType[current_type].toLowerCase()];
}
return undefined;
}
selected_type?(): identities.IdentitifyType {
return this.selected_identity_type ? identities.IdentitifyType[this.selected_identity_type.toUpperCase()] : undefined;
}
set_identity(type: identities.IdentitifyType, identity: identities.Identity) {
this.identities[identities.IdentitifyType[type].toLowerCase()] = identity;
}
spawn_identity_handshake_handler?(connection: connection.AbstractServerConnection): connection.HandshakeIdentityHandler {
const identity = this.selected_identity();
if (!identity)
return undefined;
return identity.spawn_identity_handshake_handler(connection);
}
encode?(): string {
const identity_data = {};
for (const key in this.identities)
if (this.identities[key])
identity_data[key] = this.identities[key].encode();
return JSON.stringify({
version: 1,
username: this.default_username,
password: this.default_password,
profile_name: this.profile_name,
identity_type: this.selected_identity_type,
identity_data: identity_data,
id: this.id
});
}
valid(): boolean {
const identity = this.selected_identity();
if (!identity || !identity.valid()) return false;
return true;
}
}
async function decode_profile(data): Promise<ConnectionProfile | string> {
data = JSON.parse(data);
if (data.version !== 1)
return "invalid version";
const result: ConnectionProfile = new ConnectionProfile(data.id);
result.default_username = data.username;
result.default_password = data.password;
result.profile_name = data.profile_name;
result.selected_identity_type = (data.identity_type || "").toLowerCase();
if (data.identity_data) {
for (const key in data.identity_data) {
const type = identities.IdentitifyType[key.toUpperCase() as string];
const _data = data.identity_data[key];
if (type == undefined) continue;
const identity = await identities.decode_identity(type, _data);
if (identity == undefined) continue;
result.identities[key.toLowerCase()] = identity;
}
}
return result;
}
interface ProfilesData {
version: number;
profiles: string[];
}
let available_profiles: ConnectionProfile[] = [];
export async function load() {
available_profiles = [];
const profiles_json = localStorage.getItem("profiles");
let profiles_data: ProfilesData = (() => {
try {
return profiles_json ? JSON.parse(profiles_json) : {version: 0} as any;
} catch (error) {
debugger;
console.error(tr("Invalid profile json! Resetting profiles :( (%o)"), profiles_json);
createErrorModal(tr("Profile data invalid"), MessageHelper.formatMessage(tr("The profile data is invalid.{:br:}This might cause data loss."))).open();
return {version: 0};
}
})();
if (profiles_data.version === 0) {
profiles_data = {
version: 1,
profiles: []
};
}
if (profiles_data.version == 1) {
for (const profile_data of profiles_data.profiles) {
const profile = await decode_profile(profile_data);
if (typeof (profile) === 'string') {
console.error(tr("Failed to load profile. Reason: %s, Profile data: %s"), profile, profiles_data);
continue;
}
available_profiles.push(profile);
}
}
if (!find_profile("default")) { //Create a default profile and teaforo profile
{
const profile = create_new_profile("default", "default");
profile.default_password = "";
profile.default_username = "";
profile.profile_name = "Default Profile";
/* generate default identity */
try {
const identity = await identities.TeaSpeakIdentity.generate_new();
let active = true;
setTimeout(() => {
active = false;
}, 1000);
await identity.improve_level(8, 1, () => active);
profile.set_identity(identities.IdentitifyType.TEAMSPEAK, identity);
profile.selected_identity_type = identities.IdentitifyType[identities.IdentitifyType.TEAMSPEAK];
} catch (error) {
createErrorModal(tr("Failed to generate default identity"), tr("Failed to generate default identity!<br>Please manually generate the identity within your settings => profiles")).open();
}
}
{ /* forum identity (works only when connected to the forum) */
const profile = create_new_profile("TeaSpeak Forum", "teaforo");
profile.default_password = "";
profile.default_username = "";
profile.profile_name = "TeaSpeak Forum profile";
profile.set_identity(identities.IdentitifyType.TEAFORO, identities.static_forum_identity());
profile.selected_identity_type = identities.IdentitifyType[identities.IdentitifyType.TEAFORO];
}
save();
}
}
export function create_new_profile(name: string, id?: string): ConnectionProfile {
const profile = new ConnectionProfile(id || guid());
profile.profile_name = name;
profile.default_username = "";
available_profiles.push(profile);
return profile;
}
let _requires_save = false;
export function save() {
const profiles: string[] = [];
for (const profile of available_profiles)
profiles.push(profile.encode());
const data = JSON.stringify({
version: 1,
profiles: profiles
});
localStorage.setItem("profiles", data);
}
export function mark_need_save() {
_requires_save = true;
}
export function requires_save(): boolean {
return _requires_save;
}
export function profiles(): ConnectionProfile[] {
return available_profiles;
}
export function find_profile(id: string): ConnectionProfile | undefined {
for (const profile of profiles())
if (profile.id == id)
return profile;
return undefined;
}
selected_type?(): IdentitifyType {
return this.selected_identity_type ? IdentitifyType[this.selected_identity_type.toUpperCase()] : undefined;
export function find_profile_by_name(name: string): ConnectionProfile | undefined {
name = name.toLowerCase();
for (const profile of profiles())
if ((profile.profile_name || "").toLowerCase() == name)
return profile;
return undefined;
}
set_identity(type: IdentitifyType, identity: Identity) {
this.identities[IdentitifyType[type].toLowerCase()] = identity;
export function default_profile(): ConnectionProfile {
return find_profile("default");
}
spawn_identity_handshake_handler?(connection: AbstractServerConnection): HandshakeIdentityHandler {
const identity = this.selected_identity();
if (!identity)
return undefined;
return identity.spawn_identity_handshake_handler(connection);
}
encode?(): string {
const identity_data = {};
for (const key in this.identities)
if (this.identities[key])
identity_data[key] = this.identities[key].encode();
return JSON.stringify({
version: 1,
username: this.default_username,
password: this.default_password,
profile_name: this.profile_name,
identity_type: this.selected_identity_type,
identity_data: identity_data,
id: this.id
});
}
valid(): boolean {
const identity = this.selected_identity();
if (!identity || !identity.valid()) return false;
return true;
}
}
async function decode_profile(data): Promise<ConnectionProfile | string> {
data = JSON.parse(data);
if (data.version !== 1)
return "invalid version";
const result: ConnectionProfile = new ConnectionProfile(data.id);
result.default_username = data.username;
result.default_password = data.password;
result.profile_name = data.profile_name;
result.selected_identity_type = (data.identity_type || "").toLowerCase();
if (data.identity_data) {
for (const key in data.identity_data) {
const type = IdentitifyType[key.toUpperCase() as string];
const _data = data.identity_data[key];
if (type == undefined) continue;
const identity = await decode_identity(type, _data);
if (identity == undefined) continue;
result.identities[key.toLowerCase()] = identity;
export function set_default_profile(profile: ConnectionProfile) {
const old_default = default_profile();
if (old_default && old_default != profile) {
old_default.id = guid();
}
profile.id = "default";
return old_default;
}
return result;
}
interface ProfilesData {
version: number;
profiles: string[];
}
let available_profiles: ConnectionProfile[] = [];
export async function load() {
available_profiles = [];
const profiles_json = localStorage.getItem("profiles");
let profiles_data: ProfilesData = (() => {
try {
return profiles_json ? JSON.parse(profiles_json) : {version: 0} as any;
} catch (error) {
debugger;
console.error(tr("Invalid profile json! Resetting profiles :( (%o)"), profiles_json);
createErrorModal(tr("Profile data invalid"), MessageHelper.formatMessage(tr("The profile data is invalid.{:br:}This might cause data loss."))).open();
return {version: 0};
}
})();
if (profiles_data.version === 0) {
profiles_data = {
version: 1,
profiles: []
};
}
if (profiles_data.version == 1) {
for (const profile_data of profiles_data.profiles) {
const profile = await decode_profile(profile_data);
if (typeof (profile) === 'string') {
console.error(tr("Failed to load profile. Reason: %s, Profile data: %s"), profile, profiles_data);
continue;
}
available_profiles.push(profile);
}
}
if (!find_profile("default")) { //Create a default profile and teaforo profile
{
const profile = create_new_profile("default", "default");
profile.default_password = "";
profile.default_username = "";
profile.profile_name = "Default Profile";
/* generate default identity */
try {
const identity = await TeaSpeakIdentity.generate_new();
let active = true;
setTimeout(() => {
active = false;
}, 1000);
await identity.improve_level(8, 1, () => active);
profile.set_identity(IdentitifyType.TEAMSPEAK, identity);
profile.selected_identity_type = IdentitifyType[IdentitifyType.TEAMSPEAK];
} catch (error) {
createErrorModal(tr("Failed to generate default identity"), tr("Failed to generate default identity!<br>Please manually generate the identity within your settings => profiles")).open();
}
}
{ /* forum identity (works only when connected to the forum) */
const profile = create_new_profile("TeaSpeak Forum", "teaforo");
profile.default_password = "";
profile.default_username = "";
profile.profile_name = "TeaSpeak Forum profile";
profile.set_identity(IdentitifyType.TEAFORO, static_forum_identity());
profile.selected_identity_type = IdentitifyType[IdentitifyType.TEAFORO];
}
save();
export function delete_profile(profile: ConnectionProfile) {
available_profiles.remove(profile);
}
}
export function create_new_profile(name: string, id?: string): ConnectionProfile {
const profile = new ConnectionProfile(id || guid());
profile.profile_name = name;
profile.default_username = "";
available_profiles.push(profile);
return profile;
}
let _requires_save = false;
export function save() {
const profiles: string[] = [];
for (const profile of available_profiles)
profiles.push(profile.encode());
const data = JSON.stringify({
version: 1,
profiles: profiles
});
localStorage.setItem("profiles", data);
}
export function mark_need_save() {
_requires_save = true;
}
export function requires_save(): boolean {
return _requires_save;
}
export function profiles(): ConnectionProfile[] {
return available_profiles;
}
export function find_profile(id: string): ConnectionProfile | undefined {
for (const profile of profiles())
if (profile.id == id)
return profile;
return undefined;
}
export function find_profile_by_name(name: string): ConnectionProfile | undefined {
name = name.toLowerCase();
for (const profile of profiles())
if ((profile.profile_name || "").toLowerCase() == name)
return profile;
return undefined;
}
export function default_profile(): ConnectionProfile {
return find_profile("default");
}
export function set_default_profile(profile: ConnectionProfile) {
const old_default = default_profile();
if (old_default && old_default != profile) {
old_default.id = guid();
}
profile.id = "default";
return old_default;
}
export function delete_profile(profile: ConnectionProfile) {
available_profiles.remove(profile);
}

206
shared/js/profiles/Identity.ts
View file

@ -1,116 +1,110 @@
import {AbstractCommandHandler, AbstractServerConnection, ServerCommand} from "../connection/ConnectionBase";
import {connection} from "../connection/HandshakeHandler";
import HandshakeIdentityHandler = connection.HandshakeIdentityHandler;
import {NameIdentity} from "./identities/NameIdentity";
import {TeaForumIdentity} from "./identities/TeaForumIdentity";
import {TeaSpeakIdentity} from "./identities/TeamSpeakIdentity";
export enum IdentitifyType {
TEAFORO,
TEAMSPEAK,
NICKNAME
}
export interface Identity {
fallback_name(): string | undefined ;
uid() : string;
type() : IdentitifyType;
valid() : boolean;
encode?() : string;
decode(data: string) : Promise<void>;
spawn_identity_handshake_handler(connection: AbstractServerConnection) : HandshakeIdentityHandler;
}
export async function decode_identity(type: IdentitifyType, data: string) : Promise<Identity> {
let identity: Identity;
switch (type) {
case IdentitifyType.NICKNAME:
identity = new NameIdentity();
break;
case IdentitifyType.TEAFORO:
identity = new TeaForumIdentity(undefined);
break;
case IdentitifyType.TEAMSPEAK:
identity = new TeaSpeakIdentity(undefined, undefined);
break;
}
if(!identity)
return undefined;
try {
await identity.decode(data)
} catch(error) {
/* todo better error handling! */
console.error(error);
return undefined;
namespace profiles.identities {
export enum IdentitifyType {
TEAFORO,
TEAMSPEAK,
NICKNAME
}
return identity;
}
export interface Identity {
fallback_name(): string | undefined ;
uid() : string;
type() : IdentitifyType;
export function create_identity(type: IdentitifyType) {
let identity: Identity;
switch (type) {
case IdentitifyType.NICKNAME:
identity = new NameIdentity();
break;
case IdentitifyType.TEAFORO:
identity = new TeaForumIdentity(undefined);
break;
case IdentitifyType.TEAMSPEAK:
identity = new TeaSpeakIdentity(undefined, undefined);
break;
}
return identity;
}
valid() : boolean;
export class HandshakeCommandHandler<T extends AbstractHandshakeIdentityHandler> extends AbstractCommandHandler {
readonly handle: T;
encode?() : string;
decode(data: string) : Promise<void>;
constructor(connection: AbstractServerConnection, handle: T) {
super(connection);
this.handle = handle;
spawn_identity_handshake_handler(connection: connection.AbstractServerConnection) : connection.HandshakeIdentityHandler;
}
handle_command(command: ServerCommand): boolean {
if($.isFunction(this[command.command]))
this[command.command](command.arguments);
else if(command.command == "error") {
return false;
} else {
console.warn(tr("Received unknown command while handshaking (%o)"), command);
export async function decode_identity(type: IdentitifyType, data: string) : Promise<Identity> {
let identity: Identity;
switch (type) {
case IdentitifyType.NICKNAME:
identity = new NameIdentity();
break;
case IdentitifyType.TEAFORO:
identity = new TeaForumIdentity(undefined);
break;
case IdentitifyType.TEAMSPEAK:
identity = new TeaSpeakIdentity(undefined, undefined);
break;
}
if(!identity)
return undefined;
try {
await identity.decode(data)
} catch(error) {
/* todo better error handling! */
console.error(error);
return undefined;
}
return identity;
}
export function create_identity(type: IdentitifyType) {
let identity: Identity;
switch (type) {
case IdentitifyType.NICKNAME:
identity = new NameIdentity();
break;
case IdentitifyType.TEAFORO:
identity = new TeaForumIdentity(undefined);
break;
case IdentitifyType.TEAMSPEAK:
identity = new TeaSpeakIdentity(undefined, undefined);
break;
}
return identity;
}
export class HandshakeCommandHandler<T extends AbstractHandshakeIdentityHandler> extends connection.AbstractCommandHandler {
readonly handle: T;
constructor(connection: connection.AbstractServerConnection, handle: T) {
super(connection);
this.handle = handle;
}
handle_command(command: connection.ServerCommand): boolean {
if($.isFunction(this[command.command]))
this[command.command](command.arguments);
else if(command.command == "error") {
return false;
} else {
console.warn(tr("Received unknown command while handshaking (%o)"), command);
}
return true;
}
}
export abstract class AbstractHandshakeIdentityHandler implements connection.HandshakeIdentityHandler {
connection: connection.AbstractServerConnection;
protected callbacks: ((success: boolean, message?: string) => any)[] = [];
protected constructor(connection: connection.AbstractServerConnection) {
this.connection = connection;
}
register_callback(callback: (success: boolean, message?: string) => any) {
this.callbacks.push(callback);
}
abstract start_handshake();
protected trigger_success() {
for(const callback of this.callbacks)
callback(true);
}
protected trigger_fail(message: string) {
for(const callback of this.callbacks)
callback(false, message);
}
return true;
}
}
export abstract class AbstractHandshakeIdentityHandler implements connection.HandshakeIdentityHandler {
connection: AbstractServerConnection;
protected callbacks: ((success: boolean, message?: string) => any)[] = [];
protected constructor(connection: AbstractServerConnection) {
this.connection = connection;
}
register_callback(callback: (success: boolean, message?: string) => any) {
this.callbacks.push(callback);
}
abstract start_handshake();
protected trigger_success() {
for(const callback of this.callbacks)
callback(true);
}
protected trigger_fail(message: string) {
for(const callback of this.callbacks)
callback(false, message);
}
}

160
shared/js/profiles/identities/NameIdentity.ts
View file

@ -1,92 +1,88 @@
import {CommandResult} from "../../connection/ServerConnectionDeclaration";
import {log, LogCategory} from "../../log";
import {AbstractServerConnection} from "../../connection/ConnectionBase";
import {connection} from "../../connection/HandshakeHandler";
/// <reference path="../Identity.ts" />
import HandshakeIdentityHandler = connection.HandshakeIdentityHandler;
import {AbstractHandshakeIdentityHandler, HandshakeCommandHandler, IdentitifyType, Identity} from "../Identity";
namespace profiles.identities {
class NameHandshakeHandler extends AbstractHandshakeIdentityHandler {
readonly identity: NameIdentity;
handler: HandshakeCommandHandler<NameHandshakeHandler>;
class NameHandshakeHandler extends AbstractHandshakeIdentityHandler {
readonly identity: NameIdentity;
handler: HandshakeCommandHandler<NameHandshakeHandler>;
constructor(connection: connection.AbstractServerConnection, identity: profiles.identities.NameIdentity) {
super(connection);
this.identity = identity;
constructor(connection: AbstractServerConnection, identity: NameIdentity) {
super(connection);
this.identity = identity;
this.handler = new HandshakeCommandHandler(connection, this);
this.handler["handshakeidentityproof"] = () => this.trigger_fail("server requested unexpected proof");
}
this.handler = new HandshakeCommandHandler(connection, this);
this.handler["handshakeidentityproof"] = () => this.trigger_fail("server requested unexpected proof");
start_handshake() {
this.connection.command_handler_boss().register_handler(this.handler);
this.connection.send_command("handshakebegin", {
intention: 0,
authentication_method: this.identity.type(),
client_nickname: this.identity.name()
}).catch(error => {
log.error(LogCategory.IDENTITIES, tr("Failed to initialize name based handshake. Error: %o"), error);
if(error instanceof CommandResult)
error = error.extra_message || error.message;
this.trigger_fail("failed to execute begin (" + error + ")");
}).then(() => this.trigger_success());
}
protected trigger_fail(message: string) {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_fail(message);
}
protected trigger_success() {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_success();
}
}
start_handshake() {
this.connection.command_handler_boss().register_handler(this.handler);
this.connection.send_command("handshakebegin", {
intention: 0,
authentication_method: this.identity.type(),
client_nickname: this.identity.name()
}).catch(error => {
log.error(LogCategory.IDENTITIES, tr("Failed to initialize name based handshake. Error: %o"), error);
if(error instanceof CommandResult)
error = error.extra_message || error.message;
this.trigger_fail("failed to execute begin (" + error + ")");
}).then(() => this.trigger_success());
}
export class NameIdentity implements Identity {
private _name: string;
protected trigger_fail(message: string) {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_fail(message);
}
constructor(name?: string) {
this._name = name;
}
protected trigger_success() {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_success();
}
}
export class NameIdentity implements Identity {
private _name: string;
constructor(name?: string) {
this._name = name;
}
set_name(name: string) { this._name = name; }
name() : string { return this._name; }
fallback_name(): string | undefined {
return this._name;
}
uid(): string {
return btoa(this._name); //FIXME hash!
}
type(): IdentitifyType {
return IdentitifyType.NICKNAME;
}
valid(): boolean {
return this._name != undefined && this._name.length >= 5;
}
decode(data) : Promise<void> {
data = JSON.parse(data);
if(data.version !== 1)
throw "invalid version";
this._name = data["name"];
return;
}
encode?() : string {
return JSON.stringify({
version: 1,
name: this._name
});
}
spawn_identity_handshake_handler(connection: AbstractServerConnection) : HandshakeIdentityHandler {
return new NameHandshakeHandler(connection, this);
set_name(name: string) { this._name = name; }
name() : string { return this._name; }
fallback_name(): string | undefined {
return this._name;
}
uid(): string {
return btoa(this._name); //FIXME hash!
}
type(): IdentitifyType {
return IdentitifyType.NICKNAME;
}
valid(): boolean {
return this._name != undefined && this._name.length >= 5;
}
decode(data) : Promise<void> {
data = JSON.parse(data);
if(data.version !== 1)
throw "invalid version";
this._name = data["name"];
return;
}
encode?() : string {
return JSON.stringify({
version: 1,
name: this._name
});
}
spawn_identity_handshake_handler(connection: connection.AbstractServerConnection) : connection.HandshakeIdentityHandler {
return new NameHandshakeHandler(connection, this);
}
}
}

220
shared/js/profiles/identities/TeaForumIdentity.ts
View file

@ -1,126 +1,122 @@
import {AbstractServerConnection} from "../../connection/ConnectionBase";
import {log, LogCategory} from "../../log";
import {CommandResult} from "../../connection/ServerConnectionDeclaration";
import {forum} from "./teaspeak-forum";
import {connection} from "../../connection/HandshakeHandler";
import HandshakeIdentityHandler = connection.HandshakeIdentityHandler;
import {AbstractHandshakeIdentityHandler, HandshakeCommandHandler, IdentitifyType, Identity} from "../Identity";
/// <reference path="../Identity.ts" />
class TeaForumHandshakeHandler extends AbstractHandshakeIdentityHandler {
readonly identity: TeaForumIdentity;
handler: HandshakeCommandHandler<TeaForumHandshakeHandler>;
namespace profiles.identities {
class TeaForumHandshakeHandler extends AbstractHandshakeIdentityHandler {
readonly identity: TeaForumIdentity;
handler: HandshakeCommandHandler<TeaForumHandshakeHandler>;
constructor(connection: AbstractServerConnection, identity: TeaForumIdentity) {
super(connection);
this.identity = identity;
this.handler = new HandshakeCommandHandler(connection, this);
this.handler["handshakeidentityproof"] = this.handle_proof.bind(this);
constructor(connection: connection.AbstractServerConnection, identity: profiles.identities.TeaForumIdentity) {
super(connection);
this.identity = identity;
this.handler = new HandshakeCommandHandler(connection, this);
this.handler["handshakeidentityproof"] = this.handle_proof.bind(this);
}
start_handshake() {
this.connection.command_handler_boss().register_handler(this.handler);
this.connection.send_command("handshakebegin", {
intention: 0,
authentication_method: this.identity.type(),
data: this.identity.data().data_json()
}).catch(error => {
log.error(LogCategory.IDENTITIES, tr("Failed to initialize TeaForum based handshake. Error: %o"), error);
if(error instanceof CommandResult)
error = error.extra_message || error.message;
this.trigger_fail("failed to execute begin (" + error + ")");
});
}
private handle_proof(json) {
this.connection.send_command("handshakeindentityproof", {
proof: this.identity.data().data_sign()
}).catch(error => {
log.error(LogCategory.IDENTITIES, tr("Failed to proof the identity. Error: %o"), error);
if(error instanceof CommandResult)
error = error.extra_message || error.message;
this.trigger_fail("failed to execute proof (" + error + ")");
}).then(() => this.trigger_success());
}
protected trigger_fail(message: string) {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_fail(message);
}
protected trigger_success() {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_success();
}
}
start_handshake() {
this.connection.command_handler_boss().register_handler(this.handler);
this.connection.send_command("handshakebegin", {
intention: 0,
authentication_method: this.identity.type(),
data: this.identity.data().data_json()
}).catch(error => {
log.error(LogCategory.IDENTITIES, tr("Failed to initialize TeaForum based handshake. Error: %o"), error);
export class TeaForumIdentity implements Identity {
private readonly identity_data: forum.Data;
if(error instanceof CommandResult)
error = error.extra_message || error.message;
this.trigger_fail("failed to execute begin (" + error + ")");
});
valid() : boolean {
return !!this.identity_data && !this.identity_data.is_expired();
}
constructor(data: forum.Data) {
this.identity_data = data;
}
data() : forum.Data {
return this.identity_data;
}
decode(data) : Promise<void> {
data = JSON.parse(data);
if(data.version !== 1)
throw "invalid version";
return;
}
encode() : string {
return JSON.stringify({
version: 1
});
}
spawn_identity_handshake_handler(connection: connection.AbstractServerConnection) : connection.HandshakeIdentityHandler {
return new TeaForumHandshakeHandler(connection, this);
}
fallback_name(): string | undefined {
return this.identity_data ? this.identity_data.name() : undefined;
}
type(): profiles.identities.IdentitifyType {
return IdentitifyType.TEAFORO;
}
uid(): string {
//FIXME: Real UID!
return "TeaForo#" + ((this.identity_data ? this.identity_data.name() : "Another TeaSpeak user"));
}
}
let static_identity: TeaForumIdentity;
private handle_proof(json) {
this.connection.send_command("handshakeindentityproof", {
proof: this.identity.data().data_sign()
}).catch(error => {
log.error(LogCategory.IDENTITIES, tr("Failed to proof the identity. Error: %o"), error);
if(error instanceof CommandResult)
error = error.extra_message || error.message;
this.trigger_fail("failed to execute proof (" + error + ")");
}).then(() => this.trigger_success());
export function set_static_identity(identity: TeaForumIdentity) {
static_identity = identity;
}
protected trigger_fail(message: string) {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_fail(message);
export function update_forum() {
if(forum.logged_in() && (!static_identity || static_identity.data() !== forum.data())) {
static_identity = new TeaForumIdentity(forum.data());
} else {
static_identity = undefined;
}
}
protected trigger_success() {
this.connection.command_handler_boss().unregister_handler(this.handler);
super.trigger_success();
export function valid_static_forum_identity() : boolean {
return static_identity && static_identity.valid();
}
export function static_forum_identity() : TeaForumIdentity | undefined {
return static_identity;
}
}
export class TeaForumIdentity implements Identity {
private readonly identity_data: forum.Data;
valid() : boolean {
return !!this.identity_data && !this.identity_data.is_expired();
}
constructor(data: forum.Data) {
this.identity_data = data;
}
data() : forum.Data {
return this.identity_data;
}
decode(data) : Promise<void> {
data = JSON.parse(data);
if(data.version !== 1)
throw "invalid version";
return;
}
encode() : string {
return JSON.stringify({
version: 1
});
}
spawn_identity_handshake_handler(connection: AbstractServerConnection) : HandshakeIdentityHandler {
return new TeaForumHandshakeHandler(connection, this);
}
fallback_name(): string | undefined {
return this.identity_data ? this.identity_data.name() : undefined;
}
type(): IdentitifyType {
return IdentitifyType.TEAFORO;
}
uid(): string {
//FIXME: Real UID!
return "TeaForo#" + ((this.identity_data ? this.identity_data.name() : "Another TeaSpeak user"));
}
}
let static_identity: TeaForumIdentity;
export function set_static_identity(identity: TeaForumIdentity) {
static_identity = identity;
}
export function update_forum() {
if(forum.logged_in() && (!static_identity || static_identity.data() !== forum.data())) {
static_identity = new TeaForumIdentity(forum.data());
} else {
static_identity = undefined;
}
}
export function valid_static_forum_identity() : boolean {
return static_identity && static_identity.valid();
}
export function static_forum_identity() : TeaForumIdentity | undefined {
return static_identity;
}

1509
shared/js/profiles/identities/TeamSpeakIdentity.ts
View file

File diff suppressed because it is too large Load diff

23
shared/js/profiles/identities/teaspeak-forum.ts
View file

@ -1,11 +1,8 @@
import {Settings, settings} from "../../settings";
import {update_forum} from "./TeaForumIdentity";
declare interface Window {
interface Window {
grecaptcha: GReCaptcha;
}
export interface GReCaptcha {
interface GReCaptcha {
render(container: string | HTMLElement, parameters: {
sitekey: string;
theme?: "dark" | "light";
@ -21,10 +18,10 @@ export interface GReCaptcha {
reset(widget_id?: string);
}
export namespace forum {
namespace forum {
export namespace gcaptcha {
export async function initialize() {
if(typeof((window as any).grecaptcha) === "undefined") {
if(typeof(window.grecaptcha) === "undefined") {
let script = document.createElement("script");
script.async = true;
@ -53,7 +50,7 @@ export namespace forum {
}
}
if(typeof((window as any).grecaptcha) === "undefined")
if(typeof(window.grecaptcha) === "undefined")
throw tr("failed to load recaptcha");
}
@ -65,9 +62,9 @@ export namespace forum {
throw tr("initialisation failed");
}
if(container.attr("captcha-uuid"))
(window as any).grecaptcha.reset(container.attr("captcha-uuid"));
window.grecaptcha.reset(container.attr("captcha-uuid"));
else {
container.attr("captcha-uuid", (window as any).grecaptcha.render(container[0], {
container.attr("captcha-uuid", window.grecaptcha.render(container[0], {
"sitekey": key,
callback: callback_data
}));
@ -209,7 +206,7 @@ export namespace forum {
localStorage.setItem("teaspeak-forum-data", response["data"]);
localStorage.setItem("teaspeak-forum-sign", response["sign"]);
localStorage.setItem("teaspeak-forum-auth", response["auth-key"]);
update_forum();
profiles.identities.update_forum();
} catch(error) {
console.error(tr("Failed to parse forum given data: %o"), error);
return {
@ -269,7 +266,7 @@ export namespace forum {
_data = new Data(_data.auth_key, response["data"], response["sign"]);
localStorage.setItem("teaspeak-forum-data", response["data"]);
localStorage.setItem("teaspeak-forum-sign", response["sign"]);
update_forum();
profiles.identities.update_forum();
} catch(error) {
console.error(tr("Failed to parse forum given data: %o"), error);
throw tr("failed to parse data");
@ -323,7 +320,7 @@ export namespace forum {
localStorage.removeItem("teaspeak-forum-data");
localStorage.removeItem("teaspeak-forum-sign");
localStorage.removeItem("teaspeak-forum-auth");
update_forum();
profiles.identities.update_forum();
}
loader.register_task(loader.Stage.JAVASCRIPT_INITIALIZING, {

2
shared/js/proto.ts
View file

@ -1,3 +1,5 @@
//Used by CertAccept popup
interface Array<T> {
remove(elem?: T): boolean;
last?(): T;

15
shared/js/settings.ts
View file

@ -1,9 +1,6 @@
/// <reference path="ui/elements/modal.ts" />
//Used by CertAccept popup
import {log, LogCategory} from "./log";
import {createErrorModal} from "./ui/elements/modal";
if(typeof(customElements) !== "undefined") {
try {
class X_Properties extends HTMLElement {}
@ -17,7 +14,7 @@ if(typeof(customElements) !== "undefined") {
}
/* T = value type */
export interface SettingsKey<T> {
interface SettingsKey<T> {
key: string;
fallback_keys?: string | string[];
@ -28,7 +25,7 @@ export interface SettingsKey<T> {
require_restart?: boolean;
}
export class SettingsBase {
class SettingsBase {
protected static readonly UPDATE_DIRECT: boolean = true;
protected static transformStO?<T>(input?: string, _default?: T, default_type?: string) : T {
@ -80,7 +77,7 @@ export class SettingsBase {
}
}
export class StaticSettings extends SettingsBase {
class StaticSettings extends SettingsBase {
private static _instance: StaticSettings;
static get instance() : StaticSettings {
if(!this._instance)
@ -142,7 +139,7 @@ export class StaticSettings extends SettingsBase {
}
}
export class Settings extends StaticSettings {
class Settings extends StaticSettings {
static readonly KEY_USER_IS_NEW: SettingsKey<boolean> = {
key: 'user_is_new_user',
default_value: true
@ -436,7 +433,7 @@ export class Settings extends StaticSettings {
}
}
export class ServerSettings extends SettingsBase {
class ServerSettings extends SettingsBase {
private cacheServer = {};
private _server_unique_id: string;
private _server_save_worker: NodeJS.Timer;
@ -514,4 +511,4 @@ export class ServerSettings extends SettingsBase {
}
}
export let settings: Settings;
let settings: Settings;

8
shared/js/sound/Sounds.ts
View file

@ -1,8 +1,4 @@
import {settings} from "../settings";
import {log, LogCategory} from "../log";
import {ConnectionHandler} from "../ConnectionHandler";
export enum Sound {
enum Sound {
SOUND_TEST = "sound.test",
SOUND_EGG = "sound.egg",
@ -65,7 +61,7 @@ export enum Sound {
GROUP_CHANNEL_CHANGED_SELF = "group.channel.changed.self"
}
export namespace sound {
namespace sound {
export interface SoundHandle {
key: string;
filename: string;

4
shared/js/stats.ts
View file

@ -1,6 +1,4 @@
import {log, LogCategory} from "./log";
export namespace stats {
namespace stats {
const LOG_PREFIX = "[Statistics] ";
export enum CloseCodes {

81
shared/js/ui/channel-tree/channel.css
View file

@ -1,81 +0,0 @@
.channel-container {
display: flex;
flex-direction: column;
}
.channel-container .container-channel {
position: relative;
display: flex;
flex-direction: row;
justify-content: stretch;
width: 100%;
min-height: 16px;
align-items: center;
cursor: pointer;
}
.channel-container .container-channel .channel-type {
flex-grow: 0;
flex-shrink: 0;
margin-right: 2px;
}
.channel-container .container-channel .container-channel-name {
display: flex;
flex-direction: row;
flex-grow: 1;
flex-shrink: 1;
justify-content: left;
max-width: 100%;
/* important for the repetitive channel name! */
overflow-x: hidden;
height: 16px;
}
.channel-container .container-channel .container-channel-name.align-right {
justify-content: right;
}
.channel-container .container-channel .container-channel-name.align-center, .channel-container .container-channel .container-channel-name.align-repetitive {
justify-content: center;
}
.channel-container .container-channel .container-channel-name .channel-name {
align-self: center;
color: #828282;
min-width: 0;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.channel-container .container-channel .container-channel-name.align-repetitive .channel-name {
text-overflow: clip;
}
.channel-container .container-channel .icons {
display: flex;
flex-direction: row;
flex-grow: 0;
flex-shrink: 0;
}
.channel-container .container-channel.move-selected {
border-bottom: 1px solid black;
}
.channel-container .container-channel .show-channel-normal-only {
display: none;
}
.channel-container .container-channel .show-channel-normal-only.channel-normal {
display: block;
}
.channel-container .container-channel .icon_no_sound {
position: relative;
display: flex;
}
.channel-container .container-channel .icon_no_sound .background {
width: 10px;
height: 14px;
background: red;
position: absolute;
top: 1px;
left: 3px;
z-index: -1;
}
.channel-container .container-clients {
display: flex;
flex-direction: column;
}
/*# sourceMappingURL=channel.css.map */

1
shared/js/ui/channel-tree/channel.css.map
View file

@ -1 +0,0 @@
{"version":3,"sourceRoot":"","sources":["channel.scss","colors.scss"],"names":[],"mappings":"AAEA;EACI;EACA;;AAEA;EACI;EAEA;EACA;EACA;EAEA;EACA;EAEA;EACA;;AAEA;EACI;EACA;EAEA;;AAGJ;EACI;EACA;EAEA;EACA;EAEA;EAEA;AAAiB;EACjB;EACA;;AAEA;EACI;;AAGJ;EACI;;AAGJ;EACI;EACA,OC/CW;EDiDX;EACA;EACA;EACA;;AAIA;EACI;;AAKZ;EACI;EACA;EAEA;EACA;;AAGJ;EACI;;AAGJ;EACI;;AAEA;EACI;;AAIR;EACI;EACA;;AAEA;EACI;EACA;EAEA;EACA;EACA;EACA;EACA;;AAKZ;EACI;EACA","file":"channel.css"}

106
shared/js/ui/channel-tree/channel.scss
View file

@ -1,106 +0,0 @@
@import "colors";
.channel-container {
display: flex;
flex-direction: column;
.container-channel {
position: relative;
display: flex;
flex-direction: row;
justify-content: stretch;
width: 100%;
min-height: 16px;
align-items: center;
cursor: pointer;
.channel-type {
flex-grow: 0;
flex-shrink: 0;
margin-right: 2px;
}
.container-channel-name {
display: flex;
flex-direction: row;
flex-grow: 1;
flex-shrink: 1;
justify-content: left;
max-width: 100%; /* important for the repetitive channel name! */
overflow-x: hidden;
height: 16px;
&.align-right {
justify-content: right;
}
&.align-center, &.align-repetitive {
justify-content: center;
}
.channel-name {
align-self: center;
color: $channel-tree-entry-color;
min-width: 0;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
&.align-repetitive {
.channel-name {
text-overflow: clip;
}
}
}
.icons {
display: flex;
flex-direction: row;
flex-grow: 0;
flex-shrink: 0;
}
&.move-selected {
border-bottom: 1px solid black;
}
.show-channel-normal-only {
display: none;
&.channel-normal {
display: block;
}
}
.icon_no_sound {
position: relative;
display: flex;
.background {
width: 10px;
height: 14px;
background: red;
position: absolute;
top: 1px;
left: 3px;
z-index: -1;
}
}
}
.container-clients {
display: flex;
flex-direction: column;
}
}

120
shared/js/ui/channel-tree/channel.tsx
View file

@ -1,120 +0,0 @@
import * as React from "react";
import {ChannelEntry} from "../../channel-tree/channel";
const cssChannel = require("./channel.scss");
const cssTree = require("./tree.scss");
class ChannelIcon extends React.Component<{ channel: ChannelEntry }, {}> {
channel_icon_classes() {
const class_list = [];
const channel = this.props.channel;
if(channel.formattedChannelName() !== channel.channelName())
return "channel-spacer";
let icon_color;
if(channel.properties.channel_flag_password && !channel.cached_password())
icon_color = "yellow";
else if(channel.properties.channel_flag_maxclients_unlimited && channel.clients().length >= channel.properties.channel_maxclients)
icon_color = "red";
else if(channel.properties.channel_flag_maxfamilyclients_unlimited && channel.clients(true).length >= channel.properties.channel_maxfamilyclients)
icon_color = "red";
else
icon_color = "green";
return "channel-normal client-channel_" + icon_color + (channel.flag_subscribed ? "_subscribed" : "");
}
render() {
return <div className={this.channel_icon_classes()} />;
}
}
class ChannelIcons extends React.Component<{channel: ChannelEntry}, {}> {
render_icon(target: HTMLDivElement) {
const props = this.props.channel.properties;
if(!props.channel_icon_id) return;
const tag = this.props.channel.channelTree.client.fileManager.icons.generateTag(props.channel_icon_id);
tag.appendTo($(target));
}
render() {
const icons = [];
const props = this.props.channel.properties;
if(props.channel_flag_default) {
icons.push(<div className={"show-channel-normal-only icon_entry icon_default icon client-channel_default"} title={tr("Default channel")} />);
}
if(props.channel_flag_password) {
icons.push(<div className={"show-channel-normal-only icon_entry icon_password icon client-register"} title={tr("The channel is password protected")} />);
}
if(props.channel_codec_quality > 4) {
icons.push(<div className={"show-channel-normal-only icon_entry icon_moderated icon client-moderated"} title={tr("Music quality")} />);
}
if(props.channel_needed_talk_power > 0) {
icons.push(<div className={"show-channel-normal-only icon_entry icon_moderated icon client-moderated"} title={tr("Channel is moderated")} />);
}
if(props.channel_icon_id != 0) {
icons.push(<div className={"show-channel-normal-only icon_entry channel_icon"} title={tr("Channel icon")} ref={e => this.render_icon(e) }/>)
}
if(!audio.codec.supported(props.channel_codec)) {
icons.push(<div className={cssChannel.icon_no_sound}>
<div className={cssChannel.background} />
<div className={"icon_entry icon client-conflict-icon"} title={tr("You don't support the channel codec")} />
</div>)
}
return (<div className={cssChannel.icons}>{icons}</div>);
}
}
class ChannelLine extends React.Component<{ channel: ChannelEntry }, {}> {
render() {
let depth = 1;
let parent = this.props.channel;
while((parent = parent.parent))
depth++;
//TODO: On handle spacer alignments in channel name!
return (
<div className={cssChannel.containerChannel}>
<div className={cssTree.markerTextUnread} />
<div className={cssTree.depthFiller} style={{ width: depth + "em" }} />
<ChannelIcon channel={this.props.channel} />
<div className={cssChannel.containerChannelName}>
<a className={cssChannel.channelName}>{this.props.channel.formattedChannelName()}</a>
</div>
<ChannelIcons channel={this.props.channel} />
</div>
);
}
}
class ChannelClientsView extends React.Component<{}, {}> {
}
class SubChannelView extends React.Component<{ channels: ChannelEntry[] }, {}> {
render() {
return this.props.channels.map(e => <ChannelLine channel={e} />);
}
}
export class Channel extends React.Component<{ channel: ChannelEntry }, {}> {
children: ChannelEntry[];
channel_entry() : ChannelEntry { return this.props.channel; }
render() {
return (
<div className={[cssTree.entry, cssChannel.channelContainer].join(" ")}>
<ChannelLine channel={this.props.channel} />
<ChannelClientsView />
<SubChannelView channels={[]} />
</div>
);
}
}

3
shared/js/ui/channel-tree/colors.css
View file

@ -1,3 +0,0 @@
/*# sourceMappingURL=colors.css.map */

1
shared/js/ui/channel-tree/colors.css.map
View file

@ -1 +0,0 @@
{"version":3,"sourceRoot":"","sources":[],"names":[],"mappings":"","file":"colors.css"}

3
shared/js/ui/channel-tree/colors.scss
View file

@ -1,3 +0,0 @@
$channel-tree-new-message-color: #a814147F;
$channel-tree-entry-color: #828282;

38
shared/js/ui/channel-tree/tree.css
View file

@ -1,38 +0,0 @@
/* Some general browser helpers */
.tree-container .tree .entry .depth-filler {
font-size: 16px;
flex-shrink: 0;
flex-grow: 0;
}
.tree-container .marker-text-unread {
position: absolute;
left: 0;
top: 0;
bottom: 0;
width: 1px;
background-color: #a814147F;
opacity: 1;
-moz-transition: opacity 0.25s;
-o-transition: opacity 0.25s;
-webkit-transition: opacity 0.25s;
transition: opacity 0.25s;
}
.tree-container .marker-text-unread:before {
content: "";
position: absolute;
left: 0;
top: 0;
bottom: 0;
width: 24px;
background: -moz-linear-gradient(left, rgba(168, 20, 20, 0.18) 0%, rgba(168, 20, 20, 0) 100%);
/* FF3.6-15 */
background: -webkit-linear-gradient(left, rgba(168, 20, 20, 0.18) 0%, rgba(168, 20, 20, 0) 100%);
/* Chrome10-25,Safari5.1-6 */
background: linear-gradient(to right, rgba(168, 20, 20, 0.18) 0%, rgba(168, 20, 20, 0) 100%);
/* W3C, IE10+, FF16+, Chrome26+, Opera12+, Safari7+ */
}
.tree-container .marker-text-unread.hidden {
opacity: 0;
}
/*# sourceMappingURL=tree.css.map */

1
shared/js/ui/channel-tree/tree.css.map
View file

@ -1 +0,0 @@
{"version":3,"sourceRoot":"","sources":["../../../css/static/mixin.scss","tree.scss"],"names":[],"mappings":"AAAA;ACQY;EACI;EAEA;EACA;;AAKZ;EACI;EACA;EACA;EACA;EAEA;EACA;EAEA;EDvBP,iBC4CO;ED3CP,eC2CO;ED1CP,oBC0CO;EDzCP,YCyCO;;AAnBA;EACI;EACA;EAEA;EACA;EACA;EAEA;EAEA;AAAyF;EACzF;AAA2F;EAC3F;AAAuF;;AAG3F;EACI","file":"tree.css"}

50
shared/js/ui/channel-tree/tree.scss
View file

@ -1,50 +0,0 @@
@import "../../../css/static/mixin";
@import "../../../css/static/properties";
.tree-container {
.tree {
.entry {
.depth-filler {
font-size: 16px;
flex-shrink: 0;
flex-grow: 0;
}
}
}
.marker-text-unread {
position: absolute;
left: 0;
top: 0;
bottom: 0;
width: 1px;
background-color: #a814147F;
opacity: 1;
&:before {
content: '';
position: absolute;
left: 0;
top: 0;
bottom: 0;
width: 24px;
background: -moz-linear-gradient(left, rgba(168,20,20,.18) 0%, rgba(168,20,20,0) 100%); /* FF3.6-15 */
background: -webkit-linear-gradient(left, rgba(168,20,20,.18) 0%,rgba(168,20,20,0) 100%); /* Chrome10-25,Safari5.1-6 */
background: linear-gradient(to right, rgba(168,20,20,.18) 0%,rgba(168,20,20,0) 100%); /* W3C, IE10+, FF16+, Chrome26+, Opera12+, Safari7+ */
}
&.hidden {
opacity: 0;
}
@include transition(opacity $button_hover_animation_time);
}
}

5
shared/js/ui/channel-tree/tree.tsx
View file

@ -1,5 +0,0 @@
import * as React from "react";
export class TreeView {
}

13
shared/js/channel-tree/channel.ts → shared/js/ui/channel.ts
View file

@ -1,15 +1,12 @@
/// <reference path="view.ts" />
/// <reference path="../utils/helpers.ts" />
import {ChannelTree} from "./view";
import {ClientEntry} from "./client";
export enum ChannelType {
enum ChannelType {
PERMANENT,
SEMI_PERMANENT,
TEMPORARY
}
export namespace ChannelType {
namespace ChannelType {
export function normalize(mode: ChannelType) {
let value: string = ChannelType[mode];
value = value.toLowerCase();
@ -17,13 +14,13 @@ export namespace ChannelType {
}
}
export enum ChannelSubscribeMode {
enum ChannelSubscribeMode {
SUBSCRIBED,
UNSUBSCRIBED,
INHERITED
}
export class ChannelProperties {
class ChannelProperties {
channel_order: number = 0;
channel_name: string = "";
channel_name_phonetic: string = "";
@ -58,7 +55,7 @@ export class ChannelProperties {
channel_conversation_history_length: number = -1;
}
export class ChannelEntry {
class ChannelEntry {
channelTree: ChannelTree;
channelId: number;
parent?: ChannelEntry;

25
shared/js/channel-tree/client.ts → shared/js/ui/client.ts
View file

@ -1,11 +1,8 @@
/// <reference path="channel.ts" />
/// <reference path="../ui/modal/ModalChangeVolume.ts" />
/// <reference path="../ui/client_move.ts" />
/// <reference path="modal/ModalChangeVolume.ts" />
/// <reference path="client_move.ts" />
import {ChannelEntry} from "./channel";
import {ChannelTree} from "./view";
export enum ClientType {
enum ClientType {
CLIENT_VOICE,
CLIENT_QUERY,
CLIENT_INTERNAL,
@ -14,7 +11,7 @@ export enum ClientType {
CLIENT_UNDEFINED
}
export class ClientProperties {
class ClientProperties {
client_type: ClientType = ClientType.CLIENT_VOICE; //TeamSpeaks type
client_type_exact: ClientType = ClientType.CLIENT_VOICE;
@ -60,7 +57,7 @@ export class ClientProperties {
client_is_priority_speaker: boolean = false;
}
export class ClientConnectionInfo {
class ClientConnectionInfo {
connection_bandwidth_received_last_minute_control: number = -1;
connection_bandwidth_received_last_minute_keepalive: number = -1;
connection_bandwidth_received_last_minute_speech: number = -1;
@ -112,7 +109,7 @@ export class ClientConnectionInfo {
connection_client_port: number = -1;
}
export class ClientEntry {
class ClientEntry {
readonly events: events.Registry<events.channel_tree.client>;
protected _clientId: number;
@ -1126,7 +1123,7 @@ export class ClientEntry {
}
}
export class LocalClientEntry extends ClientEntry {
class LocalClientEntry extends ClientEntry {
handle: ConnectionHandler;
private renaming: boolean;
@ -1235,7 +1232,7 @@ export class LocalClientEntry extends ClientEntry {
}
}
export class MusicClientProperties extends ClientProperties {
class MusicClientProperties extends ClientProperties {
player_state: number = 0;
player_volume: number = 0;
@ -1267,7 +1264,7 @@ export class MusicClientProperties extends ClientProperties {
}
*/
export class SongInfo {
class SongInfo {
song_id: number = 0;
song_url: string = "";
song_invoker: number = 0;
@ -1280,7 +1277,7 @@ export class SongInfo {
song_length: number = 0;
}
export class MusicClientPlayerInfo extends SongInfo {
class MusicClientPlayerInfo extends SongInfo {
bot_id: number = 0;
player_state: number = 0;
@ -1293,7 +1290,7 @@ export class MusicClientPlayerInfo extends SongInfo {
player_description: string = "";
}
export class MusicClientEntry extends ClientEntry {
class MusicClientEntry extends ClientEntry {
private _info_promise: Promise<MusicClientPlayerInfo>;
private _info_promise_age: number = 0;
private _info_promise_resolve: any;

4
shared/js/ui/client_move.ts
View file

@ -1,4 +1,6 @@
export class ClientMover {
/// <reference path="client.ts" />
class ClientMover {
static readonly listener_root = $(document);
static readonly move_element = $("#mouse-move");
readonly channel_tree: ChannelTree;

6
shared/js/ui/elements/context_divider.ts
View file

@ -1,14 +1,10 @@
import {settings} from "../../settings";
import {log, LogCategory} from "../../log";
declare const $: any;
interface JQuery<TElement = HTMLElement> {
dividerfy() : this;
}
if(!$.fn.dividerfy) {
$.fn.dividerfy = function<T extends HTMLElement>(this: JQuery<T>) : JQuery<T> {
(this as any).find(".container-seperator").each(function (this: T) {
this.find(".container-seperator").each(function (this: T) {
if(!this.previousElementSibling) return;
if(!this.nextElementSibling) return;

2
shared/js/ui/elements/context_menu.ts
View file

@ -1,4 +1,4 @@
export namespace contextmenu {
namespace contextmenu {
export interface MenuEntry {
callback?: () => void;
type: MenuEntryType;

94
shared/js/ui/elements/modal.ts
View file

@ -1,13 +1,13 @@
import {KeyCode} from "../../PPTListener";
/// <reference path="../../PPTListener.ts" />
export enum ElementType {
enum ElementType {
HEADER,
BODY,
FOOTER
}
export type BodyCreator = (() => JQuery | JQuery[] | string) | string | JQuery | JQuery[];
export const ModalFunctions = {
type BodyCreator = (() => JQuery | JQuery[] | string) | string | JQuery | JQuery[];
const ModalFunctions = {
divify: function (val: JQuery) {
if(val.length > 1)
return $.spawn("div").append(val);
@ -54,7 +54,7 @@ export const ModalFunctions = {
}
};
export class ModalProperties {
class ModalProperties {
template?: string;
header: BodyCreator = () => "HEADER";
body: BodyCreator = () => "BODY";
@ -89,7 +89,7 @@ export class ModalProperties {
full_size?: boolean = false;
}
export namespace modal {
namespace modal {
export function initialize_modals() {
register_global_events();
}
@ -184,7 +184,7 @@ let _global_modal_count = 0;
let _global_modal_last: HTMLElement;
let _global_modal_last_time: number;
export class Modal {
class Modal {
private _htmlTag: JQuery;
properties: ModalProperties;
shown: boolean;
@ -296,11 +296,11 @@ export class Modal {
}
}
export function createModal(data: ModalProperties | any) : Modal {
function createModal(data: ModalProperties | any) : Modal {
return new Modal(ModalFunctions.warpProperties(data));
}
export class InputModalProperties extends ModalProperties {
class InputModalProperties extends ModalProperties {
maxLength?: number;
field_title?: string;
@ -310,7 +310,7 @@ export class InputModalProperties extends ModalProperties {
error_message?: string;
}
export function createInputModal(headMessage: BodyCreator, question: BodyCreator, validator: (input: string) => boolean, callback: (flag: boolean | string) => void, props: InputModalProperties | any = {}) : Modal {
function createInputModal(headMessage: BodyCreator, question: BodyCreator, validator: (input: string) => boolean, callback: (flag: boolean | string) => void, props: InputModalProperties | any = {}) : Modal {
props = ModalFunctions.warpProperties(props);
props.template_properties || (props.template_properties = {});
props.template_properties.field_title = props.field_title;
@ -370,7 +370,7 @@ export function createInputModal(headMessage: BodyCreator, question: BodyCreator
return modal;
}
export function createErrorModal(header: BodyCreator, message: BodyCreator, props: ModalProperties | any = { footer: undefined }) {
function createErrorModal(header: BodyCreator, message: BodyCreator, props: ModalProperties | any = { footer: undefined }) {
props = ModalFunctions.warpProperties(props);
(props.template_properties || (props.template_properties = {})).header_class = "modal-header-error";
@ -382,7 +382,7 @@ export function createErrorModal(header: BodyCreator, message: BodyCreator, prop
return modal;
}
export function createInfoModal(header: BodyCreator, message: BodyCreator, props: ModalProperties | any = { footer: undefined }) {
function createInfoModal(header: BodyCreator, message: BodyCreator, props: ModalProperties | any = { footer: undefined }) {
props = ModalFunctions.warpProperties(props);
(props.template_properties || (props.template_properties = {})).header_class = "modal-header-info";
@ -393,3 +393,73 @@ export function createInfoModal(header: BodyCreator, message: BodyCreator, props
modal.htmlTag.find(".modal-body").addClass("modal-info");
return modal;
}
/* extend jquery */
interface ModalElements {
header?: BodyCreator;
body?: BodyCreator;
footer?: BodyCreator;
}
interface JQuery<TElement = HTMLElement> {
modalize(entry_callback?: (header: JQuery, body: JQuery, footer: JQuery) => ModalElements | void, properties?: ModalProperties | any) : Modal;
}
$.fn.modalize = function (this: JQuery, entry_callback?: (header: JQuery, body: JQuery, footer: JQuery) => ModalElements | void, properties?: ModalProperties | any) : Modal {
properties = properties || {} as ModalProperties;
entry_callback = entry_callback || ((a,b,c) => undefined);
let tag_modal = this[0].tagName.toLowerCase() == "modal" ? this : undefined; /* TODO may throw exception? */
let tag_head = tag_modal ? tag_modal.find("modal-header") : ModalFunctions.jqueriefy(properties.header);
let tag_body = tag_modal ? tag_modal.find("modal-body") : this;
let tag_footer = tag_modal ? tag_modal.find("modal-footer") : ModalFunctions.jqueriefy(properties.footer);
const result = entry_callback(tag_head as any, tag_body, tag_footer as any) || {};
properties.header = result.header || tag_head;
properties.body = result.body || tag_body;
properties.footer = result.footer || tag_footer;
return createModal(properties);
};

2
shared/js/ui/elements/net_graph.ts
View file

@ -1,4 +1,4 @@
export namespace net.graph {
namespace net.graph {
export type Entry = {
timestamp: number;

6
shared/js/ui/elements/slider.ts
View file

@ -1,4 +1,4 @@
export interface SliderOptions {
interface SliderOptions {
min_value?: number;
max_value?: number;
initial_value?: number;
@ -8,11 +8,11 @@ export interface SliderOptions {
value_field?: JQuery | JQuery[];
}
export interface Slider {
interface Slider {
value(value?: number) : number;
}
export function sliderfy(slider: JQuery, options?: SliderOptions) : Slider {
function sliderfy(slider: JQuery, options?: SliderOptions) : Slider {
options = Object.assign( {
initial_value: 0,
min_value: 0,

161
shared/js/ui/elements/tab.ts Normal file
View file

@ -0,0 +1,161 @@
/// <reference path="../../i18n/localize.ts" />
interface JQuery<TElement = HTMLElement> {
asTabWidget(copy?: boolean) : JQuery<TElement>;
tabify(copy?: boolean) : this;
changeElementType(type: string) : JQuery<TElement>;
}
if(typeof (customElements) !== "undefined") {
try {
class X_Tab extends HTMLElement {}
class X_Entry extends HTMLElement {}
class X_Tag extends HTMLElement {}
class X_Content extends HTMLElement {}
customElements.define('x-tab', X_Tab, { extends: 'div' });
customElements.define('x-entry', X_Entry, { extends: 'div' });
customElements.define('x-tag', X_Tag, { extends: 'div' });
customElements.define('x-content', X_Content, { extends: 'div' });
} catch(error) {
console.warn("failed to define costum elements");
}
} else {
console.warn(tr("Could not defied tab customElements!"));
}
var TabFunctions = {
tabify(template: JQuery, copy: boolean = true) : JQuery {
console.log("Tabify: copy=" + copy);
console.log(template);
let tag = $.spawn("div");
tag.addClass("tab");
let header = $.spawn("div");
header.addClass("tab-header");
let content = $.spawn("div");
content.addClass("tab-content");
content.append($.spawn("div").addClass("height-watcher"));
let silentContent = $.spawn("div");
silentContent.addClass("tab-content-invisible");
/* add some kind of min height */
const update_height = () => {
const height_watcher = tag.find("> .tab-content .height-watcher");
const entries: JQuery = tag.find("> .tab-content-invisible x-content, > .tab-content x-content");
console.error(entries);
let max_height = 0;
entries.each((_, _e) => {
const entry = $(_e);
const height = entry.visible_height();
if(height > max_height)
max_height = height;
});
height_watcher.css('min-height', max_height + "px");
tag.find(".window-resize-listener").trigger('resize');
};
template.find("x-entry").each( (_, _entry) => {
const entry = $(_entry);
const tag_header = $.spawn("div").addClass("entry");
const tag_content = copy ? entry.find("x-content").clone(true, true) : entry.find("x-content");
{
const header_tag = entry.find("x-tag");
const header_data = copy ? header_tag.contents().clone(true, true) : header_tag.contents();
if(header_tag.attr("x-entry-class"))
tag_header.addClass(header_tag.attr("x-entry-class"));
if(header_tag.attr("x-entry-id"))
tag_header.attr("x-id", header_tag.attr("x-entry-id"));
tag_header.append(header_data);
/* listener if the tab might got removed */
tag_header.addClass("window-resize-listener");
tag_header.on('resize', event => {
if(!tag_header.is(':visible') && tag_header.hasClass('selected')) {
let element = tag_header.next('.entry:visible');
if(element.length == 0)
element = tag_header.prev('.entry:visible');
if(element.length == 0) {
tag_header.removeClass("selected");
tag_content.hide();
} else {
element.first().trigger('click');
}
console.log("Next: %o", tag_header.next('.entry:visible'));
console.log("prev: %o", tag_header.prev('.entry:visible'));
}
});
}
content.append(tag_content.hide());
tag_header.on("click", () => {
if(tag_header.hasClass("selected")) return;
tag.find(".tab-header .selected").removeClass("selected");
tag_header.addClass("selected");
content.find("> x-content").hide();
/* don't show many nodes at once */
let entries = tag_content.find(".tab-show-partitional");
entries.hide();
const show_next = index => {
console.log("Show " + index);
if(index >= entries.length) return;
entries.eq(index).show();
setTimeout(show_next.bind(undefined, index + 1), 0);
};
show_next(0);
tag_content.trigger('show');
tag_content.show();
});
console.log(this);
header.append(tag_header);
});
setTimeout(() => header.find(".entry").first().trigger("click"), 0);
tag.append(header);
tag.append(content);
tag.append(silentContent);
tag.on('tab.resize', update_height);
return tag;
}
};
if(!$.fn.asTabWidget) {
$.fn.asTabWidget = function (copy?: boolean) : JQuery {
if($(this).prop("tagName") == "X-TAB")
return TabFunctions.tabify($(this), typeof(copy) === "boolean" ? copy : true);
else {
throw "Invalid tag! " + $(this).prop("tagName");
}
}
}
if(!$.fn.tabify) {
$.fn.tabify = function (this: JQuery, copy?: boolean) {
const wrapped_tag = $.spawn("div").append(this);
wrapped_tag.find("x-tab").each((_, _element) => {
const element = $(_element);
element.replaceWith(element.asTabWidget(copy));
});
return wrapped_tag.children();
}
}

4
shared/js/ui/elements/tooltip.ts
View file

@ -1,8 +1,8 @@
export function tooltip(entry: JQuery) {
function tooltip(entry: JQuery) {
return tooltip.initialize(entry);
}
export namespace tooltip {
namespace tooltip {
let _global_tooltip: JQuery;
export type Handle = {
show();

27
shared/js/ui/frames/ControlBar.ts
View file

@ -13,27 +13,12 @@
client_away_message Value: ''
*/
import {ConnectionHandler, DisconnectReason} from "../../ConnectionHandler";
import {top_menu} from "./MenuBar";
import {Settings, settings} from "../../settings";
import {createErrorModal, createInfoModal, createInputModal} from "../elements/modal";
import {default_recorder} from "../../voice/RecorderProfile";
import {sound, Sound} from "../../sound/Sounds";
import {Modals} from "../modal/ModalConnect";
import {Modal as ModalsS} from "../modal/ModalSettings";
import {log} from "./server_log";
import {MessageHelper} from "./chat";
import {CommandResult} from "../../connection/ServerConnectionDeclaration";
import {PermissionType} from "../../permission/PermissionManager";
import {bookmarks} from "../../bookmarks";
import {contextmenu} from "../elements/context_menu";
let control_bar: ControlBar; /* global variable to access the control bar */
export let control_bar: ControlBar; /* global variable to access the control bar */
export type MicrophoneState = "disabled" | "muted" | "enabled";
export type HeadphoneState = "muted" | "enabled";
export type AwayState = "away-global" | "away" | "online";
export class ControlBar {
type MicrophoneState = "disabled" | "muted" | "enabled";
type HeadphoneState = "muted" | "enabled";
type AwayState = "away-global" | "away" | "online";
class ControlBar {
private _button_away_active: AwayState;
private _button_microphone: MicrophoneState;
private _button_speakers: HeadphoneState;
@ -436,7 +421,7 @@ export class ControlBar {
}
private on_open_settings() {
ModalsS.spawnSettingsModal();
Modals.spawnSettingsModal();
}
private on_open_connect() {

10
shared/js/ui/frames/MenuBar.ts
View file

@ -1,12 +1,4 @@
import {bookmarks} from "../../bookmarks";
import {Modals} from "../modal/ModalBookmarks";
import {DisconnectReason} from "../../ConnectionHandler";
import {control_bar} from "./ControlBar";
import {createErrorModal} from "../elements/modal";
import {PermissionType} from "../../permission/PermissionManager";
import {Sound} from "../../sound/Sounds";
export namespace top_menu {
namespace top_menu {
export interface HRItem { }
export interface MenuItem {

6
shared/js/ui/frames/chat.ts
View file

@ -1,6 +1,4 @@
import {log, LogCategory} from "../../log";
export enum ChatType {
enum ChatType {
GENERAL,
SERVER,
CHANNEL,
@ -8,7 +6,7 @@ export enum ChatType {
}
declare const xbbcode: any;
export namespace MessageHelper {
namespace MessageHelper {
export function htmlEscape(message: string) : string[] {
const div = document.createElement('div');
div.innerText = message;

8
shared/js/ui/frames/chat_frame.ts
View file

@ -1,11 +1,5 @@
/* the bar on the right with the chats (Channel & Client) */
import {ChannelEntry} from "../../channel-tree/channel";
import {Modals} from "../modal/ModalMusicManage";
import {MessageHelper} from "./chat";
import {ServerEntry} from "../../channel-tree/server";
import {ConnectionHandler} from "../../ConnectionHandler";
export namespace chat {
namespace chat {
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;

8
shared/js/ui/frames/connection_handlers.ts
View file

@ -1,11 +1,7 @@
import {ConnectionHandler, DisconnectReason} from "../../ConnectionHandler";
import {Settings, settings} from "../../settings";
import {control_bar} from "./ControlBar";
import {top_menu} from "./MenuBar";
export let server_connections: ServerConnectionManager;
let server_connections: ServerConnectionManager;
export class ServerConnectionManager {
class ServerConnectionManager {
private connection_handlers: ConnectionHandler[] = [];
private active_handler: ConnectionHandler | undefined;

6
shared/js/ui/frames/hostbanner.ts
View file

@ -1,8 +1,4 @@
import {ConnectionHandler} from "../../ConnectionHandler";
import {Settings, settings} from "../../settings";
import {log, LogCategory} from "../../log";
export class Hostbanner {
class Hostbanner {
readonly html_tag: JQuery<HTMLElement>;
readonly client: ConnectionHandler;

2
shared/js/ui/frames/image_preview.ts
View file

@ -1,4 +1,4 @@
export namespace image_preview {
namespace image_preview {
let preview_overlay: JQuery<HTMLDivElement>;
let container_image: JQuery<HTMLDivElement>;
let button_open_in_browser: JQuery;

985
shared/js/ui/frames/server_log.ts
View file

File diff suppressed because it is too large Load diff

2
shared/js/ui/frames/side/chat_box.ts
View file

@ -1,4 +1,4 @@
export namespace chat {
namespace chat {
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;

2
shared/js/ui/frames/side/chat_helper.ts
View file

@ -1,4 +1,4 @@
export namespace chat {
namespace chat {
export namespace helpers {
//https://regex101.com/r/YQbfcX/2
//static readonly URL_REGEX = /^(?<hostname>([a-zA-Z0-9-]+\.)+[a-zA-Z0-9-]{2,63})(?:\/(?<path>(?:[^\s?]+)?)(?:\?(?<query>\S+))?)?$/gm;

9
shared/js/ui/frames/side/client_info.ts
View file

@ -1,11 +1,4 @@
import {ClientEntry, LocalClientEntry} from "../../../channel-tree/client";
import {Modals} from "../../modal/ModalClientInfo";
import {htmltags} from "../../htmltags";
import {image_preview} from "../image_preview";
import {i18n} from "../../../i18n/country";
import {GroupManager} from "../../../permission/GroupManager";
export namespace chat {
namespace chat {
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;

8
shared/js/ui/frames/side/conversations.ts
View file

@ -1,10 +1,4 @@
import {htmltags} from "../../htmltags";
import {MessageHelper} from "../chat";
import {CommandResult, ErrorID} from "../../../connection/ServerConnectionDeclaration";
import {log, LogCategory} from "../../../log";
import {createErrorModal} from "../../elements/modal";
export namespace chat {
namespace chat {
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;

5
shared/js/ui/frames/side/music_info.ts
View file

@ -1,7 +1,6 @@
import {MusicClientEntry} from "../../../channel-tree/client";
import {image_preview} from "../image_preview";
namespace chat {
import PlayerState = connection.voice.PlayerState;
export namespace chat {
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;

6
shared/js/ui/frames/side/private_conversations.ts
View file

@ -1,9 +1,5 @@
/* the bar on the right with the chats (Channel & Client) */
import {log, LogCategory} from "../../../log";
import {htmltags} from "../../htmltags";
import {MessageHelper} from "../chat";
export namespace chat {
namespace chat {
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;

2
shared/js/ui/htmltags.ts
View file

@ -1,4 +1,4 @@
export namespace htmltags {
namespace htmltags {
let mouse_coordinates: {x: number, y: number} = {x: 0, y: 0};
function initialize() {

6
shared/js/ui/modal/ModalAbout.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
function format_date(date: number) {
const d = new Date(date);

6
shared/js/ui/modal/ModalAvatar.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
//TODO: Test if we could render this image and not only the browser by knowing the type.
export function spawnAvatarUpload(callback_data: (data: ArrayBuffer | undefined | null) => any) {
const modal = createModal({

6
shared/js/ui/modal/ModalAvatarList.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
const avatar_to_uid = (id: string) => {
const buffer = new Uint8Array(id.length / 2);
for(let index = 0; index < id.length; index += 2) {

5
shared/js/ui/modal/ModalBanClient.ts
View file

@ -1,3 +1,8 @@
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export type BanEntry = {
name?: string;
unique_id: string;

7
shared/js/ui/modal/ModalBanList.ts
View file

@ -1,4 +1,9 @@
export namespace Modals {
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../i18n/localize.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function openBanList(client: ConnectionHandler) {
let modal: Modal;

6
shared/js/ui/modal/ModalBookmarks.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function spawnBookmarkModal() {
let modal: Modal;
modal = createModal({

6
shared/js/ui/modal/ModalChangeLatency.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
let modal: Modal;
export function spawnChangeLatency(client: ClientEntry, current: connection.voice.LatencySettings, reset: () => connection.voice.LatencySettings, apply: (settings: connection.voice.LatencySettings) => any, callback_flush?: () => any) {
if(modal) modal.close();

6
shared/js/ui/modal/ModalChangeVolume.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
//TODO: Use the max limit!
let modal: Modal;

2
shared/js/ui/modal/ModalChannelInfo.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export function openChannelInfo(channel: ChannelEntry) {
let modal: Modal;

2
shared/js/ui/modal/ModalClientInfo.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
type InfoUpdateCallback = (info: ClientConnectionInfo) => any;
export function openClientInfo(client: ClientEntry) {
let modal: Modal;

6
shared/js/ui/modal/ModalConnect.ts
View file

@ -1,5 +1,7 @@
/// <reference path="../../ui/elements/modal.ts" />
//FIXME: Move this shit out of this file!
export namespace connection_log {
namespace connection_log {
//TODO: Save password data
export type ConnectionData = {
name: string;
@ -89,7 +91,7 @@ export namespace connection_log {
});
}
export namespace Modals {
namespace Modals {
export function spawnConnectModal(options: {
default_connect_new_tab?: boolean /* default false */
}, defaultHost: { url: string, enforce: boolean} = { url: "ts.TeaSpeak.de", enforce: false}, connect_profile?: { profile: profiles.ConnectionProfile, enforce: boolean}) {

4
shared/js/ui/modal/ModalCreateChannel.ts
View file

@ -1,4 +1,6 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
namespace Modals {
export function createChannelModal(connection: ConnectionHandler, channel: ChannelEntry | undefined, parent: ChannelEntry | undefined, permissions: PermissionManager, callback: (properties?: ChannelProperties, permissions?: PermissionValue[]) => any) {
let properties: ChannelProperties = { } as ChannelProperties; //The changes properties
const modal = createModal({

2
shared/js/ui/modal/ModalGroupAssignment.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
let current_modal: Modal;
export function createServerGroupAssignmentModal(client: ClientEntry, callback: (groups: number[], flag: boolean) => Promise<boolean>) {
if(current_modal)

6
shared/js/ui/modal/ModalIconSelect.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function spawnIconSelect(client: ConnectionHandler, callback_icon?: (id: number) => any, selected_icon?: number) {
selected_icon = selected_icon || 0;
let allow_manage = client.permissions.neededPermission(PermissionType.B_ICON_MANAGE).granted(1);

2
shared/js/ui/modal/ModalIdentity.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export function spawnTeamSpeakIdentityImprove(identity: profiles.identities.TeaSpeakIdentity, name: string): Modal {
let modal: Modal;
let elapsed_timer: NodeJS.Timer;

6
shared/js/ui/modal/ModalInvite.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
type URLGeneratorSettings = {
flag_direct: boolean,
flag_resolved: boolean

2
shared/js/ui/modal/ModalKeySelect.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export function spawnKeySelect(callback: (key?: ppt.KeyEvent) => void) {
let modal = createModal({
header: tr("Select a key"),

6
shared/js/ui/modal/ModalMusicManage.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function openMusicManage(client: ConnectionHandler, bot: MusicClientEntry) {
const ev_registry = new events.Registry<events.modal.music_manage>();
ev_registry.enable_debug("music-manage");

6
shared/js/ui/modal/ModalNewcomer.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
const next_step: {[key: string]:string} = {
"welcome": "microphone",
//"microphone": app.is_web() ? "identity" : "speaker", /* speaker setup only for the native client! */

6
shared/js/ui/modal/ModalPlaylistEdit.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function spawnPlaylistSongInfo(song: PlaylistSong) {
let modal: Modal;

7
shared/js/ui/modal/ModalPlaylistList.ts
View file

@ -1,4 +1,9 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../i18n/localize.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function spawnPlaylistManage(client: ConnectionHandler) {
{
createErrorModal(tr("Not implemented"), tr("Playlist management hasn't yet been implemented")).open();

6
shared/js/ui/modal/ModalPoke.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
let global_modal: PokeModal;
interface ServerEntry {

6
shared/js/ui/modal/ModalQuery.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
export function spawnQueryCreate(connection: ConnectionHandler, callback_created?: (user, pass) => any) {
let modal;
modal = createModal({

6
shared/js/ui/modal/ModalQueryManage.ts
View file

@ -1,4 +1,8 @@
export namespace Modals {
/// <reference path="../../ui/elements/modal.ts" />
/// <reference path="../../ConnectionHandler.ts" />
/// <reference path="../../proto.ts" />
namespace Modals {
/*
export function spawnQueryManage(client: ConnectionHandler) {
let modal: Modal;

2
shared/js/ui/modal/ModalServerEdit.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export function createServerModal(server: ServerEntry, callback: (properties?: ServerProperties) => Promise<void>) {
const properties = Object.assign({}, server.properties);

2
shared/js/ui/modal/ModalServerInfo.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export function openServerInfo(server: ServerEntry) {
let modal: Modal;
let update_callbacks: ServerBandwidthInfoUpdateCallback[] = [];

2
shared/js/ui/modal/ModalServerInfoBandwidth.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export enum RequestInfoStatus {
SUCCESS,
UNKNOWN,

2
shared/js/ui/modal/ModalSettings.ts
View file

@ -1,4 +1,4 @@
export namespace Modals {
namespace Modals {
export function spawnSettingsModal(default_page?: string) : Modal {
let modal: Modal;
modal = createModal({

4
shared/js/ui/modal/ModalYesNo.ts
View file

@ -1,6 +1,6 @@
import {BodyCreator, ModalFunctions} from "../elements/modal";
/// <reference path="../../ui/elements/modal.ts" />
export namespace Modals {
namespace Modals {
export function spawnYesNo(header: BodyCreator, body: BodyCreator, callback: (_: boolean) => any, properties?: {
text_yes?: string,
text_no?: string,

4
shared/js/ui/modal/permission/CanvasPermissionEditor.ts
View file

@ -1,5 +1,7 @@
/// <reference path="./ModalPermissionEdit.ts" /> /* first needs the AbstractPermissionEdit */
/* Canvas Permission Editor */
export namespace pe {
namespace pe {
namespace ui {
export namespace scheme {
export interface CheckBox {

Some files were not shown because too many files have changed in this diff Show more