mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-01 12:42:58 +08:00
2693 lines
93 KiB
TypeScript
2693 lines
93 KiB
TypeScript
// Type definitions for Knuddels UserApps API 1.0
|
|
// Project: https://developer.knuddels.de
|
|
// Definitions by: Knuddels GmbH & Co. KG <https://github.com/Knuddels/>
|
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
|
|
|
// JSON definition
|
|
interface Json {
|
|
[x: string]: string | number | boolean | Date | Json | JsonArray;
|
|
}
|
|
interface JsonArray extends Array<string | number | boolean | Date | Json | JsonArray> { }
|
|
// serializable objects (for persistence)
|
|
type KnuddelsSerializable = string | number | boolean | User | BotUser;
|
|
interface KnuddelsJson {
|
|
[x: string]: string | number | boolean | Date | KnuddelsJson | KnuddelsJsonArray | KnuddelsSerializable;
|
|
}
|
|
interface KnuddelsJsonArray extends Array<string | number | boolean | Date | KnuddelsJson | KnuddelsJsonArray | KnuddelsSerializable> { }
|
|
// "data" that may be send between apps and between server and client
|
|
type KnuddelsEvent = string | Json | KnuddelsEventArray;
|
|
interface KnuddelsEventArray extends Array<string | KnuddelsEvent | KnuddelsEventArray> { }
|
|
/**
|
|
* App ist die abstrakte Klasse einer konkreten App, die ein Entwickler schreiben kann.
|
|
* Im eigenen Javascript-Code muss eine Variable mit dem Namen <em>App</em> vorhanden sein, damit eine App lauffähig ist.
|
|
*/
|
|
declare interface App {
|
|
/**
|
|
* Dieses Methode wird aufgerufen, sobald ein Nutzer versucht den Channel zu betreten.
|
|
* Die App kann nun entscheiden, ob der Nutzer den Channel betreten darf.
|
|
*
|
|
* <b style="color:red;">Hinweis:</b> Um ein responsives User Interface für den Nutzer,
|
|
* der den Channel betreten möchte zu garantieren, muss die App innerhalb von einer Sekunde auf diese Anfrage reagieren,
|
|
* damit ihre Antwort in das Ergebnis einfliesst.
|
|
*
|
|
* Mit bestimmten Smileyfeatures ist es derzeit trotzdem möglich, den Channel zu betreten.
|
|
* Diese Nutzer können nicht ausgesperrt werden:
|
|
* <ul>
|
|
* <li>Channelbesitzer</li>
|
|
* <li>Channelmoderatoren und HZAs</li>
|
|
* <li>Admins (sofern notwendig)</li>
|
|
* <li>Sysadmins</li>
|
|
* <li>User Apps Team (Mitarbeiter von Knuddels)</li>
|
|
* </ul>
|
|
*
|
|
* Ist der Channel mit einem Passwort geschützt und der Nutzer, der versucht den Channel zu betreten kennt das Passwort,
|
|
* so kann er nicht aus dem Channel ausgeschlossen werden.
|
|
*/
|
|
mayJoinChannel?(user: User): ChannelJoinPermission;
|
|
/**
|
|
* Diese Methode wird jedes Mal aufgerufen, sobald ein Nutzer versucht eine öffentliche Nachricht zu senden.
|
|
* Die App kann nun entscheiden, ob die Nachricht veröffentlicht werden darf.
|
|
*
|
|
* Laufen mehrere Apps im selben Channel, so wird die Nachricht veröffentlicht, sofern alle Apps es erlauben.
|
|
*
|
|
* Dauert das Fragen aller Apps nach Erlaubnis länger als 10 Sekunden, so wird die Antwort genutzt, die bis dahin
|
|
* gegeben wurde.
|
|
*/
|
|
mayShowPublicMessage?(publicMessage: PublicMessage): boolean;
|
|
/**
|
|
* Diese Methode wird jedes Mal aufgerufen, sobald ein Nutzer versucht eine öffentliche Handlung auszuführen.
|
|
* Die App kann nun entscheiden, ob die Handlung ausgeführt werden darf.
|
|
*
|
|
* Laufen mehrere Apps im selben Channel, so wird die Handlung ausgeführt, sofern alle Apps es erlauben.
|
|
*
|
|
* Dauert das Fragen aller Apps nach Erlaubnis länger als 10 Sekunden, so wird die Antwort genutzt, die bis dahin
|
|
* gegeben wurde.
|
|
*/
|
|
mayShowPublicActionMessage?(publicActionMessage: PublicActionMessage): boolean;
|
|
/**
|
|
* Diese Methode wird aufgerufen, sobald die App startet.
|
|
* Dies ist der beste Zeipunkt um Werte zu initialisieren und aus der Persistenz zu lesen.
|
|
*/
|
|
onAppStart?(): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn ein User Knuddel an den BotUser gesendet hat.
|
|
* Es ist die Aufgabe der App in dieser Methode zu entscheiden, ob sie die Knuddel annimmt oder ablehnt.
|
|
* Wird diese Methode von der App nicht implementiert, so werden Knuddel automatisch akzeptiert.
|
|
* Ist diese Methode implementiert und es treten Fehler (Exceptions, Timeout,...) auf oder der Entwickler entscheidet nicht,
|
|
* was mit den Knuddel geschehen soll, so werden diese vom App-System automatisch an den Absender zurück geschickt.
|
|
* <br />
|
|
* <b style="color:red;">Wichtig:</b> Zum Zeitpunkt des Aufrufs dieser Methode wurden die Knuddel noch nicht an den BotUser übertragen.
|
|
*/
|
|
onBeforeKnuddelReceived?(knuddelTransfer: KnuddelTransfer): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, sobald ein BotUser Knuddel von einem User erhalten hat.
|
|
*/
|
|
onKnuddelReceived?(sender: User, receiver: BotUser, knuddelAmount: KnuddelAmount, transferReason: string): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn die App sich darauf vorbereiten soll heruntergefahren zu werden.
|
|
* Als Parameter wird die geschätzte Zeit übergeben, die die App noch hat, bis sie heruntergefahren wird
|
|
* und der Aufruf App/onShutdown:event folgt.
|
|
*
|
|
* App/onPrepareShutdown:event kann dazu benutzt werden das Nutzererlebnis zu verbessern,
|
|
* sofern eine App heruntergefahren werden muss (bsp. für Updates).
|
|
* Eine Spiele-App könnte z.B. entscheiden, dass sie keine weiteren Spiele eröffnet und den Spielern offener Spiele
|
|
* die Information anzeigt, wie lange das Spiel noch läuft, bevor es unentschieden endet.
|
|
*
|
|
* <br><br><b style="color:red;">Achtung:</b> Die Methode kann im Lebenszyklus einer App mehrfach aufgerufen werden.
|
|
*/
|
|
onPrepareShutdown?(secondsTillShutdown: number): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn ein BotUser privat angeschrieben wird.
|
|
*/
|
|
onPrivateMessage?(privateMessage: PrivateMessage): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn im Channel der App
|
|
* eine öffentliche Nachricht geschrieben wird.
|
|
* Für Nachrichten von BotUsern wird diese Methode nicht aufgerufen.
|
|
*/
|
|
onPublicMessage?(publicMessage: PublicMessage): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn im Channel der App
|
|
* eine Event-Nachricht veröffentlicht wird.
|
|
* Für Nachrichten von BotUsern wird diese Methode nicht aufgerufen.
|
|
*/
|
|
onPublicEventMessage?(publicEventMessage: PublicEventMessage): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn im Channel der App
|
|
* eine öffentliche Handlung durchgeführt wird.
|
|
* Für Handlungen von BotUsern wird diese Methode nicht aufgerufen.
|
|
*/
|
|
onPublicActionMessage?(publicActionMessage: PublicActionMessage): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn eine App beendet wird.
|
|
* Sobald diese Methode aufgerufen wird, steht nur noch ein begrenzter Teil der API zur Verfügung.
|
|
* Die App sollte den kompletten Zustand in der Persistenz speichern, sodass der Zustand
|
|
* beim nächsten App/onAppStart:event wiederhergestellt werden kann.
|
|
*
|
|
* Während des Shutdowns können asynchrone each-Methoden, wie UserPersistenceNumbers/each:method
|
|
* und UserAccess/eachAccessibleUser:method nicht zuverlässig genutzt werden.
|
|
*/
|
|
onShutdown?(): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn ein User im Channel der App
|
|
* über die Systemfunktionen (/dice, /diceo) würfelt.
|
|
* Die App kann auf das Ergebnis zugreifen und die Daten für die Auswertung und Entscheidungen nutzen.
|
|
*/
|
|
onUserDiced?(diceEvent: DiceEvent): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn ein User den Channel der App betritt.
|
|
*/
|
|
onUserJoined?(user: User): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn ein User den Channel der App verlässt.
|
|
*/
|
|
onUserLeft?(user: User): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn aus einer anderen App ein Event mit sendAppEvent versendet wurde.
|
|
*/
|
|
onAppEventReceived?(appInstance: AppInstance, type: string, data: KnuddelsEvent): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn aus dem HTML User Interface ein Event mit
|
|
* sendEvent() gesendet wurde.
|
|
*/
|
|
onEventReceived?(user: User, type: string, data: KnuddelsEvent, appContentSession: AppContentSession): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn ein User Knuddel in seinen KnuddelAccount
|
|
* eingezahlt hat.
|
|
*/
|
|
onAccountReceivedKnuddel?(sender: User, receiver: BotUser, knuddelAmount: KnuddelAmount, transferReason: string, knuddelAccount: KnuddelAccount): void;
|
|
/**
|
|
* Diese Methode wird aufgerufen, wenn sich die Anzahl der Knuddel auf einem KnuddelAccount eines User
|
|
* geändert hat.
|
|
*/
|
|
onAccountChangedKnuddelAmount?(user: User, knuddelAccount: KnuddelAccount, oldKnuddelAmount: KnuddelAmount, newKnuddelAmount: KnuddelAmount): void;
|
|
/**
|
|
* Ermöglicht das Registrieren eigener Chatbefehle.
|
|
* In einem Channel kann nur eine App laufen, die einen bestimmten Chatbefehl nutzt.
|
|
* Versucht eine zweite App einen Chatbefehl zu registrieren, den eine andere
|
|
* App bereits nutzt, so wird ein Fehler geloggt und die App startet nicht bzw. fährt herunter.
|
|
*
|
|
* Die Struktur eines registrierten Chatbefehls ist:
|
|
* <code>commandName: function (user, params, command) {}</code>
|
|
*
|
|
*
|
|
* <ul>
|
|
* <li><code>commandName</code> ist der Name der Funktion, wie sie aufgerufen wird (beispielsweise /commandname)</li>
|
|
* <li><code>user</code> ist der Nutzer, der die Funktion aufgerufen hat</li>
|
|
* <li><code>params</code> sind die Parameter, die der Nutzer hinter dem Befehl eingegeben hat (beispielsweise /commandname params)</li>
|
|
* <li><code>command</code> ist der Name des Befehl selbst (beispielsweise commandName)</li>
|
|
* </ul>
|
|
*/
|
|
chatCommands?: { [commandName: string]: (user: User, params: string, command: string) => void };
|
|
}
|
|
|
|
/**
|
|
* Ermöglicht Zugriff auf Informationen zu Apps und Events zwischeneinander.
|
|
*
|
|
* Die Instanz von <code>AppAccess</code> erhält man über den KnuddelsServer
|
|
* mit KnuddelsServer.getAppAccess()
|
|
*/
|
|
declare class AppAccess {
|
|
/**
|
|
* Liefert die Instanz der eigenen App.
|
|
*/
|
|
getOwnInstance(): AppInstance;
|
|
/**
|
|
* Liefert die Instanzen aller anderen Apps, die gerade in diesem Channel laufen.
|
|
* @since AppServer 82904
|
|
*/
|
|
getAllRunningAppsInChannel(includeSelf?: boolean): AppInstance[];
|
|
/**
|
|
* Liefert die Instanzen aller anderen Apps, die gerade in diesem Channel laufen.
|
|
* @since AppServer 82904
|
|
*/
|
|
getRunningAppInChannel(appId: string): (AppInstance|null);
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert den visuellen Inhalt einer Applikation, der Usern angezeigt werden soll.
|
|
*/
|
|
declare class AppContent {
|
|
/**
|
|
* Liefert den AppViewMode.
|
|
*/
|
|
getAppViewMode(): AppViewMode;
|
|
/**
|
|
* Liefert das HTMLFile, das beim Anlegen des AppContents
|
|
* genutzt wurde.
|
|
*/
|
|
getHTMLFile(): HTMLFile;
|
|
/**
|
|
* Liefert die Breite des AppContent.
|
|
*/
|
|
getWidth(): number;
|
|
/**
|
|
* Liefert die Höhe des AppContent.
|
|
*/
|
|
getHeight(): number;
|
|
/**
|
|
* Liefert die LoadConfiguration, mit der die Optik beim Laden des HTML User Interface beeinflusst werden kann.
|
|
*/
|
|
getLoadConfiguration(): LoadConfiguration;
|
|
/**
|
|
* Liefert einen AppContent, der das HTMLFile als Overlay oben rechts im Channel anzeigt.
|
|
*/
|
|
static overlayContent(htmlFile: HTMLFile, width: number, height: number): AppContent;
|
|
/**
|
|
* Liefert einen AppContent, der das HTMLFile als Overlay (200x350) oben rechts im Channel anzeigt.
|
|
*/
|
|
static overlayContent(htmlFile: HTMLFile): AppContent;
|
|
/**
|
|
* Liefert einen AppContent, der das HTMLFile im Applet/HTML-Chat
|
|
* als Popup (300x400) und auf Android als Fullscreen-View anzeigt.
|
|
*/
|
|
static popupContent(htmlFile: HTMLFile): AppContent;
|
|
/**
|
|
* Liefert einen AppContent, der das HTMLFile im Applet/HTML-Chat
|
|
* als Popup und auf Android als Fullscreen-View anzeigt.
|
|
*/
|
|
static popupContent(htmlFile: HTMLFile, width: number, height: number): AppContent;
|
|
/**
|
|
* Sendet Daten an alle Nutzer, die diesen AppContent geöffnet haben.
|
|
*/
|
|
sendEvent(type: string, data?: KnuddelsEvent): void;
|
|
/**
|
|
* Liefert eine Liste aller User, die diesen AppContent
|
|
* geöffnet haben.
|
|
*/
|
|
getUsers(): User[];
|
|
/**
|
|
* Liefert eine Liste aller AppContentSessions, die dieses AppContent,
|
|
* die User gerade geöffnet haben.
|
|
*/
|
|
getSessions(): AppContentSession[];
|
|
/**
|
|
* Ersetzt den AppContent, bei allen Usern, die diesen AppContent
|
|
* geöffnet haben durch den neuen AppContent.
|
|
*
|
|
* <br /><br /><b><font color="red">Hinweis:</font></b> Es können nur AppContent mit demselben AppViewMode
|
|
* zum Ersetzen genutzt werden.
|
|
*/
|
|
replaceWithAppContent(newAppContent: AppContent): void;
|
|
/**
|
|
* Entfernt diesen AppContent, bei allen Usern, die diesen AppContent
|
|
* geöffnet haben.
|
|
*/
|
|
remove(): void;
|
|
/**
|
|
* Fügt einen Listener hinzu, der aufgerufen wird, wenn jemand den AppContent schließt.
|
|
*/
|
|
addCloseListener(callback: { user: User; appContent: AppContent; }): void;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert den visuellen Inhalt einer App, der einem User angezeigt wird.
|
|
*/
|
|
declare class AppContentSession {
|
|
/**
|
|
* Sendet Daten an den verbundenen Client.
|
|
*/
|
|
sendEvent(type: string, data?: KnuddelsEvent): void;
|
|
/**
|
|
* Liefert den AppViewMode.
|
|
*/
|
|
getAppViewMode(): AppViewMode;
|
|
/**
|
|
* Entfernt die AppContentSession beim verbundenen User.
|
|
*/
|
|
remove(): void;
|
|
/**
|
|
* Liefert den User.
|
|
*/
|
|
getUser(): User;
|
|
/**
|
|
* Liefert den verbundenen AppContent.
|
|
*/
|
|
getAppContent(): AppContent;
|
|
}
|
|
|
|
/**
|
|
* Die Instanz von <code>AppInfo</code> zur laufenden App erhält man über die AppInstance
|
|
* mit appInstance.getAppInfo()
|
|
*/
|
|
declare class AppInfo {
|
|
/**
|
|
* Liefert die AppUid.
|
|
* Diese ist für jede Sub-Channel Instanz der App unterschiedlich.
|
|
* Wenn RootAppUid == AppUid dann ist dies die Root-App-Instanz.
|
|
*/
|
|
getAppUid(): number;
|
|
/**
|
|
* Liefert die RootAppUid.
|
|
* Diese ist für jede Sub-Channel Instanz der App gleich.
|
|
* Wenn RootAppUid == AppUid dann ist dies die Root-App-Instanz.
|
|
*
|
|
* Sie wird für den Link für Auszahlungen aus einem Knuddel-Account benötigt: <code>/knuddelaccount payout:<RootAppUid>:<BETRAG></code>
|
|
*/
|
|
getRootAppUid(): number;
|
|
/**
|
|
* Liefert den in der Konfiguration eingestellten Namen der App.
|
|
*/
|
|
getAppName(): string;
|
|
/**
|
|
* Liefert die Version der App, die in der Konfiguration eingestellt wurde.
|
|
*/
|
|
getAppVersion(): string;
|
|
/**
|
|
* Liefert die eindeutige Id der App.
|
|
* Die appId setzt sich zusammen aus
|
|
* <ul>
|
|
* <li>id des Entwicklungsservers</li>
|
|
* <li>FTP-Nutzername</li>
|
|
* <li>Ordnername der App -> appKey</li>
|
|
* </ul>
|
|
*/
|
|
getAppId(): string;
|
|
/**
|
|
* Liefert den eindeutigen Key der App.
|
|
* Der appKey ist der Ordnername, in dem die App liegt.
|
|
*/
|
|
getAppKey(): string;
|
|
/**
|
|
* Liefert den Entwickler der App, falls die serverId knuddelsDE oder knuddelsDEV ist, ansonsten null.
|
|
*/
|
|
getAppDeveloper(): User;
|
|
/**
|
|
* Liefert die Liste der AppManager für diese App. Die Channelbesitzer zählen automatisch auch als AppManager.
|
|
*/
|
|
getAppManagers(): User[];
|
|
/**
|
|
* Liefert den Steuersatz, der bei Auszahlung bereits genutzer Knuddel von einem
|
|
* KnuddelAccount an einen User
|
|
* anfällt. Die anfallenden Steuern werden bei Auszahlung vom BotUser
|
|
* abgezogen.
|
|
*/
|
|
getTaxRate(): number;
|
|
/**
|
|
* Liefert den KnuddelAmount, der an Steuern anfallen würde,
|
|
* wenn alle User jetzt all ihre Knuddel aus ihrem
|
|
* KnuddelAccount abheben würden.
|
|
*/
|
|
getTotalTaxKnuddelAmount(): KnuddelAmount;
|
|
/**
|
|
* Liefert den KnuddelAmount, der jetzt noch vom
|
|
* BotUser an KnuddelAccounts
|
|
* übertragen werden kann, so dass für alle Knuddel noch die Steuern bezahlt werden können.
|
|
*/
|
|
getMaxPayoutKnuddelAmount(): KnuddelAmount;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert die Instanz einer App.
|
|
*
|
|
* Die eigene Instanz von <code>AppInstance</code> erhält man über das AppAccess-Objekt
|
|
* mit appAccess.getOwnInstance()
|
|
*/
|
|
declare class AppInstance {
|
|
/**
|
|
* Liefert die AppInfo.
|
|
*/
|
|
getAppInfo(): AppInfo;
|
|
/**
|
|
* Sendet ein App-Event an diese App-Instanz.
|
|
*/
|
|
sendAppEvent(type: string, data: KnuddelsEvent): void;
|
|
/**
|
|
* Informiert, ob die aktuelle AppInstanz eine Root-Instanz ist.
|
|
*/
|
|
isRootInstance(): boolean;
|
|
/**
|
|
* Liefert die Root-Instanz der aktuellen App-Instanz.
|
|
*/
|
|
getRootInstance(): RootAppInstance;
|
|
/**
|
|
* Liefert alle App-Instanzen dieser App in diesem Channel und Subchannels.
|
|
* Mit <code>includeSelf = false</code> kann man die eigene Instanz ausschließen.
|
|
*/
|
|
getAllInstances(includeSelf?: boolean): AppInstance[];
|
|
/**
|
|
* Liefert den Startzeitpunkt dieser AppInstance.
|
|
*/
|
|
getStartDate(): Date;
|
|
/**
|
|
* Liefert die Namen der ChatCommands, die diese AppInstnce derzeit registriert hat.
|
|
*/
|
|
getRegisteredChatCommandNames(): (string[]|null);
|
|
/**
|
|
* Liefert den Namen des Channels in dem diese AppInstance läuft.
|
|
*/
|
|
getChannelName(): string;
|
|
}
|
|
|
|
/**
|
|
* Jede App besitzt eine AppPersistence in der global für diese App
|
|
* Informationen gespeichert werden können. An die Instanz der AppPersistence gelangt man durch den Aufruf
|
|
* KnuddelsServer.getPersistence();.
|
|
*/
|
|
declare class AppPersistence extends Persistence {
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz eines AppProfileEntry repräsentiert einen von einer App erzeugen Profileintrag in Profilen von Usern.
|
|
*/
|
|
declare class AppProfileEntry {
|
|
/**
|
|
* Liefert den key für den die Topliste, die den Profileintrag erzeugt angelegt wurde.
|
|
*/
|
|
getKey(): string;
|
|
/**
|
|
* Liefert den getDisplayType
|
|
*/
|
|
getDisplayType(): ToplistDisplayType;
|
|
/**
|
|
* Liefert das Toplist-Objekt.
|
|
*/
|
|
getToplist(): Toplist;
|
|
}
|
|
|
|
/**
|
|
* Mit einer Instanz von AppProfileEntryAccess kann eine App
|
|
* AppProfileEntry-Objekte (Profileinträge) erzeugen und verwalten.
|
|
*
|
|
* Die Instanz für die <code>AppProfileEntryAccess</code> erhält man über das KnuddelsServer-Objekt
|
|
* mit KnuddelsServer.getAppProfileEntryAccess()
|
|
*
|
|
* <br><br><b style="color:red;">Achtung:</b> Derzeit darf eine App bis zu <b>fünf</b> AppProfileEntries haben.
|
|
* <br><br><b style="color:red;">Achtung:</b> Profileinträge werden nur dann angezeigt, wenn der Channel sichtbar ist.
|
|
*/
|
|
declare class AppProfileEntryAccess {
|
|
/**
|
|
* Liefert die Liste aller AppProfileEntry-Objekte, die diese App erzeugt hat.
|
|
*/
|
|
getAllProfileEntries(): AppProfileEntry[];
|
|
/**
|
|
* Liefert den AppProfileEntry für den übergebenen userPersistenceNumberKey.
|
|
*/
|
|
getAppProfileEntry(userPersistenceNumberKey: string): AppProfileEntry;
|
|
/**
|
|
* Erzeugt oder aktualisiert ein AppProfileEntry anhand der übergebenen Toplist
|
|
* und dem ToplistDisplayType und liefert den AppProfileEntry im Anschluss zurück.
|
|
*
|
|
* Profileinträge, die erzeugt werden, sind nur sichtbar, solange die App läuft und werden im Profil ausgeblendet, sofern die App aus ist.
|
|
*/
|
|
createOrUpdateEntry(toplist: Toplist, toplistDisplayType: ToplistDisplayType): AppProfileEntry;
|
|
/**
|
|
* Löscht den übergebenen AppProfileEntry.
|
|
*/
|
|
removeEntry(appProfileEntry: AppProfileEntry): void;
|
|
}
|
|
|
|
/**
|
|
* Liefert Informationen über einen AppServer.
|
|
*
|
|
* Die Instanz von <code>AppServerInfo</code> erhält man über den KnuddelsServer
|
|
* mit KnuddelsServer.getAppServerInfo()
|
|
*/
|
|
declare class AppServerInfo extends ServerInfo {
|
|
}
|
|
|
|
/**
|
|
* null
|
|
*/
|
|
declare class AppViewMode {
|
|
/**
|
|
*
|
|
*/
|
|
static readonly Overlay: AppViewMode;
|
|
/**
|
|
* Zum Öffnen eines Popups durch das HTML User Interface
|
|
*/
|
|
static readonly Popup: AppViewMode;
|
|
}
|
|
|
|
/**
|
|
* Ein BotUser repräsentiert einen Nutzer, der für die App als Nutzer im Channel interagieren kann.
|
|
*
|
|
* Die Instanz für den <code>Standard-BotUser</code> erhält man über das KnuddelsServer-Objekt
|
|
* mit KnuddelsServer.getDefaultBotUser()
|
|
*/
|
|
declare class BotUser extends User {
|
|
/**
|
|
* Sendet eine öffentliche Nachricht in den Channel.
|
|
*/
|
|
sendPublicMessage(message: string): void;
|
|
/**
|
|
* Sendet eine öffentliche Handlung in den Channel.
|
|
* Dies funktioniert so, als ob der BotUser /me TEXT im Chat eingeben würde.
|
|
*/
|
|
sendPublicActionMessage(actionMessage: string): void;
|
|
/**
|
|
* Sendet eine private Nachricht an bestimmte Nutzer.
|
|
*/
|
|
sendPrivateMessage(message: string, users?: User[]): void;
|
|
/**
|
|
* Sendet eine persistente Nachricht an einen bestimmten Nutzer.
|
|
*/
|
|
sendPostMessage(topic: string, text: string, receivingUser?: User): void;
|
|
/**
|
|
* Transferiert eine bestimmte Anzahl Knuddel an einen Zielnutzer oder KnuddelAccount.<br /><br />
|
|
* <b style="color:red;">Wichtiger Hinweis:</b> Sollte die App versuchen mehr Knuddel zu transferieren,
|
|
* als sie besitzt, so wird der <code>onError</code>-Callback aufgerufen und die App transferiert so viele Knuddel, wie möglich.
|
|
* Zudem werden die Schulden für den Channelbesitzer gemerkt. Sobald sich der Channelbesitzer einloggt, erhält er einen Hinweis über offene Schulden
|
|
* und sollte diese direkt begleichen.
|
|
* Hat ein Channelbesitzer eine gewisse Menge Schulden angesammelt, so schalten wir alle Apps in diesem Channel ab.
|
|
* <br />Es können nur Knuddel transferiert werden zu Nutzern mit <code>UserType.Human</code>.
|
|
*/
|
|
transferKnuddel(receivingUserOrAccount: (User|KnuddelAccount), knuddelAmount: KnuddelAmount,
|
|
parameters?: { displayReasonText?: string; transferDisplayType?: KnuddelTransferDisplayType;
|
|
onSuccess?: () => void; onError?: (message: string) => void; }): void;
|
|
}
|
|
|
|
/**
|
|
* Ein Channel ist ein Raum in dem die App läuft.
|
|
*
|
|
* Die Instanz für den <code>Channel</code> erhält man über das KnuddelsServer-Objekt
|
|
* mit KnuddelsServer.getChannel()
|
|
*/
|
|
declare class Channel {
|
|
/**
|
|
* Gibt Zugriff auf das ChannelConfiguration-Objekt des Channels.
|
|
*/
|
|
getChannelConfiguration(): ChannelConfiguration;
|
|
/**
|
|
* Gibt Zugriff auf das ChannelRestrictions-Objekt des Channels.
|
|
*/
|
|
getChannelRestrictions(): ChannelRestrictions;
|
|
/**
|
|
* Gibt Zugriff auf das ChannelDesign-Objekt des Channels.
|
|
* @since AppServer 87470, ChatServer 87470
|
|
*/
|
|
getChannelDesign(): ChannelDesign;
|
|
/**
|
|
* Gibt Zugriff auf Nutzer, die gerade im Channel online sind.
|
|
*/
|
|
getOnlineUsers(...userType: UserType[]): User[];
|
|
/**
|
|
* Liefert die Information, ob in diesem Channel Videos gestreamt werden können.
|
|
*/
|
|
isVideoChannel(): boolean;
|
|
/**
|
|
* Liefert die VideoChannelData des Channels.
|
|
*/
|
|
getVideoChannelData(): VideoChannelData;
|
|
/**
|
|
* Liefert den Namen des Channels.
|
|
*/
|
|
getChannelName(): string;
|
|
/**
|
|
* Liefert den Namen des Root-Channels (nur relevant, falls die App Tochterchannel haben kann).
|
|
*/
|
|
getRootChannelName(): string;
|
|
/**
|
|
* Liefert den ChannelTalkMode, in dem sich der Channel gerade befindet.
|
|
*/
|
|
getTalkMode(): ChannelTalkMode;
|
|
/**
|
|
* Liefert alle User, die bestimmte ChannelTalkPermissions haben.
|
|
*/
|
|
getAllUsersWithTalkPermission(...channelTalkPermission: ChannelTalkPermission[]): User[];
|
|
/**
|
|
* Liefert die Information, ob der Channel sichtbar (<code>true</code>) oder unsichtbar (<code>false</code>) ist.
|
|
* @since AppServer 82202
|
|
*/
|
|
isVisible(): boolean;
|
|
}
|
|
|
|
/**
|
|
* Eine ChannelConfiguration erlaubt Zugriff auf verschiedene Details
|
|
* der Konfiguration des Channels, in dem die App läuft.
|
|
*
|
|
* Die Instanz für die <code>ChannelConfiguration</code> erhält man über das Channel-Objekt
|
|
* mit channel.getChannelConfiguration()
|
|
*/
|
|
declare class ChannelConfiguration {
|
|
/**
|
|
* Liefert das ChannelRights-Objekt des Channels.
|
|
*/
|
|
getChannelRights(): ChannelRights;
|
|
/**
|
|
* Liefert das ChannelInformation-Objekt des Channels.
|
|
*/
|
|
getChannelInformation(): ChannelInformation;
|
|
}
|
|
|
|
/**
|
|
* Ermöglicht Zugriff auf Designeinstellungen des Channels.
|
|
* @since AppServer 87470, ChatServer 87470
|
|
*/
|
|
declare class ChannelDesign {
|
|
/**
|
|
* Liefert die eingestellte Standard-Schriftgröße des Channels.
|
|
* @since AppServer 87470, ChatServer 87470
|
|
*/
|
|
getDefaultFontSize(): number;
|
|
/**
|
|
* Liefert die eingestellte Standard-Schriftfarbe des Channels.
|
|
* @since AppServer 87470, ChatServer 87470
|
|
*/
|
|
getDefaultFontColor(): Color;
|
|
/**
|
|
* Liefert die eingestellte Hintergrundfarbe des Channels.
|
|
* @since AppServer 87470, ChatServer 87470
|
|
*/
|
|
getBackgroundColor(): Color;
|
|
}
|
|
|
|
/**
|
|
* Ermöglicht Zugriff auf textuelle Channelinformationen und persistente Änderungen.
|
|
*/
|
|
declare class ChannelInformation {
|
|
/**
|
|
* Liefert das eingestellte Thema des Channels.
|
|
*/
|
|
getTopic(): string;
|
|
/**
|
|
* Aktualisiert das Thema das Channels.
|
|
*/
|
|
setTopic(topic: string, showMessage: boolean): void;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz der Klasse ChannelJoinPermission wird als Rückgabewert
|
|
* der Methode <code>App.mayJoinChannel(user)</code> benötigt.
|
|
*
|
|
* Hiermit wird bestimmt, ob der anfragende Nutzer den Channel betreten darf.
|
|
*
|
|
* Erlauben mit <code>ChannelJoinPermission.accepted()</code>
|
|
* Verbieten mit <code>ChannelJoinPermission.denied(denyReason)</code>
|
|
*/
|
|
declare class ChannelJoinPermission {
|
|
/**
|
|
* Erzeugt ein ChannelJoinPermission-Objekt, das den Zugriff in den Channel erlaubt.
|
|
*/
|
|
static accepted(): ChannelJoinPermission;
|
|
/**
|
|
* Erzeugt ein ChannelJoinPermission-Objekt, das den Zugriff in den Channel verbietet.
|
|
*/
|
|
static denied(denyReason: string): ChannelJoinPermission;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von ChannelRestrictions ermöglicht es, aktuelle Informationen über Nutzungsbeschränkungen im Channel zu erhalten.
|
|
*
|
|
* Die Instanz für die <code>ChannelRestrictions</code> erhält man über das Channel-Objekt
|
|
* mit channel.getChannelRestrictions()
|
|
*/
|
|
declare class ChannelRestrictions {
|
|
/**
|
|
* Liefert alle User die im Channel derzeit für das Schreiben öffentlicher Nachrichten gesperrt sind.
|
|
*/
|
|
getMutedUsers(): User[];
|
|
/**
|
|
* Liefert alle User die im Channel derzeit für das Nutzen
|
|
* von Farben, Textformatierung und Smileys in öffentlichen Nachrichten gesperrt sind.
|
|
*/
|
|
getColorMutedUsers(): User[];
|
|
/**
|
|
* Liefert alle User die für das Betreten des Channel derzeit gesperrt sind.
|
|
*/
|
|
getLockedUsers(): User[];
|
|
}
|
|
|
|
/**
|
|
* Die Instanz für die <code>ChannelRights</code> erhält man über das ChannelConfiguration-Objekt
|
|
* mit channelConfiguration.getChannelRights()
|
|
*/
|
|
declare class ChannelRights {
|
|
/**
|
|
* Liefert die Liste aller Channelbesitzer. In öffentlichen Channels sind dies alle hauptzuständigen betreuenden Mitglieder. (HZA/HZE)
|
|
*/
|
|
getChannelOwners(): User[];
|
|
/**
|
|
* Liefert die Liste aller Channel-Moderatoren.
|
|
*/
|
|
getChannelModerators(): User[];
|
|
/**
|
|
* Liefert die Liste aller Event-Moderatoren.
|
|
*/
|
|
getEventModerators(): User[];
|
|
}
|
|
|
|
/**
|
|
* ChannelTalkMode repräsentiert das den Gesprächsmodus im Channel.
|
|
*
|
|
* Die Instanz für die <code>ChannelTalkMode</code> erhält man über das Channel-Objekt
|
|
* mit channel.getTalkMode()
|
|
*/
|
|
declare class ChannelTalkMode {
|
|
/**
|
|
* Jeder darf gerade im Channel schreiben.
|
|
*/
|
|
static readonly Everyone: ChannelTalkMode;
|
|
/**
|
|
* Nur Personen, die besondere Rederechte haben dürfen gerade im Channel schreiben.
|
|
*/
|
|
static readonly OnlyWithTalkPermission: ChannelTalkMode;
|
|
/**
|
|
* Nur Personen, die besondere Rederechte haben dürfen gerade im Channel schreiben.
|
|
* Die Nachrichten aller anderen Nutzer werden gefiltert und ggf. von den Moderatoren zugelassen.
|
|
*/
|
|
static readonly FilteredByModerators: ChannelTalkMode;
|
|
}
|
|
|
|
/**
|
|
* ChannelTalkPermission repräsentiert das Rederecht eines User
|
|
* im Channel.
|
|
*/
|
|
declare class ChannelTalkPermission {
|
|
/**
|
|
* Der User ist gerade nicht im Channel,
|
|
* daher ist die ChannelTalkPermission nicht bekannnt.
|
|
*/
|
|
static readonly NotInChannel: ChannelTalkPermission;
|
|
/**
|
|
* Der User hat keine speziellen Rederechte.
|
|
* Beim ChannelTalkMode Default können diese User
|
|
* Nachrichten verfassen:
|
|
*/
|
|
static readonly Default: ChannelTalkPermission;
|
|
/**
|
|
* Der User kann eine öffentliche Nachricht verfassen. Danach wechselt die
|
|
* ChannelTalkPermission automatisch auf Default.
|
|
*/
|
|
static readonly TalkOnce: ChannelTalkPermission;
|
|
/**
|
|
* Der User kann permanent öffentliche Nachrichten verfassen.
|
|
*/
|
|
static readonly TalkPermanent: ChannelTalkPermission;
|
|
/**
|
|
* Der User ist VIP und kann öffentliche Nachrichten verfassen,
|
|
* die farbig und groß dargestellt werden.
|
|
*/
|
|
static readonly VIP: ChannelTalkPermission;
|
|
/**
|
|
* Der User ist VIP und kann öffentliche Nachrichten verfassen,
|
|
* die farbig und groß dargestellt werden. Moderatoren haben zudem weitere Möglichkeiten, die in der
|
|
* <a href="http://knuddels.de/doku/Moderationssystem.pdf" target="_blank">Anleitung zum Moderationssystem</a>
|
|
* nachgelesen werden können.
|
|
*/
|
|
static readonly Moderator: ChannelTalkPermission;
|
|
}
|
|
|
|
/**
|
|
* Liefert Informationen über einen ChatServer.
|
|
*
|
|
* Die Instanz von <code>ChatServerInfo</code> erhält man über den KnuddelsServer
|
|
* mit KnuddelsServer.getChatServerInfo()
|
|
*/
|
|
declare class ChatServerInfo extends ServerInfo {
|
|
/**
|
|
* Liefert die Information, ob dieser Chat-Server ein Test-System ist.
|
|
*/
|
|
isTestSystem(): boolean;
|
|
}
|
|
|
|
/**
|
|
* Klasse, die es ermöglicht den Client innerhalb des HTML User Interface zu steuern und Daten an den Server zu senden.
|
|
*/
|
|
declare class Client {
|
|
/**
|
|
* Schließt das HTML User Interface.
|
|
*/
|
|
static close(): void;
|
|
/**
|
|
* Sendet ein Event zum Server, das mit dem AppHook onEventReceived in der App
|
|
* abgefangen werden kann.
|
|
*/
|
|
static sendEvent(type: string, data: KnuddelsEvent): void;
|
|
/**
|
|
* Sagt dem Chatserver, dass dieser Befehl für den Nutzer, der das HTML User Interface sieht, ausgeführt werden soll.
|
|
* Ist der Befehl auf einer Whitelist vom Server, so wird er sofort ausgeführt. Im anderen Falle sieht der Nutzer einen
|
|
* Link zum Bestätigen, mit dem er die Aktion starten kann.
|
|
*
|
|
* Derzeit sind diese Befehle auf der Whitelist: w, info, wc, top, h, dice, d, diceo, w2, serverpp, knuddelaccount,
|
|
* /tf-insert, /tf-inserts, /tf-insertb, /tf-insertsb, /tf-override, /tf-overrides, /tf-overrideb, /tf-overridesb, /autotype
|
|
*/
|
|
static executeSlashCommand(command: string): void;
|
|
/**
|
|
* Bindet eine Javascript-Datei ein und sorgt dafür, dass immer die aktuellste Version vom Server geladen wird.
|
|
*/
|
|
static includeJS(...files: string[]): void;
|
|
/**
|
|
* Registriert sich für ein bestimmtes Event, das vom Server mittels User/sendEvent:method oder vom Client via Client/dispatchEvent:method verschickt wurde.
|
|
*/
|
|
static addEventListener(type: string, callback: (event: {type: string, data: KnuddelsEvent}) => void): void;
|
|
/**
|
|
* Sendet ein bestimmtes Event, so dass alle mit Client/addEventListener:method registrierten Listener aufgerufen werden.
|
|
*/
|
|
static dispatchEvent(event: Client.Event): void;
|
|
/**
|
|
* Entfernt alle Event-Listener für einen bestimmten Event-Typ.
|
|
*/
|
|
static removeEventListener(type: string): void;
|
|
/**
|
|
* Bindet eine CSS-Datei ein und sorgt dafür, dass immer die aktuellste Version vom Server geladen wird.
|
|
*/
|
|
static includeCSS(...files: string[]): void;
|
|
/**
|
|
* Spielt einen Sound ab. Der angegebene Dateiname kann hierbei entweder absolut oder relativ zur angezeigten HTML-Datei sein.
|
|
* Bisher können nur Dateien mit Wave-Format zuverlässig abgespielt werden.
|
|
*/
|
|
static playSound(fileName: string): void;
|
|
/**
|
|
* Lädt einen Sound herunter, damit die Datei später ohne Wartezeit abgespielt werden kann.
|
|
* (Android only)
|
|
* Der angegebene Dateiname kann hierbei entweder absolut oder relativ zur angezeigten HTML-Datei sein.
|
|
*/
|
|
static prefetchSound(fileName: string): void;
|
|
/**
|
|
* Gibt einen Sound wieder frei, der in nächster Zeit vom Client nicht mehr gebraucht wird.
|
|
* (Android only)
|
|
* Der angegebene Dateiname kann hierbei entweder absolut oder relativ zur angezeigten HTML-Datei sein.
|
|
*/
|
|
static freeSound(fileName: string): void;
|
|
/**
|
|
* Liefert den HostFrame des aktuellen Inhalts.
|
|
*/
|
|
static getHostFrame(): Client.HostFrame;
|
|
/**
|
|
* Liefert den Nicknamen des Users, der gerade dieses HTML User Interface angezeigt bekommt.
|
|
*/
|
|
static getNick(): string;
|
|
/**
|
|
* Liefert den aktuellen ClientType des Nutzers, der gerade dieses HTML User Interface angezeigt bekommt.
|
|
*/
|
|
static getClientType(): ClientType;
|
|
/**
|
|
* Liefert die Id, die beim Laden von Skripten und Stylesheets an die URL angehängt wird, um sicherzustellen, dass eine neue Version
|
|
* der Datei vom Server geholt wird, statt die Datei aus dem Cache zu laden.
|
|
*
|
|
* Diese Id kann beim Einbinden eigener Ressourcen zum selben Zweck genutzt werden.
|
|
*/
|
|
static getCacheInvalidationId(): string;
|
|
/**
|
|
* Beinhaltet die JSON-Daten, die beim Erstellen des HTMLFile übergeben wurden.
|
|
*/
|
|
static pageData: Json;
|
|
}
|
|
|
|
/**
|
|
* Klasse, mit der clientseitige Farbobjekte erstellt werden können.
|
|
*/
|
|
declare module Client {
|
|
export class Color {
|
|
/**
|
|
* Erzeugt ein Color-Objekt mit RGB-Werten.
|
|
*/
|
|
static fromRGB(red: number, green: number, blue: number): Color;
|
|
/**
|
|
* Erzeugt ein Color-Objekt aus einem HexString.
|
|
*/
|
|
static fromHexString(colorString: string): Color;
|
|
/**
|
|
* Liefert den Rot-Anteil der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getRed(): number;
|
|
/**
|
|
* Liefert den Grün-Anteil der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getGreen(): number;
|
|
/**
|
|
* Liefert den Blau-Anteil der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getBlue(): number;
|
|
/**
|
|
* Liefert die Farbe als in CSS nutzbaren HexString.
|
|
*/
|
|
asHexString(): string;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Klasse, die es ermöglicht ein Event via Client/dispatchEvent:method zu versenden.
|
|
*/
|
|
declare module Client {
|
|
export class Event {
|
|
/**
|
|
* Erzeugt ein Event.
|
|
*/
|
|
constructor(type: string, data: KnuddelsEvent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Klasse, die es ermöglicht den Inhalte zu steuern, die im Bereich liegen, der das HTML User Interface hostet.
|
|
*/
|
|
declare module Client {
|
|
export class HostFrame {
|
|
/**
|
|
* Setzt den Titel der Seite im gezoomten Modus (nur Android).
|
|
*/
|
|
setTitle(newTitle: string): void;
|
|
/**
|
|
* Ändert die sichtbare Hintergrundfarbe des Hostframes animiert. (Android-only)
|
|
*/
|
|
setBackgroundColor(newColor: Color, durationMillis?: number): void;
|
|
/**
|
|
* Setzt die Icons, die als Fenster-Icon angezeigt werden sollen. (Applet-only, nur mit AppViewMode.Popup)
|
|
* Die Bilder müssen von groß nach klein sortiert sein. Die größeren Bilder werden (je nach System) automatisch dann eingesetzt,
|
|
* wenn größere Bilder benötigt werden (z.B. in der Task-Leiste, oder beim Alt+Tab Fenster-Wechsel).
|
|
* @since Applet: 9.0bwj, AppServer: 84904
|
|
*/
|
|
setIcons(...path: string[]): void;
|
|
/**
|
|
* Setzt, ob das Fenster resizable ist. (Applet-only, nur mit AppViewMode.Popup)
|
|
*/
|
|
setResizable(resizable: boolean): void;
|
|
/**
|
|
* Bringt das Fenster der App (App-Popup bzw. Chat-Fenster) in den Vordergrund. (Applet-only)
|
|
* @since Applet: 9.0bwj, AppServer: 84904
|
|
*/
|
|
focus(): void;
|
|
/**
|
|
* Ändert die Größe des App-Fensters (AppViewMode.Popup) bzw. App-Overlays (AppViewMode.Overlay).
|
|
* @since Applet: 9.0bwj, AppServer: 84516
|
|
*/
|
|
setSize(width: number, height: number): void;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ClientType repräsentiert die Art der Chat-Verbindung des Users.
|
|
*
|
|
* Eine Instanz von <code>ClientType</code> erhält man über das User-Objekt
|
|
* mit user.getClientType()
|
|
*/
|
|
declare class ClientType {
|
|
/**
|
|
* Der User ist mit dem Java Applet im Chat.
|
|
*/
|
|
static readonly Applet: ClientType;
|
|
/**
|
|
* Der User ist mit dem Browser im Chat (Mini-Chat, HTML-Chat).
|
|
*/
|
|
static readonly Browser: ClientType;
|
|
/**
|
|
* Der User ist mit der Android-App im Chat.
|
|
*/
|
|
static readonly Android: ClientType;
|
|
/**
|
|
* Der User ist mit der iOS-App im Chat.
|
|
*/
|
|
static readonly IOS: ClientType;
|
|
/**
|
|
* Der User ist nicht im Chat.
|
|
*/
|
|
static readonly Offline: ClientType;
|
|
}
|
|
|
|
/**
|
|
* Klasse, mit der serverseitige Farbobjekte erstellt werden können.
|
|
*/
|
|
declare class Color {
|
|
/**
|
|
* Erzeugt ein serverseitiges Color-Objekt mit RGB-Werten.
|
|
* Als Alpha-Wert wird automatisch 255 genutzt.
|
|
*/
|
|
static fromRGB(red: number, green: number, blue: number): Color;
|
|
/**
|
|
* Erzeugt ein serverseitiges Color-Objekt mit RGBA-Werten.
|
|
*/
|
|
static fromRGBA(red: number, green: number, blue: number, alpha: number): Color;
|
|
/**
|
|
* Liefert den Alpha-Wert der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getAlpha(): number;
|
|
/**
|
|
* Liefert den Blau-Anteil der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getBlue(): number;
|
|
/**
|
|
* Liefert den Grün-Anteil der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getGreen(): number;
|
|
/**
|
|
* Liefert den Rot-Anteil der Farbe als Zahl zwischen 0 und 255.
|
|
*/
|
|
getRed(): number;
|
|
/**
|
|
* Liefert die Farbe als KCode zurück.
|
|
*/
|
|
toKCode(): string;
|
|
/**
|
|
* Liefert die numerische Repräsentation der Farbe zurück.
|
|
*/
|
|
asNumber(): number;
|
|
/**
|
|
* Erzeugt ein serverseitiges Color-Objekt aus der numerischen Repräsentation einer Farbe.
|
|
*/
|
|
static fromNumber(value: number): Color;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von Dice repräsentiert die Anzahl an Würfeln von einerm bestimmten Typ.
|
|
*/
|
|
declare class Dice {
|
|
/**
|
|
* Erzeugt ein Dice-Objekt mit der übergebenen Anzahl Würfel und Augenzahl.
|
|
*/
|
|
constructor(count: number /* optional */, value: number);
|
|
/**
|
|
* Liefert die Anzahl der Würfel.
|
|
*/
|
|
getAmount(): number;
|
|
/**
|
|
* Liefert die Anzahl der Seiten der Würfel.
|
|
*/
|
|
getNumberOfSides(): number;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von DiceConfiguration repräsentiert eindeutig eine Konfiguration zum würfeln.
|
|
* Wurde gewürfelt, so können die Konfigurationen verglichen werden, um zu prüfen, ob exakt die Würfel
|
|
* gewürfelt wurden, die gewürfelt werden sollten.
|
|
*/
|
|
declare class DiceConfiguration {
|
|
/**
|
|
* Informiert, ob es sich um einen offenen Würfelwurf handelt.
|
|
* Offene Würfelwürfe sind speziell. Falls die Augenzahl des Würfels die Maximalsumme zeigt,
|
|
* so wird noch einmal gewürfelt und die neue Zahl dazu addiert, solange bis der Würfel
|
|
* nicht mehr die Maximalsumme zeigt.
|
|
*
|
|
* <b>Beispiel:</b> /diceo 1w4 -> 4 -> 4 -> 3 = 11
|
|
*/
|
|
isUsingOpenThrow(): boolean;
|
|
/**
|
|
* Informiert darüber, ob die Würfel privat geworfen worden sind.
|
|
* Würfelwürfe zählen als privat, wenn am Ende des Würfelbefehls ein Ausrufezeichen steht.
|
|
* <b>Beispiel:</b> /dice 10w2!
|
|
*/
|
|
isUsingPrivateThrow(): boolean;
|
|
/**
|
|
* Liefert ein Array mit Würfeln, mit denen gewürfelt wurde.
|
|
*/
|
|
getDices(): Dice[];
|
|
/**
|
|
* Vergleicht, ob zwei Konfigurationen inhaltlich identisch sind
|
|
*/
|
|
equals(diceConfiguration: DiceConfiguration): boolean;
|
|
/**
|
|
* Liefert den Befehl, der im Chat eingegeben werden kann, um einen Wurf auszuführen,
|
|
* der zur DiceConfiguration passt.
|
|
* @since AppServer 82248
|
|
*/
|
|
getChatCommand(): string;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz einer DiceConfigurationFactory kann zur Unterstützung genutzt werden, um eine
|
|
* DiceConfiguration zu erzeugen.
|
|
*/
|
|
declare class DiceConfigurationFactory {
|
|
/**
|
|
* Fügt der Konfiguration einen Würfel hinzu.
|
|
*/
|
|
addDice(dice: Dice): void;
|
|
/**
|
|
* Liefert die Anzahl der Würfel, die zur Konfiguration gehören.
|
|
*/
|
|
computeCurrentDiceCount(): number;
|
|
/**
|
|
* Setzt die Information, ob ein offener Wurf oder ein normaler Wurf stattfinden soll.
|
|
* Offene Würfelwürfe sind speziell. Falls die Augenzahl des Würfels die Maximalsumme zeigt,
|
|
* so wird noch einmal gewürfelt und die neue Zahl dazu addiert, solange bis der Würfel
|
|
* nicht mehr die Maximalsumme zeigt.
|
|
*
|
|
* <b>Beispiel:</b> /diceo 1w4 -> 4 -> 4 -> 3 = 11
|
|
*/
|
|
setUseOpenThrow(shouldUseOpenThrow: boolean): void;
|
|
/**
|
|
* Setzt die Information, ob der Würfelwurf privat stattfinden soll.
|
|
*/
|
|
setShouldUsePrivateThrow(shouldUsePrivateThrow: boolean): void;
|
|
/**
|
|
* Liefert die erzeugte Würfelkonfiguration.
|
|
*/
|
|
getDiceConfiguration(): DiceConfiguration;
|
|
/**
|
|
* Erzeugt eine Würfelkonfiguration.
|
|
*/
|
|
static fromString(diceConfigurationString: string): DiceConfiguration;
|
|
}
|
|
|
|
/**
|
|
* Wird in der App die Methode onUserDiced überschrieben, so erhält diese bei jedem Würfelwurf ein DiceEvent.
|
|
* Ein DiceEvent ermöglicht einem detaillierte Informationen rund um diesen Würfelwurf in Erfahrung zu bringen.
|
|
*/
|
|
declare class DiceEvent {
|
|
/**
|
|
* Liefert den Nutzer, der gewürfelt hat.
|
|
*/
|
|
getUser(): User;
|
|
/**
|
|
* Liefert das DiceResult des Würfelwurfs.
|
|
*/
|
|
getDiceResult(): DiceResult;
|
|
}
|
|
|
|
/**
|
|
* Ein DiceResult beinhaltet konkrete Informationen über einen Würfelwurf.
|
|
*/
|
|
declare class DiceResult {
|
|
/**
|
|
* Liefert die Konfiguration mit der gewürfelt wurde.
|
|
*/
|
|
getDiceConfiguration(): DiceConfiguration;
|
|
/**
|
|
* Liefert ein Array mit Details zu den einzelnen Ergebnissen pro Würfeltyp.
|
|
*/
|
|
getSingleDiceResults(): SingleDiceResult[];
|
|
/**
|
|
* Liefert die Summe der Augenzahlen aller Würfel
|
|
*/
|
|
totalSum(): number;
|
|
}
|
|
|
|
/**
|
|
* Die Instanz einer Domain beinhaltet alle relevanten Informationen zur Domain.
|
|
*/
|
|
declare class Domain {
|
|
/**
|
|
* Liefert ein den Domain-Namen der aktuellen Domain.
|
|
*/
|
|
getDomainName(): string;
|
|
}
|
|
|
|
/**
|
|
* Die Instanz von <code>ExternalServerAccess</code> erhält man über die KnuddelsServer.getExternalServerAccess().
|
|
* Damit der Zugriff auf einen externern Server funktioniert, muss auf dem Server eine Datei <code>knuddelsAccess.txt</code> abgelegt werden, die die FTP-User-ID des Entwicklers enthält.
|
|
*/
|
|
declare class ExternalServerAccess {
|
|
/**
|
|
* Liefert eine Liste aller zugreifbaren Domains
|
|
*/
|
|
getAllAccessibleDomains(): Domain[];
|
|
/**
|
|
* Prüft den Zugriff auf eine bestimmte URL. Wird je Kombination von "Protokoll + Host + Port" geprüft.<br>
|
|
* Beispiel: http://www.example.de:8080
|
|
*/
|
|
canAccessURL(urlString: string): boolean;
|
|
/**
|
|
* Macht einen GET-Request auf die übergebene URL und liefert den Inhalt zurück.
|
|
* Diese Methode ist eine Convenience-Methode für externalServerAccess.callURL().
|
|
*/
|
|
getURL(urlString: string, parameters?: { onSuccess?: (responseData: string, externalServerResponse: ExternalServerResponse) => void;
|
|
onFailure?: (responseData: string, externalServerResponse: ExternalServerResponse) => void; }): void;
|
|
/**
|
|
* Macht einen POST-Request auf die übergebene URL und liefert den Inhalt zurück.
|
|
* Diese Methode ist eine Convenience-Methode für externalServerAccess.callURL().
|
|
*/
|
|
postURL(urlString: string, parameters?: { onSuccess?: (responseData: string, externalServerResponse: ExternalServerResponse) => void;
|
|
onFailure?: (responseData: string, externalServerResponse: ExternalServerResponse) => void; data?: Json; }): void;
|
|
/**
|
|
* Macht einen GET-Request auf die übergebene URL. Im Gegensatz zum GET-Request wird der Inhalt der Webseite wird nicht ausgelesen.
|
|
* Aus diesem Grund ist diese Methode schneller.
|
|
* Diese Methode ist eine Convenience-Methode für externalServerAccess.callURL().
|
|
*/
|
|
touchURL(urlString: string, parameters?: { onSuccess?: (responseData: string, externalServerResponse: ExternalServerResponse) => void;
|
|
onFailure?: (responseData: string, externalServerResponse: ExternalServerResponse) => void; }): void;
|
|
/**
|
|
* Macht einen Request auf die übergebene URL.
|
|
*/
|
|
callURL(urlString: string, parameters?: { onSuccess?: (responseData: string, externalServerResponse: ExternalServerResponse) => void;
|
|
onFailure?: (responseData: string, externalServerResponse: ExternalServerResponse) => void; method?: ("GET" | "POST"); data?: Json; }): void;
|
|
}
|
|
|
|
/**
|
|
* Die Instanz von <code>ExternalServerResponse</code> erhält in den onSuccess- und onFailure-Callbacks der Methoden von
|
|
* ExternalServerAccess. Es enthält alle notwendigen Daten zum Verarbeiten.
|
|
*/
|
|
declare class ExternalServerResponse {
|
|
/**
|
|
* Liefert die abgefragte URL.
|
|
*/
|
|
getURLString(): string;
|
|
/**
|
|
* Liefert den <a href="https://de.wikipedia.org/wiki/HTTP-Statuscode" target="_blank">HTTP-Statuscode</a> der Seite.
|
|
*/
|
|
getResponseCode(): number;
|
|
/**
|
|
* Liefert ein Objekt, das die Headerdaten der Antwort enthält.
|
|
*/
|
|
getHeaderFields(): { [key: string]: string[] };
|
|
}
|
|
|
|
/**
|
|
* Gender repräsentiert das Geschlecht eines User.
|
|
*/
|
|
declare class Gender {
|
|
/**
|
|
* Das Geschlecht ist männlich.
|
|
*/
|
|
static readonly Male: Gender;
|
|
/**
|
|
* Das Geschlecht ist weiblich.
|
|
*/
|
|
static readonly Female: Gender;
|
|
/**
|
|
* Das Geschlecht ist nicht bekannt.
|
|
*/
|
|
static readonly Unknown: Gender;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert eine HTML-Datei, die auf dem Server im Ordner /www liegt.
|
|
*/
|
|
declare class HTMLFile {
|
|
/**
|
|
*
|
|
*/
|
|
constructor(assetPath: string, pageData?: Json);
|
|
/**
|
|
* Liefert den Pfad, der beim Anlegen der HTMLFile-Instanz genutzt wurde.
|
|
*/
|
|
getAssetPath(): string;
|
|
/**
|
|
* Liefert die pageData, die beim Anlegen der HTMLFile-Instanz genutzt wurden.
|
|
*/
|
|
getPageData(): Json;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von KnuddelAccount ermöglicht den Zugriff auf die freigegebenen Knuddel
|
|
* eines bestimmten User. Knuddel können abgezogen und addiert werden.
|
|
*/
|
|
declare class KnuddelAccount {
|
|
/**
|
|
* Liefert den KnuddelAmount eines Users,
|
|
* über den die App gerade frei verfügen kann.
|
|
*/
|
|
getKnuddelAmount(): KnuddelAmount;
|
|
/**
|
|
* Liefert den KnuddelAmount aus dem KnuddelAccount,
|
|
* der bereits von der App genutzt wurde.
|
|
* Beim Auszahlen dieser Knuddel aus dem KnuddelAccount an den
|
|
* User fallen Steuern an.
|
|
*/
|
|
getKnuddelAmountUsed(): KnuddelAmount;
|
|
/**
|
|
* Liefert den KnuddelAmount aus dem KnuddelAccount,
|
|
* der noch nicht von der App genutzt wurde.
|
|
* Beim Auszahlen dieser Knuddel aus dem KnuddelAccount an den
|
|
* User fallen <strong>keine</strong> Steuern an.
|
|
*/
|
|
getKnuddelAmountUnused(): KnuddelAmount;
|
|
/**
|
|
* Liefert die Summe aller Transfers, die die App an diesen KnuddelAccount bzw. User überwiesen hat.
|
|
*/
|
|
getTotalKnuddelAmountAppToUser(): KnuddelAmount;
|
|
/**
|
|
* Liefert die Summe aller Transfers, die die App von diesem KnuddelAccount bzw. User abgebucht/erhalten hat.
|
|
*/
|
|
getTotalKnuddelAmountUserToApp(): KnuddelAmount;
|
|
/**
|
|
* Liefert die Information, ob in diesem Moment genug Knuddel verfügbar sind.
|
|
*/
|
|
hasEnough(knuddelAmount: KnuddelAmount): boolean;
|
|
/**
|
|
* Liefert den Nutzer, dem der KnuddelAccount gehört.
|
|
*/
|
|
getUser(): User;
|
|
/**
|
|
* Versucht eine bestimmte Menge Knuddel zu verwenden. Dies ist nur möglich, wenn der User auf seinem KnuddelAccount
|
|
* genug Knuddel besitzt <strong>und</strong> online im Channel ist.
|
|
* Vom KnuddelAccount des Besitzer des Channel können Knuddel auch abgebucht werden, wenn dieser nicht im Channel online ist.
|
|
*
|
|
* Ist das Event App.onBeforeKnuddelReceived implementiert, so wird diese direkt nach dem <code>use</code> aufgerufen,
|
|
* um zu entscheiden, ob die Knuddel angenommen werden sollen.
|
|
*
|
|
* <br ><br ><b>Hinweis:</b> Knuddel an einen Nutzer senden kannst du mit der Methode BotUser/transferKnuddel:method.
|
|
*/
|
|
use(knuddelAmount: KnuddelAmount, displayReasonText: string, parameters?: { transferReason?: string; onError?: (message: string) => void; onSuccess?: () => void; }): void;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von KnuddelAmount repräsentiert eine bestimmte Anzahl von Knuddel.
|
|
*/
|
|
declare class KnuddelAmount {
|
|
/**
|
|
* Erzeugt eine Instanz von KnuddelAmount mit der Anzahl Knuddel.
|
|
*/
|
|
constructor(knuddel: number);
|
|
/**
|
|
* Erzeugt eine Instanz von KnuddelAmount mit einer bestimmten Cent-Anzahl.
|
|
*/
|
|
static fromCents(knuddel: number): KnuddelAmount;
|
|
/**
|
|
* Erzeugt eine Instanz von KnuddelAmount mit einer bestimmten Knuddel-Anzahl.
|
|
*/
|
|
static fromKnuddel(knuddel: number): KnuddelAmount;
|
|
/**
|
|
* Liefert die Anzahl der Knuddel in KnuddelCent zurück.
|
|
*/
|
|
getKnuddelCents(): number;
|
|
/**
|
|
* Gibt den Wert der Knuddel als Zahl zurück.
|
|
*/
|
|
asNumber(): number;
|
|
/**
|
|
* Liefert eine negierte Kopie des KnuddelAmount zurück.
|
|
*/
|
|
negate(): KnuddelAmount;
|
|
/**
|
|
* Liefert die Information, ob der Knuddelwert unter 0 ist.
|
|
*/
|
|
isNegative(): boolean;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert einen KnuddelPot.
|
|
* Ein KnuddelPot kann nur durch Factory-Methoden des KnuddelsServer erzeugt werden:
|
|
* KnuddelsServer/createKnuddelPot:method.
|
|
*
|
|
* Wird die App heruntergefahren, so werden alle KnuddelPots, die nicht gesealt sind automatisch refunded.
|
|
*/
|
|
declare class KnuddelPot {
|
|
/**
|
|
* Liefert die id des KnuddelPot.
|
|
*/
|
|
getId(): number;
|
|
/**
|
|
* Liefert den Status des KnuddelPot.
|
|
*/
|
|
getState(): KnuddelPotState;
|
|
/**
|
|
* Liefert den beim Kreieren des KnuddelPots festgelegten KnuddelAmount, den jeder Teilnehmer zahlen muss.
|
|
*/
|
|
getKnuddelAmountPerParticipant(): KnuddelAmount;
|
|
/**
|
|
* Liefert den KnuddelAmount, der bisher insgesamt in den KnuddelPot eingezahlt wurde.
|
|
*/
|
|
getKnuddelAmountTotal(): KnuddelAmount;
|
|
/**
|
|
* Liefert die Liste der Teilnehmer, die bisher in den KnuddelPot eingezahlt haben.
|
|
*/
|
|
getParticipants(): User[];
|
|
/**
|
|
* Liefert den höchsten Multiplikator, der gültig ist.
|
|
*/
|
|
getMaxFeeMultiplier(): number;
|
|
/**
|
|
* Setzt den BotUser, der den Anteil der Einzahlungen nach dem Spiel erhält
|
|
* und den Anteil, vom Gesamtpot, den er erhalten soll.
|
|
*/
|
|
setFee(feeUser: BotUser, feeMultiplier: number): void;
|
|
/**
|
|
* Liefert den mit KnuddelPot/setFee:method gesetzten BotUser an den die Gebühr ausbezahlt wird.
|
|
*/
|
|
getFeeUser(): User;
|
|
/**
|
|
* Liefert den mit KnuddelPot/setFee:method gesetzten Multiplikator der Gebühr.
|
|
*/
|
|
getFeeMultiplier(): number;
|
|
/**
|
|
* Versiegelt den KnuddelPot, sodass keine weiteren Einzahlungen vorgenommen
|
|
* werden können und Gewinne ausgeschüttet werden können.
|
|
*/
|
|
seal(): void;
|
|
/**
|
|
* Bezahlt alle Einsätze an die Teilnehmer zurück und informiert mit dem übergeben Text über den Grund.
|
|
*/
|
|
refund(reason?: string): void;
|
|
/**
|
|
* Fügt einen Gewinner in die Liste der Gewinner hinzu.
|
|
* Der zweite Parameter ist die Gewichtung mit der ausgezahlt werden soll.
|
|
* Wird der Parameter weggelassen, so ist er automatisch 1.
|
|
*/
|
|
addWinner(user: User, weight?: number): void;
|
|
/**
|
|
* Zahlt den KnuddelPot an die mit addWinner gesetzten Gewinner aus.
|
|
*/
|
|
payout(text?: string): void;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert den Status eines KnuddelPot.
|
|
*/
|
|
declare class KnuddelPotState {
|
|
/**
|
|
* Der KnuddelPot ist geöffnet und kann neue Teilnehmer annehmen.
|
|
*/
|
|
static readonly Open: KnuddelPotState;
|
|
/**
|
|
* Der KnuddelPot ist versiegelt und kann keine neuen Teilnehmer annehmen.
|
|
*/
|
|
static readonly Sealed: KnuddelPotState;
|
|
/**
|
|
* Der KnuddelPot ist beendet und die Knuddel bereits ausgezahlt.
|
|
*/
|
|
static readonly Closed: KnuddelPotState;
|
|
}
|
|
|
|
/**
|
|
* Ein KnuddelTransfer ist ein Container-Objekt für die Daten, die bei einer Knuddel-Transaktion von einem User
|
|
* an eine App anfallen.
|
|
*
|
|
* Implementiert man den App-Hook <code>onBeforeKnuddelReceived</code>, so kann man dort entscheiden, ob man den KnuddelTransfer
|
|
* annimmt oder ablehnt.
|
|
*/
|
|
declare class KnuddelTransfer {
|
|
/**
|
|
* Liefert den User, der den KnuddelTransfer ausgelöst hat.
|
|
*/
|
|
getSender(): User;
|
|
/**
|
|
* Liefert den BotUser, der die Knuddel des KnuddelTransfer erhält,
|
|
* wenn dieser mit accept()</code> angenommen wurde.
|
|
*/
|
|
getReceiver(): BotUser;
|
|
/**
|
|
* Liefert die Anzahl der Knuddel, die mit diesem Transfer überwiesen werden.
|
|
*/
|
|
getKnuddelAmount(): KnuddelAmount;
|
|
/**
|
|
* Liefert den Grund für den Transfer, der bei der Überweisung angegeben wurde mit
|
|
* <code>/appknuddel BOTNICK:KNUDDEL:GRUND</code>.
|
|
*/
|
|
getTransferReason(): string;
|
|
/**
|
|
* Lehnt die Knuddel aus dem KnuddelTransfer ab und sendet sie zurück an den Absender.
|
|
* Als Grund sieht der Absender den übergebenen <code>reason</code>.
|
|
*
|
|
* Diese Methode wirft eine Exception, wenn sie auf einen bereits verarbeiteten Transfer aufgerufen wird.
|
|
* Sie kann nur erfolgreich aus dem AppHook <code>onBeforeKnuddelReceived</code> aufgerufen werden.
|
|
*
|
|
* In der Methode <code>onBeforeKnuddelReceived</code> kann genau ein Aufruf einer dieser drei Methoden gemacht werden:
|
|
* KnuddelTransfer/accept:method,
|
|
* KnuddelTransfer/addToPot:method,
|
|
* KnuddelTransfer/reject:method
|
|
*/
|
|
reject(reason: string): void;
|
|
/**
|
|
* Nimmt die Knuddel aus dem KnuddelTransfer an und übergibt sie an den BotUser,
|
|
* der mit <code>getReceiver()</code> abgefragt werden kann.
|
|
*
|
|
* Diese Methode wirft eine Exception, wenn sie auf einen bereits verarbeiteten Transfer aufgerufen wird.
|
|
* Sie kann nur erfolgreich aus dem AppHook <code>onBeforeKnuddelReceived</code> aufgerufen werden.
|
|
* In der Methode <code>onBeforeKnuddelReceived</code> kann genau ein Aufruf einer dieser drei Methoden gemacht werden:
|
|
*
|
|
* KnuddelTransfer/accept:method,
|
|
* KnuddelTransfer/addToPot:method,
|
|
* KnuddelTransfer/reject:method
|
|
*/
|
|
accept(): void;
|
|
/**
|
|
* Liefert die Information, ob ein bestimmter KnuddelTransfer zu einem KnuddelPot hinzugefügt werden kann.
|
|
*/
|
|
canAddToPot(pot: KnuddelPot): boolean;
|
|
/**
|
|
* Nimmt die Knuddel aus dem KnuddelTransfer an und übergibt sie an den übergebenen KnuddelPot.
|
|
*
|
|
* Diese Methode funktioniert analog zu KnuddelTransfer/accept:method, nur dass die Knuddel im KnuddelPot statt beim BotUser landen.
|
|
*
|
|
* Diese Methode wirft eine Exception, wenn sie auf einen bereits verarbeiteten Transfer aufgerufen wird.
|
|
* Sie kann nur erfolgreich aus dem AppHook <code>onBeforeKnuddelReceived</code> aufgerufen werden.
|
|
*
|
|
* In der Methode <code>onBeforeKnuddelReceived</code> kann genau ein Aufruf einer dieser drei Methoden gemacht werden:
|
|
* KnuddelTransfer/accept:method,
|
|
* KnuddelTransfer/addToPot:method,
|
|
* KnuddelTransfer/reject:method
|
|
*/
|
|
addToPot(knuddelPot: KnuddelPot): void;
|
|
/**
|
|
* Liefert die Information, ob der KnuddelTransfer bereits verarbeitet wurde.
|
|
* Falls die Methode <code>false</code> zurückliefert muss noch entschieden werden, ob der
|
|
* KnuddelTransfer angenommen oder abgelehnt wird.
|
|
*/
|
|
isProcessed(): boolean;
|
|
}
|
|
|
|
/**
|
|
* KnuddelTransferDisplayType repräsentiert die Art der Darstellung einer Knuddel-Überweisung.
|
|
*/
|
|
declare class KnuddelTransferDisplayType {
|
|
/**
|
|
* Nachricht wird öffentlich angezeigt.
|
|
*/
|
|
static readonly Public: KnuddelTransferDisplayType;
|
|
/**
|
|
* Nachricht wird privat angezeigt.
|
|
*/
|
|
static readonly Private: KnuddelTransferDisplayType;
|
|
/**
|
|
* Nachricht wird als /m zugestellt.
|
|
*/
|
|
static readonly Post: KnuddelTransferDisplayType;
|
|
}
|
|
|
|
/**
|
|
* KnuddelsServer ist die 'Einstiegsklasse'. Mit den statischen Methoden des KnuddelsServer erhält man Zugriff auf viele
|
|
* Objekte und Klassen, die im Verlauf der App-Entwicklung benötigt werden.
|
|
*/
|
|
declare class KnuddelsServer {
|
|
/**
|
|
* Liefert den BotUser, der standardmäßig zur App gehört.
|
|
*/
|
|
static getDefaultBotUser(): BotUser;
|
|
/**
|
|
* Liefert die AppPersistence, mit der sich Zahlen, Strings und Javascript-Objekte langfristig und über die Session einer App hinaus gespeichert werden können.
|
|
*/
|
|
static getPersistence(): AppPersistence;
|
|
/**
|
|
* Liefert den Channel in dem die App läuft.
|
|
*/
|
|
static getChannel(): Channel;
|
|
/**
|
|
* Liefert das UserAccess-Objekt, über das
|
|
* User zugreifbar werden.
|
|
*/
|
|
static getUserAccess(): UserAccess;
|
|
/**
|
|
* Liefert ein ExternalServerAccess-Objekt, mit dem
|
|
* andere Server angesteuert werden können.
|
|
*/
|
|
static getExternalServerAccess(): ExternalServerAccess;
|
|
/**
|
|
* Aktualisiert die Liste der genutzten Hooks. Werden zur Laufzeit chatCommands oder App-Hooks (wie mayJoinChannel) dynamisch erzeugt oder gelöscht, so muss danach <code>refreshHooks()</code>
|
|
* aufgerufen werden, damit diese Änderung wirksam wird.
|
|
*/
|
|
static refreshHooks(): void;
|
|
/**
|
|
* Liefert den Standard-Logger für diese App. Alles, was geloggt wird, wird vom Nutzer "App-Logs" als private Nachricht zugestellt.
|
|
*/
|
|
static getDefaultLogger(): Logger;
|
|
/**
|
|
* Liefert den Pfad eines Bildes zur Integration in der eigenen App.
|
|
* Alle Bilder, die im Ordner /www in der App abgelegt werden können hier referenziert werden.
|
|
*/
|
|
static getFullImagePath(imageName: string): string;
|
|
/**
|
|
* Liefert den Pfad eines <b>Systembildes</b> zur Integration in der eigenen App.
|
|
* Alle Bilder, die unter <a href="http://apps4.knuddels.biz/kimg/" target="_blank">http://apps4.knuddels.biz/kimg/</a>
|
|
* erreichbar sind können hier referenziert werden.
|
|
*/
|
|
static getFullSystemImagePath(imageName: string): string;
|
|
/**
|
|
* Liefert die Informationen über den ChatServer auf dem die App läuft.
|
|
*/
|
|
static getChatServerInfo(): ChatServerInfo;
|
|
/**
|
|
* Liefert die Informationen über den AppServer auf dem die App läuft.
|
|
*/
|
|
static getAppServerInfo(): AppServerInfo;
|
|
/**
|
|
* Liefert das AppAccess-Object.
|
|
*/
|
|
static getAppAccess(): AppAccess;
|
|
/**
|
|
* Erzeugt einen KnuddelPot.
|
|
*
|
|
* Ist ein KnuddelPot 30 Minuten nach dem Erzeugen noch nicht gesealt,
|
|
* so wird vom Server automatisch ein KnuddelPot/refund:method ausgelöst.
|
|
*/
|
|
static createKnuddelPot(knuddelAmount: KnuddelAmount, params?: { payoutTimeoutMinutes?: number; shouldSealPot?: (pot: KnuddelPot) => boolean; onPotSealed?: (pot: KnuddelPot) => void; }): KnuddelPot;
|
|
/**
|
|
* Liefert den KnuddelPot mit der angegeben id.
|
|
*/
|
|
static getKnuddelPot(id: number): (KnuddelPot|null);
|
|
/**
|
|
* Liefert alle für die App noch verwaltbaren KnuddelPot-Objekte.
|
|
*/
|
|
static getAllKnuddelPots(): KnuddelPot[];
|
|
/**
|
|
* Liefert das ToplistAccess-Objekt, über das
|
|
* Toplisten erzeugt und verwaltet werden können.
|
|
*/
|
|
static getToplistAccess(): ToplistAccess;
|
|
/**
|
|
* Liefert das AppProfileEntryAccess-Objekt, über das
|
|
* App-Profileinträge erzeugt und verwaltet werden können.
|
|
*/
|
|
static getAppProfileEntryAccess(): AppProfileEntryAccess;
|
|
}
|
|
|
|
/**
|
|
* Mit einer Instanz einer LoadConfiguration kann gestaltet werden, wie der Inhalt des HTML User Interface aussieht, bevor es fertig geladen ist.
|
|
*/
|
|
declare class LoadConfiguration {
|
|
/**
|
|
* Setzt die Farbe des Hintergrundes vom Loading-View, der angezeigt wird, während das HTML User Interface lädt. (standardmäßig weiß)
|
|
*/
|
|
setBackgroundColor(color: Color): void;
|
|
/**
|
|
* Setzt das Hintergrundbild vom Loading-View, das angezeigt wird, während das HTML User Interface lädt. (standardmäßig nicht gesetzt)
|
|
*/
|
|
setBackgroundImage(imageUrl: string): void;
|
|
/**
|
|
* Setzt den Text des Ladehinweiseses im Loading-View, der angezeigt wird, während das HTML User Interface lädt. (standardmäßig "Lädt...")
|
|
* Hinweis: Wird mit setLoadingIndicatorImage ein Loaading-Indicator-Bild gesetzt, so wird der mit setText gesetzte Texte ignoriert.
|
|
*/
|
|
setText(text: string): void;
|
|
/**
|
|
* Setzt ein Loading-Indicator-Bild im Loading-View, das angezeigt wird, während das HTML User Interface lädt. (standardmäßig nicht gesetzt)
|
|
* Hinweis: Wird mit setLoadingIndicatorImage ein Loaading-Indicator-Bild gesetzt, so wird der mit setText gesetzte Texte ignoriert.
|
|
*/
|
|
setLoadingIndicatorImage(imageUrl: string): void;
|
|
/**
|
|
* Setzt die Farbe des Textes im Loading-View, der angezeigt wird, während das HTML User Interface lädt. (standardmäßig schwarz)
|
|
*/
|
|
setForegroundColor(color: Color): void;
|
|
/**
|
|
* Aktiviert/Deaktiviert die Nutzung vom Loading-View. (standardmäßig aktiviert)
|
|
* Es kann sinnvoll sein, den Loading-View zu deaktivieren, wenn man selbst einen komplett eigenen Loading-View in seine App einbauen möchte.
|
|
*/
|
|
setEnabled(enabled: boolean): void;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz eines Logger ermöglicht das Loggen von Inhalten.
|
|
*
|
|
* Diese erhält man über das KnuddelsServer-Objekt
|
|
* mit KnuddelsServer.getDefaultLogger()
|
|
*
|
|
* Die Log-Einträge werden je nach Einstellungen im /apps-Fenster an den Besitzer des Channels,
|
|
* die App-Manager und den App-Entwickler zugestellt.
|
|
*/
|
|
declare class Logger {
|
|
/**
|
|
* Logge einen Text mit Level DEBUG. Dieser wird im Chat allen dafür registrierten AppManagern per /p vom App-Logs-User zugestellt. Siehe: /apps, Tab: Logs.
|
|
*
|
|
* Die Methode erwartet beliebig viele Strings als Parameter. Diese werden vor dem Logging mit einem Leerzeichen gejoint.
|
|
*/
|
|
debug(...msg: any[]): void;
|
|
/**
|
|
* Logge einen Text mit Level INFO. Dieser wird im Chat allen dafür registrierten AppManagern per /p vom App-Logs-User zugestellt. Siehe: /apps, Tab: Logs.
|
|
*
|
|
* Die Methode erwartet beliebig viele Strings als Parameter. Diese werden vor dem Logging mit einem Leerzeichen gejoint.
|
|
*/
|
|
info(...msg: any[]): void;
|
|
/**
|
|
* Logge einen Text mit Level WARN. Dieser wird im Chat allen dafür registrierten AppManagern per /p vom App-Logs-User zugestellt, sowie im /apps Fenster im Log angezeigt. Siehe: /apps, Tab: Logs.
|
|
*
|
|
* Die Methode erwartet beliebig viele Strings als Parameter. Diese werden vor dem Logging mit einem Leerzeichen gejoint.
|
|
*/
|
|
warn(...msg: any[]): void;
|
|
/**
|
|
* Logge einen Text mit Level ERROR. Dieser wird im Chat allen dafür registrierten AppManagern per /p vom App-Logs-User zugestellt, sowie im /apps Fenster im Log angezeigt. Siehe: /apps, Tab: Logs.
|
|
*
|
|
* Die Methode erwartet beliebig viele Strings als Parameter. Diese werden vor dem Logging mit einem Leerzeichen gejoint.
|
|
*/
|
|
error(...msg: any[]): void;
|
|
/**
|
|
* Logge einen Text mit Level FATAL. Dieser wird im Chat allen dafür registrierten AppManagern per /p vom App-Logs-User zugestellt, sowie im /apps Fenster im Log angezeigt. Siehe: /apps, Tab: Logs.
|
|
*
|
|
* Die Methode erwartet beliebig viele Strings als Parameter. Diese werden vor dem Logging mit einem Leerzeichen gejoint.
|
|
*/
|
|
fatal(...msg: any[]): void;
|
|
}
|
|
|
|
/**
|
|
* Message ist eine abstrakte Klasse und repräsentiert eine Nachricht im Chat.
|
|
*/
|
|
declare class Message {
|
|
/**
|
|
* Liefert den User, der die Nachricht verfasst hat.
|
|
*/
|
|
getAuthor(): User;
|
|
/**
|
|
* Liefert den Inhalt der Nachricht.
|
|
*/
|
|
getText(): string;
|
|
/**
|
|
* Liefert den genauen Zeitpunkt, zu dem die Nachricht erstellt wurde.
|
|
*/
|
|
getCreationDate(): Date;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert die Instanz der konkreten App, auf die dieser Code Zugriff hat.
|
|
*
|
|
* Die Instanz von <code>OwnAppInstance</code> erhält man über das AppAccess-Objekt
|
|
* mit appAccess.getOwnInstance()
|
|
*/
|
|
declare class OwnAppInstance {
|
|
/**
|
|
* Gibt Zugriff auf Nutzer, die gerade im Channel dieser AppInstance online sind.
|
|
* @since AppServer 82560
|
|
*/
|
|
getOnlineUsers(otherAppInstance: AppInstance, ...userType: UserType[]): User[];
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von Persistence ermöglicht die persistente Speicherung von Zahlen, Zeichenketten und JSON-Objekten.
|
|
* Es gibt die zwei Arten AppPersistence und UserPersistence
|
|
*
|
|
* Jeder eigene Datentyp hat seinen eigenen Namensraum.
|
|
* So kann derselbe <code>key</code> für eine Zahl, Zeichenkette und auch JSON-Objekt genutzt werden.
|
|
*
|
|
* <br /><br /><b>Hinweis: </b>Mit der Persistence gespeicherte Informationen überleben
|
|
* sogar die Deinstallation und Neuinstallation der App.
|
|
*/
|
|
declare class Persistence {
|
|
/**
|
|
* Informiert darüber, ob unter dem <code>key</code> ein String abgespeichert ist.
|
|
*/
|
|
hasString(key: string): boolean;
|
|
/**
|
|
* Setzt die Zeichenkette <code>value</code> für den <code>key</code>.
|
|
* Falls bereits eine Zeichenkette für den <code>key</code> existiert, so wird diese überschrieben.
|
|
*/
|
|
setString(key: string, value: string): void;
|
|
/**
|
|
* Liefert die Zeichenkette, die für den <code>key</code> gespeichert ist.
|
|
* Falls für <code>key</code> keine Zeichenkette gespeichert ist, so gibt die Methode
|
|
* den <code>defaultValue</code> zurück.
|
|
*/
|
|
getString(key: string, defaultValue?: string): string;
|
|
/**
|
|
* Löscht die Zeichenkette, die unter <code>key</code> gespeichert ist.
|
|
*/
|
|
deleteString(key: string): void;
|
|
/**
|
|
* Informiert darüber, ob unter dem <code>key</code> eine Zahl abgespeichert ist.
|
|
*/
|
|
hasNumber(key: string): boolean;
|
|
/**
|
|
* Setzt die Zahl <code>value</code> für den <code>key</code>.
|
|
* Falls bereits eine Zahl für den <code>key</code> existiert, so wird diese überschrieben.
|
|
*/
|
|
setNumber(key: string, value: number): void;
|
|
/**
|
|
* Addiert den übergebenen <code>value</code> auf die unter dem Key <code>key</code> vorhandenen Wert drauf.
|
|
* Value kann auch negativ sein um eine Subtraktion durchzuführen.
|
|
* Falls keine Zahl für den <code>key</code> existiert, so wird der <code>value</code> für <code>key</code> gespeichert.
|
|
*/
|
|
addNumber(key: string, value: number): number;
|
|
/**
|
|
* Liefert die Zahl, die für den <code>key</code> gespeichert ist.
|
|
* Falls für <code>key</code> keine Zahl gespeichert ist, so gibt die Methode
|
|
* den <code>defaultValue</code> zurück.
|
|
*/
|
|
getNumber(key: string, defaultValue?: number): number;
|
|
/**
|
|
* Löscht die Zahl, die unter <code>key</code> gespeichert ist.
|
|
*/
|
|
deleteNumber(key: string): void;
|
|
/**
|
|
* Informiert darüber, ob unter dem <code>key</code> ein Objekt abgespeichert ist.
|
|
*/
|
|
hasObject(key: string): boolean;
|
|
/**
|
|
* Setzt das Objekt <code>value</code> für den <code>key</code>.
|
|
* Falls bereits ein Objekt für den <code>key</code> existiert, so wird dieses überschrieben.
|
|
* Das als JSON serialisierte Objekt darf maximal 100kb groß sein.
|
|
*/
|
|
setObject(key: string, object: (KnuddelsJson | KnuddelsJsonArray | KnuddelsSerializable)): void;
|
|
/**
|
|
* Liefert das Objekt, das für den <code>key</code> gespeichert ist.
|
|
* Falls für <code>key</code> kein Objekt gespeichert ist, so gibt die Methode
|
|
* den <code>defaultValue</code> zurück.
|
|
*/
|
|
getObject(key: string, defaultValue?: (KnuddelsJson | KnuddelsJsonArray | KnuddelsSerializable)): (KnuddelsJson | KnuddelsJsonArray | KnuddelsSerializable);
|
|
/**
|
|
* Löscht das Objekt, das unter <code>key</code> gespeichert ist.
|
|
*/
|
|
deleteObject(key: string): void;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von PrivateMessage repräsentiert eine private Nachricht im Chat.
|
|
* Die App erhält sämtliche private Nachrichten, die an einen ihrer BotUser
|
|
* geschickt werden.
|
|
*
|
|
* <br /><br /><b>Hinweis:</b> Eine App hat keinen Zugriff auf private Nachrichten,
|
|
* die Nutzer untereinander schreiben, ohne dass ein BotUser als Empfänger involviert ist.
|
|
*/
|
|
declare class PrivateMessage extends Message {
|
|
/**
|
|
* Liefert die Liste der Empfänger der Nachricht.
|
|
*/
|
|
getReceivingUsers(): User[];
|
|
/**
|
|
* Sendet eine private Nachricht an alle Beteiligten des Gespräches.
|
|
*/
|
|
sendReply(text: string): void;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von PublicActionMessage repräsentiert eine öffentliche Handlung im Chat.
|
|
* Die App erhält die öffentlichen Handlungen.
|
|
*/
|
|
declare class PublicActionMessage extends Message {
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von PublicEventMessage repräsentiert ein öffentliches Event im Chat.
|
|
* Die App erhält die öffentlichen Events.
|
|
*/
|
|
declare class PublicEventMessage extends Message {
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz von PublicMessage repräsentiert eine öffentliche Nachricht im Chat.
|
|
* Die App erhält die öffentlichen Nachrichten, die geschrieben werden.
|
|
*/
|
|
declare class PublicMessage extends Message {
|
|
}
|
|
|
|
/**
|
|
* Eine Quest ist eine konkrete Aufgabe, die ein User in der App zu erledigen hat.
|
|
*
|
|
* Im Blog findest du Informationen darüber, wie man eine Quest für seine App erhält:
|
|
* https://blog.developer.knuddels.de/2015/10/29/how-to-get-a-quest/
|
|
*/
|
|
declare class Quest {
|
|
/**
|
|
* Löst ein Quest-Event aus.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
setSolved(count?: number): void;
|
|
/**
|
|
* Liefert den Key der Quest.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
getQuestKey(): string;
|
|
}
|
|
|
|
/**
|
|
* Ein QuestAccess-Objekt ermöglicht den Zugriff auf die Quests, die ein Nutzer des Chats, für die laufende App hat.
|
|
*
|
|
* Im Blog findest du Informationen darüber, wie man eine Quest für seine App erhält:
|
|
* https://blog.knuddels.de/2015/10/29/how-to-get-a-quest/
|
|
*/
|
|
declare class QuestAccess {
|
|
/**
|
|
* Liefert die Quests
|
|
* für diesen Nutzer in dieser App.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
getQuests(): Quest[];
|
|
/**
|
|
* Liefert die Information, ob eine bestimmte Quest offen ist.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
hasQuest(questKey: string): boolean;
|
|
/**
|
|
* Liefert eine bestimmte Quest, falls vorhanden.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
getQuest(questKey: string): (Quest|null);
|
|
/**
|
|
* Liefert den User, der zu diesem QuestAccess-Objekt gehört.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
getUser(): User;
|
|
}
|
|
|
|
/**
|
|
* RandomOperations bietet eine Sammlung verschiedener Zufallsoperationen, die man für Glücksspiele und Ähnliches nutzen kann.
|
|
*/
|
|
declare class RandomOperations {
|
|
/**
|
|
* Liefert eine Zufallszahl zwischen <code>minValue</code> (inklusiv) und <code>maxValue</code> (exklusiv).
|
|
*/
|
|
static nextInt(minValue: number /* optional */, maxValue: number): number;
|
|
/**
|
|
* Liefert ein Array mit Zufallszahlen zwischen minValue (inklusiv) und <code>n</code> (exklusiv).
|
|
*/
|
|
static nextInts(minValue: number /* optional */, maxValue: number, count: number, onlyDifferentNumbers: boolean): number[];
|
|
/**
|
|
* Liefert <code>true</code> in <code>truePropability</code>/1 Fällen
|
|
*/
|
|
static flipTrue(truePropability: number): boolean;
|
|
/**
|
|
* Liefert ein zufälliges Objekt aus einem Array.
|
|
* Falls das Array leer ist, wird <code>null</code> zurückgeliefert.
|
|
*/
|
|
static getRandomObject<T>(objects: T[]): T;
|
|
/**
|
|
* Mischt das Array der übergebenen Objekte und liefert es zurück.
|
|
*/
|
|
static shuffleObjects<T>(objects: T[]): T[];
|
|
/**
|
|
* Liefert einen zufälligen String zurück.
|
|
* @since AppServer 92699
|
|
*/
|
|
static getRandomString(length: number, allowedCharacters?: string): string;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert die Root-Instanz einer App, die im Hauptchannel läuft.
|
|
*
|
|
* Die Instanz für die <code>RootAppInstance</code> erhält man über das AppInstance-Objekt
|
|
* mit appInstance.getRootInstance()
|
|
*/
|
|
declare class RootAppInstance extends AppInstance {
|
|
/**
|
|
* Aktualisiert diese App im Channel (und ggf. vorhandenen Tochterchanneln) auf die neueste Version.
|
|
*/
|
|
updateApp(message: string /* optional */, logMessage?: string): void;
|
|
/**
|
|
* Stoppt diese App.
|
|
*/
|
|
stopApp(message: string /* optional */, logMessage?: string): void;
|
|
}
|
|
|
|
/**
|
|
* Liefert Informationen über einen Server.
|
|
*/
|
|
declare class ServerInfo {
|
|
/**
|
|
* Liefert die interne ServerId des Servers.
|
|
*/
|
|
getServerId(): string;
|
|
/**
|
|
* Liefert die Code-Revision des Servers.
|
|
*/
|
|
getRevision(): number;
|
|
}
|
|
|
|
/**
|
|
* Ein SingleDiceResult enthält das Ergebnis aller Würfel desselben Typs.
|
|
* Würfelt man beispielsweise mit der Konfiguration "1w2 + 10w5" so gibt es im <code>DiceResult</code>
|
|
* zwei SingleDiceResult-Objekte. Eines für "1w2" und eines für "10w5".
|
|
*/
|
|
declare class SingleDiceResult {
|
|
/**
|
|
* Liefert den Würfel zurück, durch den dieses SingleDiceResult erzeugt wurde.
|
|
*/
|
|
getDice(): Dice;
|
|
/**
|
|
* Liefert die Ziffern, die gewürfelt wurden.
|
|
*/
|
|
valuesRolled(): number[];
|
|
/**
|
|
* Liefert die Summe der Augenzahlen des SingleDiceResult.
|
|
*/
|
|
sum(): number;
|
|
}
|
|
|
|
/**
|
|
* Diese Dokumentation beschreibt, welche Erweiterungen am <b>serverseitigen String-Objekt</b> vorgenommen wurden.
|
|
*/
|
|
declare interface String {
|
|
/**
|
|
* Die Methode liefert den <code>String</code> zurück, auf dem sie aufgerufen wurde mit KCode escaped.
|
|
*/
|
|
escapeKCode(): string;
|
|
/**
|
|
* Entfernt jeglichen KCode aus dem <code>String</code> und gibt ihn zurück.
|
|
*/
|
|
stripKCode(): string;
|
|
/**
|
|
* Diese Methode liefert die Information, ob der <code>String</code> auf dem die Methode aufgerufen wurde
|
|
* mit einem bestimmten Prefix beginnt.
|
|
*/
|
|
startsWith(prefix: string): boolean;
|
|
/**
|
|
* Diese Methode liefert die Information, ob der <code>String</code> auf dem die Methode aufgerufen wurde
|
|
* mit einem bestimmten Suffix endet.
|
|
*/
|
|
endsWith(suffix: string): boolean;
|
|
/**
|
|
* Liefert die Breite des Strings in der Schriftart Arial mit der gegeben Schriftgröße und Information, ob Text fett dargestellt werden soll.
|
|
*/
|
|
getPixelWidth(fontSize: number, isBold: boolean): number;
|
|
/**
|
|
* Liefert einen <code>String</code>, der in der Schriftart Arial mit der gegeben Schriftgröße und Information, ob Text fett dargestellt werden soll
|
|
* maximal <code>maxPixelWidth</code> breit ist. Wird der Text dafür gekürzt, so wird an das Ende <code>abbreviationMarker</code> angehangen.
|
|
* Falls <code>abbreviationMarker</code> nicht übergeben wurde, so ist es automatisch '...'.
|
|
*/
|
|
limitString(fontSize: number, isBold: boolean, maxPixelWidth: number, abbreviationMarker?: string): string;
|
|
/**
|
|
* Liefert die Information, ob ein bestimmter <code>String</code> in diesem <code>String</code> vorhanden ist.
|
|
*/
|
|
contains(needle: string): boolean;
|
|
/**
|
|
* Liefert die Levenshtein-Distanz zum übergebenen <code>String</code>.
|
|
* Levenshtein-Distanz: Minimale Anzahl von Einfüge-, Lösch- und Ersetz-Operationen, um die erste Zeichenkette in die zweite umzuwandeln.
|
|
* @since AppServer 82271
|
|
*/
|
|
minimalConversionCost(otherString: string): number;
|
|
/**
|
|
* Liefert die Information, ob der <code>String</code> nur aus Zeichen besteht, die in einem Nicknamen
|
|
* vorkommen dürfen.
|
|
* @since AppServer 82271
|
|
*/
|
|
hasOnlyNicknameCharacters(): boolean;
|
|
/**
|
|
* Liefert die Information, ob der <code>String</code> nur aus Zeichen besteht, die Nummern sind.
|
|
* @since AppServer 82271
|
|
*/
|
|
hasOnlyDigits(): boolean;
|
|
/**
|
|
* Liefert die Information, ob der <code>String</code> nur aus Zeichen besteht, die alphanumerisch + Whitespaces sind.
|
|
* @since AppServer 82271
|
|
*/
|
|
hasOnlyAlphanumericalAndWhitespaceCharacters(): boolean;
|
|
/**
|
|
* Liefert die Information, ob der <code>String</code> leer oder <code>null</code> ist.
|
|
* @since AppServer 92695
|
|
*/
|
|
isEmpty(): boolean;
|
|
/**
|
|
* Liefert den <code>String</code> in CamelCase.
|
|
* @since AppServer 92695
|
|
*/
|
|
toCamelCase(): string;
|
|
/**
|
|
* Liefert den <code>String</code> mit dem ersten Buchstaben als Großbuchstaben.
|
|
* @since AppServer 92695
|
|
*/
|
|
capitalize(): string;
|
|
/**
|
|
* Erstellt eine Kopie des <code>String</code>, in dem alle Vorkommnisse des <code>String</code> <code>search</code> in <code>replacement</code>
|
|
* ersetzt werden und liefert diesen zurück.
|
|
*/
|
|
replaceAll(search: string | RegExp, replacement: string): string;
|
|
/**
|
|
* Prüft primitiv, ob der <code>String</code> laut Knuddels-Filterregeln ok ist.
|
|
* @since ChatServer 82262, AppServer 82262
|
|
*/
|
|
isOk(): boolean;
|
|
}
|
|
|
|
/**
|
|
* Eine Instanz einer Toplist repräsentiert eine eigene Topliste für einen bestimmten userPersistenceNumberKey.
|
|
*/
|
|
declare class Toplist {
|
|
/**
|
|
* Liefert den userPersistenceNumberKey mit dem die Topliste erzeugt wurde.
|
|
*/
|
|
getUserPersistenceNumberKey(): string;
|
|
/**
|
|
* Liefert den Anzeigenamen der Topliste.
|
|
*/
|
|
getDisplayName(): string;
|
|
/**
|
|
* Liefert den Befehl, der im Chat eingegeben werden kann, um diese Topliste zu öffnen.
|
|
* Wird ein User oder eine userId übergeben, so öffnet sich die Topliste mit diesem Nutzer im Fokus.
|
|
*/
|
|
getChatCommand(user_or_userId?: (User|number)): string;
|
|
/**
|
|
* Liefert den Anzeigenamen für den übergebenen User oder eine userId.
|
|
*/
|
|
getLabel(user_or_userId: (User|number)): string;
|
|
/**
|
|
* Legt einen Change-Listener an, der jedes mal aufgerufen wird, wenn ein User
|
|
* einen neuen Anzeigenamen erhält.
|
|
*/
|
|
addLabelChangeListener(listener: (labelChangeEvent: ToplistLabelChangeEvent) => void): void;
|
|
/**
|
|
* Löscht einen LabelChangeListener, der mit Toplist/addLabelChangeListener:method erzeugt wurde.
|
|
*/
|
|
removeLabelChangeListener(listener: (labelChangeEvent: ToplistLabelChangeEvent) => void): void;
|
|
/**
|
|
* Legt einen Change-Listener an, der jedes mal aufgerufen wird, wenn ein sich der Rang User eines Nutzers ändert.
|
|
*/
|
|
addRankChangeListener(listener: (rankChangeEvent: ToplistRankChangeEvent) => void): void;
|
|
/**
|
|
* Löscht einen RankChangeListener, der mit Toplist/addRankChangeListener:method erzeugt wurde.
|
|
*/
|
|
removeRankChangeListener(listener: (rankChangeEvent: ToplistRankChangeEvent) => void): void;
|
|
}
|
|
|
|
/**
|
|
* Mit einer Instanz von ToplistAccess kann eine App
|
|
* Toplist erzeugen und verwalten.
|
|
*
|
|
* Die Instanz für die <code>ToplistAccess</code> erhält man über das KnuddelsServer-Objekt
|
|
* mit KnuddelsServer.getToplistAccess()
|
|
*/
|
|
declare class ToplistAccess {
|
|
/**
|
|
* Liefert die Liste aller Toplisten, die diese App erzeugt hat.
|
|
*/
|
|
getAllToplists(): Toplist[];
|
|
/**
|
|
* Liefert die Toplist mit dem Persistenz-Key zurück.
|
|
*/
|
|
getToplist(userPersistenceNumberKey: string): Toplist;
|
|
/**
|
|
* Löscht die übergebene Toplist oder die Toplist mit dem Persistenz-Key.
|
|
*/
|
|
removeToplist(toplist: Toplist): void;
|
|
/**
|
|
* Erzeugt oder aktualisiert die Toplist für den übergebenen userPersistenceNumberKey.
|
|
*/
|
|
createOrUpdateToplist(userPersistenceNumberKey: string, displayName: string, parameters?: { labelMapping?: { [minValue: string]: string }; ascending?: boolean; }): Toplist;
|
|
}
|
|
|
|
/**
|
|
* ToplistDisplayType repräsentiert den Anzeigetyp eines Toplisteneintrags im Profil vonUsern.
|
|
*/
|
|
declare class ToplistDisplayType {
|
|
/**
|
|
* Nur Anzeigename anzeigen.
|
|
*/
|
|
static readonly Label: ToplistDisplayType;
|
|
/**
|
|
* Gespeicherten Wert anzeigen.
|
|
*/
|
|
static readonly Value: ToplistDisplayType;
|
|
/**
|
|
* Anzeigename und Rang anzeigen.
|
|
*/
|
|
static readonly LabelAndRank: ToplistDisplayType;
|
|
/**
|
|
* Wert und Rang anzeigen.
|
|
*/
|
|
static readonly ValueAndRank: ToplistDisplayType;
|
|
}
|
|
|
|
/**
|
|
* ToplistLabelChangeEvents erhalten EventListener die bei einer
|
|
* Toplist mit der Methode Toplist/addLabelChangeListener:method
|
|
* erzeugt wurden, nachdem sich der Anzeigename für einen User geändert hat.
|
|
*
|
|
* Das ToplistLabelChangeEvent enthält alle wichtigen Daten, um auf die Änderung zu reagieren
|
|
* und dem User beispielsweise für den Aufstieg zu gratulieren.
|
|
*/
|
|
declare class ToplistLabelChangeEvent {
|
|
/**
|
|
* Liefert die zugehörige Toplist.
|
|
*/
|
|
getToplist(): Toplist;
|
|
/**
|
|
* Liefert den vorherigen Anzeigenamen. Hatte der User vorher keinen
|
|
* Anzeigenamen, so ist dieser Wert <code>null</code>.
|
|
*/
|
|
getOldLabel(): string;
|
|
/**
|
|
* Liefert den neuen Anzeigenamen. Hatte der User nun keinen
|
|
* Anzeigenamen mehr, so ist dieser Wert <code>null</code>.
|
|
*/
|
|
getNewLabel(): string;
|
|
/**
|
|
* Liefert den User für den das Event ausgelöst wurde.
|
|
*/
|
|
getUser(): User;
|
|
/**
|
|
* Liefert den Wert, der vor der Änderung gespeichert war.
|
|
*/
|
|
getOldValue(): number;
|
|
/**
|
|
* Liefert den neuen Wert.
|
|
*/
|
|
getNewValue(): number;
|
|
}
|
|
|
|
/**
|
|
* ToplistRankChangeEvents erhalten EventListener die bei einer
|
|
* Toplist mit der Methode Toplist/addRankChangeListener:method
|
|
* erzeugt wurden, nachdem sich der Rang für einen User geändert hat.
|
|
*
|
|
* Das ToplistRankChangeEvent enthält alle wichtigen Daten, um auf die Änderung zu reagieren
|
|
* und den überholten Usern eine Nachricht zu senden.
|
|
*/
|
|
declare class ToplistRankChangeEvent {
|
|
/**
|
|
* Liefert die zugehörige Toplist.
|
|
*/
|
|
getToplist(): Toplist;
|
|
/**
|
|
* Liefert den Toplisten-Rang, den der User vor der Änderung hatte.
|
|
*/
|
|
getOldRank(): number;
|
|
/**
|
|
* Liefert den neuen Toplisten-Rang, des Users.
|
|
*/
|
|
getNewRank(): number;
|
|
/**
|
|
* Liefert den User für den das Event ausgelöst wurde.
|
|
*/
|
|
getUser(): User;
|
|
/**
|
|
* Liefert die User, die bei dieser Änderung überholt worden sind.
|
|
* <br><br><b style="color:red;">Achtung:</b> Wenn mehr als <b>10 User</b>
|
|
* überholt wurden, so liefert die Methode die besten 10 überholten User.
|
|
*/
|
|
getUsersOvertook(): User[];
|
|
/**
|
|
* Liefert den Wert, der vor der Änderung gespeichert war.
|
|
*/
|
|
getOldValue(): number;
|
|
/**
|
|
* Liefert den neuen Wert.
|
|
*/
|
|
getNewValue(): number;
|
|
}
|
|
|
|
/**
|
|
* Ein User ist ein Nutzer des Chats, in dem die App läuft.
|
|
*/
|
|
declare class User {
|
|
/**
|
|
* Liefert die eindeutige Nutzerkennung des Nutzers.
|
|
*/
|
|
getUserId(): number;
|
|
/**
|
|
* Liefert den Nicknamen des Nutzers.
|
|
*/
|
|
getNick(): string;
|
|
/**
|
|
* Liefert das Alter des Nutzers. Bei Nutzern, die bereits sehr lange in der Plattform sind kann es vorkommen, dass kein Alter angegeben wurde. In diesem Fall ist das Alter <code>0</code>.
|
|
*/
|
|
getAge(): number;
|
|
/**
|
|
* Liefert das Geschlecht des Nutzers.
|
|
*/
|
|
getGender(): Gender;
|
|
/**
|
|
* Liefert den Zeitpunkt der Registrierung des Nutzers.
|
|
*/
|
|
getRegDate(): Date;
|
|
/**
|
|
* Liefert den UserStatus des Nutzers.
|
|
*/
|
|
getUserStatus(): UserStatus;
|
|
/**
|
|
* Liefert den UserType des Nutzers.
|
|
*/
|
|
getUserType(): UserType;
|
|
/**
|
|
* Liefert den aktuellen ClientType des Nutzers oder Offline wenn er nicht im Chat online ist.
|
|
*/
|
|
getClientType(): ClientType;
|
|
/**
|
|
* Prüft ob der Client des Users den übergebenen AppViewMode (für User/sendAppContent:method) anzeigen kann.
|
|
*/
|
|
canShowAppViewMode(mode: AppViewMode): boolean;
|
|
/**
|
|
* Prüft ob der Client des User's den übergebenen AppContent anzeigen kann.
|
|
*/
|
|
canSendAppContent(appContent: AppContent): boolean;
|
|
/**
|
|
* Prüft, ob der User in dem angegebenen Team ist.
|
|
* Dies funktioniert derzeit nur für Teams, die eine eigene /fa haben.
|
|
*
|
|
* <b style="color:red;">Achtung:</b> Bei Nutzern, die neu in ein Team kommen, funktioniert die Abfrage erst dann korrekt,
|
|
* wenn er sich neu in den Channel eingeloggt hat.
|
|
*/
|
|
isInTeam(teamName: string, subTeamName?: string): boolean;
|
|
/**
|
|
* Liefert ein UserPersistence-Objekt für diesen Nutzer. Mit diesem Objekt kann eine App sich Dinge über diesen speziellen Nutzer merken.
|
|
*/
|
|
getPersistence(): UserPersistence;
|
|
/**
|
|
* Shortcut-Funktion um mit dem DefaultBotUser eine private Nachricht zu versenden.
|
|
*/
|
|
sendPrivateMessage(message: string): void;
|
|
/**
|
|
* Shortcut-Funktion um mit dem DefaultBotUser eine /m zu versenden.
|
|
*/
|
|
sendPostMessage(topic: string, text: string): void;
|
|
/**
|
|
* Liefert die Information, ob dieser Nutzer Channelbesitzer im Channel der App ist.
|
|
*/
|
|
isChannelOwner(): boolean;
|
|
/**
|
|
* Liefert die Information, ob der Channel der App
|
|
* ein Lieblingschannel des Nutzers ist.
|
|
*/
|
|
isLikingChannel(): boolean;
|
|
/**
|
|
* Liefert die Information, ob der Nutzer im harten Kern des Channels der App ist.
|
|
* @since AppServer 92701, ChatServer 92701
|
|
*/
|
|
isChannelCoreUser(): boolean;
|
|
/**
|
|
* Liefert die Information, ob dieser Nutzer ein AppManager für diese App ist. Die Channelbesitzer zählen automatisch auch als AppManager.
|
|
*/
|
|
isAppManager(): boolean;
|
|
/**
|
|
* Liefert Information, ob dieser Nutzer derzeit für das Schreiben öffentlicher Nachrichten im Channel gesperrt ist.
|
|
*/
|
|
isMuted(): boolean;
|
|
/**
|
|
* Liefert Information, ob dieser Nutzer beim Schreiben öffentlicher Nachrichten im Channel
|
|
* derzeit für die Verwendung von Textformatierungen, Farben und Smileys gesperrt ist.
|
|
*/
|
|
isColorMuted(): boolean;
|
|
/**
|
|
* Liefert Information, ob dieser Nutzer derzeit für das Betreten des Channel gesperrt ist.
|
|
*/
|
|
isLocked(): boolean;
|
|
/**
|
|
* Liefert Information, ob dieser Nutzer Channelmoderator im Channel der App ist.
|
|
*/
|
|
isChannelModerator(): boolean;
|
|
/**
|
|
* Liefert Information, ob dieser Nutzer Eventmoderator im Channel der App ist.
|
|
*/
|
|
isEventModerator(): boolean;
|
|
/**
|
|
* Liefert Information, ob dieser Nutzers der Entwickler der App ist.
|
|
*/
|
|
isAppDeveloper(): boolean;
|
|
/**
|
|
* Liefert einen Link zum Profil des Nutzers, den man im Chat anzeigen kann.
|
|
*/
|
|
getProfileLink(displayText?: string): string;
|
|
/**
|
|
* Liefert die Information, ob der Nutzer online im Channel der App ist.
|
|
*/
|
|
isOnlineInChannel(): boolean;
|
|
/**
|
|
* Liefert die Anzahl der Knuddel, die der Nutzer besitzt.
|
|
*/
|
|
getKnuddelAmount(): KnuddelAmount;
|
|
/**
|
|
* Liefert die Information, ob der Nutzer irgendwo im Chat online ist.
|
|
*/
|
|
isOnline(): boolean;
|
|
/**
|
|
* Liefert die Readme des Nutzers, die er mit /readme TEXT in sein Profil gesetzt hat.
|
|
*/
|
|
getReadme(): string;
|
|
/**
|
|
* Liefert die vom Nutzer verbrachte Zeit im gesamten Chatsystem In Minuten.
|
|
* <b>Hinweis:</b> Die Minutenzahl wird derzeit immer nur zu dem Zeitpunkt aktualisiert,
|
|
* wenn der Nutzer offline geht.
|
|
*/
|
|
getOnlineMinutes(): number;
|
|
/**
|
|
* Liefert die Information, ob der Nutzer sich mittels /away-Funktion kurz abgemeldet hat.
|
|
*/
|
|
isAway(): boolean;
|
|
/**
|
|
* Liefert die Information, ob der Nutzer ein Profilfoto hat.
|
|
*/
|
|
hasProfilePhoto(): boolean;
|
|
/**
|
|
* (Er)setzt den übergebenen AppContent beim Nutzer.
|
|
*/
|
|
sendAppContent(appContent: AppContent): AppContentSession;
|
|
/**
|
|
* Liefert alle AppContentSession, die der User
|
|
* aktuell geöffnet hat.
|
|
*/
|
|
getAppContentSessions(): AppContentSession[];
|
|
/**
|
|
* Liefert die AppContentSession, die der User
|
|
* mit einem bestimmten AppViewMode aktuell geöffnet hat.
|
|
*/
|
|
getAppContentSession(appViewMode: AppViewMode): AppContentSession;
|
|
/**
|
|
* Vergleicht den übergebenen Nutzer und liefert <code>true</code>, falls der übergebene Nutzer
|
|
* identisch ist mit dem aktuellen Nutzer.
|
|
*/
|
|
equals(user: User): boolean;
|
|
/**
|
|
* Liefert die URL zum Profilfoto des Nutzers. Die übergebene Breite und Höhe
|
|
* liefern dem Server einen Anhaltswert, um das bestmögliche Foto zu finden,
|
|
* sind aber keine Garantie, dass das Foto diese Ausmaße haben wird.
|
|
*/
|
|
getProfilePhoto(width: number, height: number): string;
|
|
/**
|
|
* Liefert das QuestAccess-Objekt
|
|
* für diesen Nutzer in dieser App.
|
|
* @since AppServer 82290, ChatServer 82290
|
|
*/
|
|
getQuestAccess(): QuestAccess;
|
|
/**
|
|
* Liefert die Information, ob der Nutzer gerade sein Video streamt.
|
|
*/
|
|
isStreamingVideo(): boolean;
|
|
/**
|
|
* Liefert den KnuddelAccount des Nutzers.
|
|
*/
|
|
getKnuddelAccount(): KnuddelAccount;
|
|
/**
|
|
* Liefert die ChannelTalkPermission für diesen Nutzer in diesem
|
|
* Channel.
|
|
*/
|
|
getChannelTalkPermission(): ChannelTalkPermission;
|
|
/**
|
|
* Liefert die Information, ob der User ein verifiziertes Profilbild hat.
|
|
*/
|
|
isProfilePhotoVerified(): boolean;
|
|
/**
|
|
* Liefert die Information, ob das Alter des Users verifiziert ist.
|
|
*/
|
|
isAgeVerified(): boolean;
|
|
/**
|
|
* Setzt dem Nutzer ein Icon in die Nickliste, das auf der rechten Seite seines Nicks angezeigt wird.
|
|
* Der Eintrag wird automatisch entfernt, sobald der Nutzer den Channel verlässt,
|
|
* kann aber auch mit User/removeNicklistIcon:method
|
|
* entfernt werden.
|
|
*/
|
|
addNicklistIcon(imagePath: string, imageWidth: number): void;
|
|
/**
|
|
* Entfernt dem Nutzer ein über die API gesetztes Icon in die Nickliste.
|
|
*/
|
|
removeNicklistIcon(imagePath: string): void;
|
|
/**
|
|
* Startet einen Würfelwurf für den Nutzer, falls er online im Channel ist und er nicht gemuted ist.
|
|
* @since AppServer 89159, ChatServer 89159
|
|
*/
|
|
triggerDice(diceConfiguration: DiceConfiguration): void;
|
|
}
|
|
|
|
/**
|
|
* Mit einer Instanz von UserAccess kann eine App
|
|
* auf User zugreifen, die bereits einmal im Channel waren,
|
|
* als die App lief. Für alle nicht zugreifbaren User kann man via UserAccess den korrekt geschriebenen Nicknamen erhalten.
|
|
*
|
|
* Die Instanz für die <code>UserAccess</code> erhält man über das KnuddelsServer-Objekt
|
|
* mit KnuddelsServer.getUserAccess()
|
|
*/
|
|
declare class UserAccess {
|
|
/**
|
|
* Liefert die userId des Nutzers mit dem übergebenen Nicknamen.
|
|
*/
|
|
getUserId(nick: string): number;
|
|
/**
|
|
* Informiert darüber, ob ein Nutzer mit dem übergebenen Nicknamen existiert.
|
|
*/
|
|
exists(nick: string): boolean;
|
|
/**
|
|
* Informiert darüber, ob der Nutzer mit der übergebenen userId geladen werden darf. Neben dem AppDeveloper können nur Nutzer geladen werden, die sich einmal im Channel befanden, als die App
|
|
* lief.
|
|
*/
|
|
mayAccess(userId: number): boolean;
|
|
/**
|
|
* Liefert den Nutzer mit der übergebenen userId. Neben dem AppDeveloper können nur Nutzer geladen werden, die sich einmal im Channel befanden, als die App lief. Es wird empfohlen vor der
|
|
* Abfrage von <code>getUserById(userId)</code> mit UserAccess/mayAccess:method abzufragen, ob dies funktionieren wird.
|
|
*/
|
|
getUserById(userId: number): User;
|
|
/**
|
|
* Liefert den Nicknamen des Nutzers mit der übergebenen userId in der korrekten Schreibweise.
|
|
*/
|
|
getNick(userId: number): string;
|
|
/**
|
|
* Loopt über alle zugreifbaren User sortiert nach Registrierzeitpunkt und
|
|
* führt für jeden User das übergebene Callback aus.
|
|
*/
|
|
eachAccessibleUser(callback: (user: User, index: number, accessibleUserCount: number, key?: string) => boolean,
|
|
parameters?: { onStart?: (accessibleUserCount: number, key?: string) => void;
|
|
onEnd?: (accessibleUserCount: number, key?: string) => void; }): void;
|
|
}
|
|
|
|
/**
|
|
* Für jeden User kann eine UserPersistence angefordert werden, um sich
|
|
* für einen bestimmten Nutzer Dinge persistent zu merken.
|
|
*/
|
|
declare class UserPersistence extends Persistence {
|
|
/**
|
|
* Löscht alle Zahlenwerte, die in dieser UserPersistence gespeichert sind.
|
|
* @since AppServer 88569
|
|
*/
|
|
deleteAllNumbers(): number;
|
|
/**
|
|
* Löscht alle Objekte, die in dieser UserPersistence gespeichert sind.
|
|
* @since AppServer 88569
|
|
*/
|
|
deleteAllObjects(): number;
|
|
/**
|
|
* Löscht alle Zeichenketten, die in dieser UserPersistence gespeichert sind.
|
|
* @since AppServer 88569
|
|
*/
|
|
deleteAllStrings(): number;
|
|
/**
|
|
* Löscht alle Daten, die in dieser UserPersistence gespeichert sind.
|
|
* @since AppServer 88569
|
|
*/
|
|
deleteAll(): number;
|
|
}
|
|
|
|
/**
|
|
* Diese Klasse repräsentiert einen Eintrag der Persistenz.
|
|
*/
|
|
declare class UserPersistenceNumberEntry {
|
|
/**
|
|
* Liefert den Nutzer.
|
|
*/
|
|
getUser(): User;
|
|
/**
|
|
* Liefert den Wert.
|
|
*/
|
|
getValue(): number;
|
|
/**
|
|
* Liefert den Rang des Elements in der Persistenz.
|
|
*/
|
|
getRank(): number;
|
|
/**
|
|
* Liefert die Position des Elements in der Persistenz.
|
|
*/
|
|
getPosition(): number;
|
|
}
|
|
|
|
/**
|
|
* Mit dieser Klasse ist es möglich nicht User-spezifische Abfragen auf die <code>UserPersistence</code> auszuführen.
|
|
*/
|
|
declare class UserPersistenceNumbers {
|
|
/**
|
|
* Liefert die Summe aller via <code>UserPersistence</code> gespeicherten Zahlen für den übergebenen <code>key</code>.
|
|
*/
|
|
static getSum(key: string): number;
|
|
/**
|
|
* Löscht alle gespeicherten Zahlen-Werte für den übergebenen <code>key</code>.
|
|
*/
|
|
static deleteAll(key: string): number;
|
|
/**
|
|
* Liefert die Anzahl aller unterschiedlichen Nutzer, die Werte für einen bestimmten <code>key</code> gespeichert haben.
|
|
* Hierbei kann optional der Wertebereich über die <code>parameters</code> eingegrenzt werden.
|
|
*/
|
|
static getCount(key: string, parameters?: { minimumValue?: number; maximumValue?: number; }): number;
|
|
/**
|
|
* Ändert einen bestimmten <code>key</code> bei allen UserPersistence.
|
|
*/
|
|
static updateKey(oldKeyName: string, newKeyName: string): number;
|
|
/**
|
|
* Ändert alle Werte für einen bestimmten <code>key</code>, die vorher einen bestimmten anderen Wert hatten in der UserPersistence.
|
|
* <br /><strong>Hinweis:</strong> Da diese Methode ein Batch-Update ist werden keine Change-Listener (ToplistRankChangeEvent, ToplistLabelChangeEvent) ausgelöst.
|
|
*/
|
|
static updateValue(key: string, oldValue: number, newValue: number): number;
|
|
/**
|
|
* Addiert einen Wert für Einträge mit einem bestimmten <code>key</code> in der UserPersistence.
|
|
* <br /><strong>Hinweis:</strong> Da diese Methode ein Batch-Update ist werden keine Change-Listener (ToplistRankChangeEvent, ToplistLabelChangeEvent) ausgelöst.
|
|
*/
|
|
static addNumber(key: string, value: number, parameters?: { minimumValue?: number; maximumValue?: number; targetUsers?: User[]; }): number;
|
|
/**
|
|
* Liefert ein Array mit <code>UserPersistenceNumberEntry</code>-Objekten für einen bestimmten <code>key</code>.
|
|
* Hierdurch kann beispielsweise eine blätterbare Topliste abgebildet werden.
|
|
*/
|
|
static getSortedEntries(key: string, parameters?: { ascending?: boolean; count?: number; page?: number; minimumValue?: number; maximumValue?: number; }): UserPersistenceNumberEntry[];
|
|
/**
|
|
* Liefert ein Array mit <code>UserPersistenceNumberEntry</code>-Objekten für einen bestimmten <code>key</code>. Hierbei werden die nähesten Elemente gewählt,
|
|
* die am übergebenen User/UserId liegen.
|
|
*
|
|
* Beispiel: Der Nutzer ist in der Liste auf Position 20, dann werden die Resultate von 14-24 bei einem Count von 10 ausgegeben.
|
|
* Beispiel: Der Nutzer ist in der Liste auf Position 3, dann werden die Resultate von 1-10 bei einem Count von 10 ausgegeben.
|
|
*/
|
|
static getSortedEntriesAdjacent(key: string, user_or_userId: (User|number), parameters?: { ascending?: boolean; count?: number; }): UserPersistenceNumberEntry[];
|
|
/**
|
|
* Liefert die absolute Position des Nutzers in der Liste. Die Position ist im Gegensatz zum Rang immer eindeutig.
|
|
*
|
|
* Bei gleichem Wert hat der Nutzer die höhere Position, der zuerst einen Eintrag in der Persistenz hatte.
|
|
*
|
|
* Mit der Methode UserPersistenceNumbers/getRank:method kann man den Rang des Nutzers herausfinden. Dieser ist identisch, wenn
|
|
* unterschiedliche Nutzer denselben Wert haben.
|
|
*/
|
|
static getPosition(key: string, user_or_userId: (User|number), parameters?: { ascending?: boolean; minimumValue?: number; }): number;
|
|
/**
|
|
* Liefert den Rang des Nutzers. Der Rang ist nicht eindeutig. Bei gleicher Punktzahl haben Nutzer denselben Rang.
|
|
* Mit der Methode UserPersistenceNumbers/getPosition:method kann man die Position eindeutige Position, statt des Ranges herausfinden.
|
|
*/
|
|
static getRank(key: string, user_or_userId: (User|number), parameters?: { ascending?: boolean; minimumValue?: number; }): number;
|
|
/**
|
|
* Ruft eine Funktion für alle Nutzer auf, die einen bestimmten <code>key</code> in der <code>UserPersistence</code> gesetzt haben.
|
|
* Hierbei greifen die übergebenen Filter.
|
|
*/
|
|
static each(key: string, callback: { user: User; value: number; index: number; totalCount: number; key: string; },
|
|
parameters?: { ascending?: boolean; minimumValue?: number; maximumValue?: number; maximumCount?: number;
|
|
onStart?: (totalCount: number, key: string) => void; onEnd?: (totalCount: number, key: string) => void; }): void;
|
|
/**
|
|
* Liefert alle keys, die für User in der Persistence
|
|
* gespeichert wurden.
|
|
* @since AppServer 82483
|
|
*/
|
|
static getAllKeys(filterKey?: string): string[];
|
|
}
|
|
|
|
/**
|
|
* Mit dieser Klasse ist es möglich nicht User-spezifische Abfragen auf die <code>UserPersistence</code> auszuführen.
|
|
*/
|
|
declare class UserPersistenceObjects {
|
|
/**
|
|
* Löscht alle gespeicherten Objekte für den übergebenen <code>key</code>.
|
|
* @since AppServer 82478
|
|
*/
|
|
static deleteAll(key: string): number;
|
|
/**
|
|
* Liefert alle keys, die für User in der Persistence
|
|
* gespeichert wurden.
|
|
* @since AppServer 82483
|
|
*/
|
|
static getAllKeys(filterKey?: string): string[];
|
|
}
|
|
|
|
/**
|
|
* Mit dieser Klasse ist es möglich nicht User-spezifische Abfragen auf die <code>UserPersistence</code> auszuführen.
|
|
*/
|
|
declare class UserPersistenceStrings {
|
|
/**
|
|
* Liefert die Information, ob für einen bestimmten key und value bei einem beliebigen Nutzer eine Paarung existiert.
|
|
* @since AppServer 88571
|
|
*/
|
|
static exists(key: string, value: string, ignoreCase?: boolean): boolean;
|
|
/**
|
|
* Löscht alle gespeicherten Strings für den übergebenen <code>key</code>.
|
|
* @since AppServer 82478
|
|
*/
|
|
static deleteAll(key: string): number;
|
|
/**
|
|
* Liefert alle keys, die für User in der Persistence
|
|
* gespeichert wurden.
|
|
* @since AppServer 82483
|
|
*/
|
|
static getAllKeys(filterKey?: string): string[];
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert den Status eines User.
|
|
*/
|
|
declare class UserStatus {
|
|
/**
|
|
* Liefert den numerischen Wert das UserStatus.
|
|
*/
|
|
getNumericStatus(): number;
|
|
/**
|
|
* Liefert die Information ob der aktuelle UserStatus mindestens so hoch ist, wie der übergebene UserStatus.
|
|
*/
|
|
isAtLeast(otherUserStatus: UserStatus): boolean;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly Newbie: UserStatus;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly Family: UserStatus;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly Stammi: UserStatus;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly HonoryMember: UserStatus;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly Admin: UserStatus;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly SystemBot: UserStatus;
|
|
/**
|
|
*
|
|
*/
|
|
static readonly Sysadmin: UserStatus;
|
|
}
|
|
|
|
/**
|
|
* Repräsentiert den Typ eines User.
|
|
*/
|
|
declare class UserType {
|
|
/**
|
|
* Bot der App.
|
|
*/
|
|
static readonly AppBot: UserType;
|
|
/**
|
|
* Bot des Knuddels-Chatsystems.
|
|
*/
|
|
static readonly SystemBot: UserType;
|
|
/**
|
|
* Menschlicher User.
|
|
*/
|
|
static readonly Human: UserType;
|
|
}
|
|
|
|
/**
|
|
* VideoChannelData hält Informationen zu laufenden Video-Streams im Channel bereit.
|
|
*/
|
|
declare class VideoChannelData {
|
|
/**
|
|
* Liefert alle User die im Channel derzeit ihr Video streamen.
|
|
*/
|
|
getStreamingVideoUsers(): User[];
|
|
}
|
|
|