665 lines
25 KiB
TypeScript
665 lines
25 KiB
TypeScript
///////////////////////////////////////
|
|
//CONSOLE MODULE
|
|
///////////////////////////////////////
|
|
import { ODHTTPGetRequest, ODVersion, ODSystemError, ODPluginError, ODManager, ODManagerData, ODValidId } from "./base"
|
|
import { ODMain } from "../main"
|
|
import nodepath from "path"
|
|
import fs from "fs"
|
|
import ansis from "ansis"
|
|
|
|
/**## ODValidConsoleColor `type`
|
|
* This is a collection of all the supported console colors within Open Ticket.
|
|
*/
|
|
export type ODValidConsoleColor = "white"|"red"|"yellow"|"green"|"blue"|"gray"|"cyan"|"magenta"
|
|
|
|
/**## ODConsoleMessageParam `type`
|
|
* This interface contains all data required for a console log parameter within Open Ticket.
|
|
*/
|
|
export interface ODConsoleMessageParam {
|
|
/**The key of this parameter. */
|
|
key:string,
|
|
/**The value of this parameter. */
|
|
value:string,
|
|
/**When enabled, this parameter will only be shown in the debug file. */
|
|
hidden?:boolean
|
|
}
|
|
|
|
/**## ODConsoleMessage `class`
|
|
* This is an Open Ticket console message.
|
|
*
|
|
* It is used to create beautiful & styled logs in the console with a prefix, message & parameters.
|
|
* It also has full color support using `ansis` and parameters are parsed for you!
|
|
*/
|
|
export class ODConsoleMessage {
|
|
/**The main message sent in the console */
|
|
message: string
|
|
/**An array of all the parameters in this message */
|
|
params: ODConsoleMessageParam[]
|
|
/**The prefix of this message (!uppercase recommended!) */
|
|
prefix: string
|
|
/**The color of the prefix of this message */
|
|
color: ODValidConsoleColor
|
|
|
|
constructor(message:string, prefix:string, color:ODValidConsoleColor, params?:ODConsoleMessageParam[]){
|
|
this.message = message
|
|
this.params = params ? params : []
|
|
this.prefix = prefix
|
|
|
|
if (["white","red","yellow","green","blue","gray","cyan","magenta"].includes(color)){
|
|
this.color = color
|
|
}else{
|
|
this.color = "white"
|
|
}
|
|
}
|
|
/**Render this message to the console using `console.log`! Returns `false` when something went wrong. */
|
|
render(){
|
|
try {
|
|
const prefixcolor = ansis[this.color]
|
|
|
|
const paramsstring = " "+this.createParamsString("gray")
|
|
const message = prefixcolor("["+this.prefix+"] ")+this.message
|
|
|
|
console.log(message+paramsstring)
|
|
return true
|
|
}catch{
|
|
return false
|
|
}
|
|
}
|
|
/**Create a more-detailed, non-colored version of this message to store it in the `otdebug.txt` file! */
|
|
toDebugString(){
|
|
const pstrings: string[] = []
|
|
this.params.forEach((p) => {
|
|
pstrings.push(p.key+": "+p.value)
|
|
})
|
|
const pstring = (pstrings.length > 0) ? " ("+pstrings.join(", ")+")" : ""
|
|
const date = new Date()
|
|
const dstring = `${date.getDate()}/${date.getMonth()+1}/${date.getFullYear()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`
|
|
return `[${dstring} ${this.prefix}] ${this.message}${pstring}`
|
|
}
|
|
/**Render the parameters of this message in a specific color. */
|
|
createParamsString(color:ODValidConsoleColor){
|
|
let validcolor: ODValidConsoleColor = "white"
|
|
if (["white","red","yellow","green","blue","gray","cyan","magenta"].includes(color)){
|
|
validcolor = color
|
|
}
|
|
|
|
const pstrings: string[] = []
|
|
this.params.forEach((p) => {
|
|
if (!p.hidden) pstrings.push(p.key+": "+p.value)
|
|
})
|
|
|
|
return (pstrings.length > 0) ? ansis[validcolor](" ("+pstrings.join(", ")+")") : ""
|
|
}
|
|
/**Set the message */
|
|
setMessage(message:string){
|
|
this.message = message
|
|
return this
|
|
}
|
|
/**Set the params */
|
|
setParams(params:ODConsoleMessageParam[]){
|
|
this.params = params
|
|
return this
|
|
}
|
|
/**Set the prefix */
|
|
setPrefix(prefix:string){
|
|
this.prefix = prefix
|
|
return this
|
|
}
|
|
/**Set the prefix color */
|
|
setColor(color:ODValidConsoleColor){
|
|
if (["white","red","yellow","green","blue","gray","cyan","magenta"].includes(color)){
|
|
this.color = color
|
|
}else{
|
|
this.color = "white"
|
|
}
|
|
return this
|
|
}
|
|
}
|
|
|
|
/**## ODConsoleInfoMessage `class`
|
|
* This is an Open Ticket console info message.
|
|
*
|
|
* It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "INFO" messages!
|
|
*/
|
|
export class ODConsoleInfoMessage extends ODConsoleMessage {
|
|
constructor(message:string,params?:ODConsoleMessageParam[]){
|
|
super(message,"INFO","blue",params)
|
|
}
|
|
}
|
|
|
|
/**## ODConsoleSystemMessage `class`
|
|
* This is an Open Ticket console system message.
|
|
*
|
|
* It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "SYSTEM" messages!
|
|
*/
|
|
export class ODConsoleSystemMessage extends ODConsoleMessage {
|
|
constructor(message:string,params?:ODConsoleMessageParam[]){
|
|
super(message,"SYSTEM","green",params)
|
|
}
|
|
}
|
|
|
|
/**## ODConsolePluginMessage `class`
|
|
* This is an Open Ticket console plugin message.
|
|
*
|
|
* It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "PLUGIN" messages!
|
|
*/
|
|
export class ODConsolePluginMessage extends ODConsoleMessage {
|
|
constructor(message:string,params?:ODConsoleMessageParam[]){
|
|
super(message,"PLUGIN","magenta",params)
|
|
}
|
|
}
|
|
|
|
/**## ODConsoleDebugMessage `class`
|
|
* This is an Open Ticket console debug message.
|
|
*
|
|
* It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "DEBUG" messages!
|
|
*/
|
|
export class ODConsoleDebugMessage extends ODConsoleMessage {
|
|
constructor(message:string,params?:ODConsoleMessageParam[]){
|
|
super(message,"DEBUG","cyan",params)
|
|
}
|
|
}
|
|
|
|
/**## ODConsoleWarningMessage `class`
|
|
* This is an Open Ticket console warning message.
|
|
*
|
|
* It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "WARNING" messages!
|
|
*/
|
|
export class ODConsoleWarningMessage extends ODConsoleMessage {
|
|
constructor(message:string,params?:ODConsoleMessageParam[]){
|
|
super(message,"WARNING","yellow",params)
|
|
}
|
|
}
|
|
|
|
/**## ODConsoleErrorMessage `class`
|
|
* This is an Open Ticket console error message.
|
|
*
|
|
* It is the same as a normal `ODConsoleMessage`, but it has a predefined prefix & color scheme for the "ERROR" messages!
|
|
*/
|
|
export class ODConsoleErrorMessage extends ODConsoleMessage {
|
|
constructor(message:string,params?:ODConsoleMessageParam[]){
|
|
super(message,"ERROR","red",params)
|
|
}
|
|
}
|
|
|
|
/**## ODError `class`
|
|
* This is an Open Ticket error.
|
|
*
|
|
* It is used to render and log Node.js errors & crashes in a styled way to the console & `otdebug.txt` file!
|
|
*/
|
|
export class ODError {
|
|
/**The original error that this class wraps around */
|
|
error: Error|ODSystemError|ODPluginError
|
|
/**The origin of the original error */
|
|
origin: NodeJS.UncaughtExceptionOrigin
|
|
|
|
constructor(error:Error|ODSystemError|ODPluginError, origin:NodeJS.UncaughtExceptionOrigin){
|
|
this.error = error
|
|
this.origin = origin
|
|
}
|
|
|
|
/**Render this error to the console using `console.log`! Returns `false` when something went wrong. */
|
|
render(){
|
|
try {
|
|
let prefix = (this.error["_ODErrorType"] == "plugin") ? "PLUGIN ERROR" : ((this.error["_ODErrorType"] == "system") ? "OPENTICKET ERROR" : "UNKNOWN ERROR")
|
|
//title
|
|
console.log(ansis.red("["+prefix+"]: ")+this.error.message+" | origin: "+this.origin)
|
|
//stack trace
|
|
if (this.error.stack) console.log(ansis.gray(this.error.stack))
|
|
//additional message
|
|
if (this.error["_ODErrorType"] == "plugin") console.log(ansis.red.bold("\nPlease report this error to the plugin developer and help us create a more stable plugin!"))
|
|
else console.log(ansis.red.bold("\nPlease report this error to our discord server and help us create a more stable ticket bot!"))
|
|
console.log(ansis.red("Also send the "+ansis.cyan.bold("otdebug.txt")+" file! It would help a lot!\n"))
|
|
return true
|
|
}catch{
|
|
return false
|
|
}
|
|
}
|
|
/**Create a more-detailed, non-colored version of this error to store it in the `otdebug.txt` file! */
|
|
toDebugString(){
|
|
return "[UNKNOWN OD ERROR]: "+this.error.message+" | origin: "+this.origin+"\n"+this.error.stack
|
|
}
|
|
}
|
|
|
|
/**## ODConsoleMessageTypes `type`
|
|
* This is a collection of all the default console message types within Open Ticket.
|
|
*/
|
|
export type ODConsoleMessageTypes = "info"|"system"|"plugin"|"debug"|"warning"|"error"
|
|
|
|
/**## ODConsoleManager `class`
|
|
* This is the Open Ticket console manager.
|
|
*
|
|
* It handles the entire console system of Open Ticket. It's also the place where you need to log `ODConsoleMessage`'s.
|
|
* This manager keeps a short history of messages sent to the console which is configurable by plugins.
|
|
*
|
|
* The debug file (`otdebug.txt`) is handled in a sub-manager!
|
|
*/
|
|
export class ODConsoleManager {
|
|
/**The history of `ODConsoleMessage`'s and `ODError`'s since startup */
|
|
history: (ODConsoleMessage|ODError)[] = []
|
|
/**The max length of the history. The oldest messages will be removed when over the limit */
|
|
historylength = 100
|
|
/**An alias to the debugfile manager. (`otdebug.txt`) */
|
|
debugfile: ODDebugFileManager
|
|
/**Is silent mode enabled? */
|
|
silent: boolean = false
|
|
|
|
constructor(historylength:number, debugfile:ODDebugFileManager){
|
|
this.historylength = historylength
|
|
this.debugfile = debugfile
|
|
}
|
|
|
|
/**Log a message to the console ... But in the Open Ticket way :) */
|
|
log(message:ODConsoleMessage): void
|
|
log(message:ODError): void
|
|
log(message:string, type?:ODConsoleMessageTypes, params?:ODConsoleMessageParam[]): void
|
|
log(message:ODConsoleMessage|ODError|string, type?:ODConsoleMessageTypes, params?:ODConsoleMessageParam[]){
|
|
if (message instanceof ODConsoleMessage){
|
|
if (!this.silent) message.render()
|
|
if (this.debugfile) this.debugfile.writeConsoleMessage(message)
|
|
this.history.push(message)
|
|
|
|
}else if (message instanceof ODError){
|
|
if (!this.silent) message.render()
|
|
if (this.debugfile) this.debugfile.writeErrorMessage(message)
|
|
this.history.push(message)
|
|
|
|
}else if (["string","number","boolean","object"].includes(typeof message)){
|
|
let newMessage: ODConsoleMessage
|
|
if (type == "info") newMessage = new ODConsoleInfoMessage(message,params)
|
|
else if (type == "system") newMessage = new ODConsoleSystemMessage(message,params)
|
|
else if (type == "plugin") newMessage = new ODConsolePluginMessage(message,params)
|
|
else if (type == "debug") newMessage = new ODConsoleDebugMessage(message,params)
|
|
else if (type == "warning") newMessage = new ODConsoleWarningMessage(message,params)
|
|
else if (type == "error") newMessage = new ODConsoleErrorMessage(message,params)
|
|
else newMessage = new ODConsoleSystemMessage(message,params)
|
|
|
|
if (!this.silent) newMessage.render()
|
|
if (this.debugfile) this.debugfile.writeConsoleMessage(newMessage)
|
|
this.history.push(newMessage)
|
|
}
|
|
this.#purgeHistory()
|
|
}
|
|
/**Shorten the history when it exceeds the max history length! */
|
|
#purgeHistory(){
|
|
if (this.history.length > this.historylength) this.history.shift()
|
|
}
|
|
}
|
|
|
|
/**## ODDebugFileManager `class`
|
|
* This is the Open Ticket debug file manager.
|
|
*
|
|
* It manages the Open Ticket debug file (`otdebug.txt`) which keeps a history of all system logs.
|
|
* There are even internal logs that aren't logged to the console which are available in this file!
|
|
*
|
|
* Using this class, you can change the max length of this file and some other cool things!
|
|
*/
|
|
export class ODDebugFileManager {
|
|
/**The path to the debugfile (`./otdebug.txt` by default) */
|
|
path: string
|
|
/**The filename of the debugfile (`otdebug.txt` by default) */
|
|
filename: string
|
|
/**The current version of the bot used in the debug file. */
|
|
version: ODVersion
|
|
/**The max length of the debug file. */
|
|
maxlines: number
|
|
|
|
constructor(path:string, filename:string, maxlines:number, version:ODVersion){
|
|
this.path = nodepath.join(path,filename)
|
|
this.filename = filename
|
|
this.version = version
|
|
this.maxlines = maxlines
|
|
|
|
this.#writeStartupStats()
|
|
}
|
|
|
|
/**Check if the debug file exists */
|
|
#existsDebugFile(){
|
|
return fs.existsSync(this.path)
|
|
}
|
|
/**Read from the debug file */
|
|
#readDebugFile(){
|
|
if (this.#existsDebugFile()){
|
|
try {
|
|
return fs.readFileSync(this.path).toString()
|
|
}catch{
|
|
return false
|
|
}
|
|
}else{
|
|
return false
|
|
}
|
|
}
|
|
/**Write to the debug file and shorten it when needed. */
|
|
#writeDebugFile(text:string){
|
|
const currenttext = this.#readDebugFile()
|
|
if (currenttext){
|
|
const splitted = currenttext.split("\n")
|
|
|
|
if (splitted.length+text.split("\n").length > this.maxlines){
|
|
splitted.splice(7,(text.split("\n").length))
|
|
}
|
|
|
|
splitted.push(text)
|
|
fs.writeFileSync(this.path,splitted.join("\n"))
|
|
}else{
|
|
//write new file:
|
|
const newtext = this.#createStatsText()+text
|
|
fs.writeFileSync(this.path,newtext)
|
|
}
|
|
}
|
|
/**Generate the stats/header of the debug file (containing the version) */
|
|
#createStatsText(){
|
|
const date = new Date()
|
|
const dstring = `${date.getDate()}/${date.getMonth()+1}/${date.getFullYear()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`
|
|
return [
|
|
"=========================",
|
|
"OPEN TICKET DEBUG FILE:",
|
|
"version: "+this.version.toString(),
|
|
"last startup: "+dstring,
|
|
"=========================\n\n"
|
|
].join("\n")
|
|
}
|
|
/**Write the stats/header to the debug file on startup */
|
|
#writeStartupStats(){
|
|
const currenttext = this.#readDebugFile()
|
|
if (currenttext){
|
|
//edit previous file:
|
|
const splitted = currenttext.split("\n")
|
|
splitted.splice(0,7)
|
|
|
|
if (splitted.length+11 > this.maxlines){
|
|
splitted.splice(0,((splitted.length+11) - this.maxlines))
|
|
}
|
|
|
|
splitted.unshift(this.#createStatsText())
|
|
splitted.push("\n---------------------------------------------------------------------\n---------------------------------------------------------------------\n")
|
|
|
|
fs.writeFileSync(this.path,splitted.join("\n"))
|
|
}else{
|
|
//write new file:
|
|
const newtext = this.#createStatsText()
|
|
fs.writeFileSync(this.path,newtext)
|
|
}
|
|
}
|
|
/**Write an `ODConsoleMessage` to the debug file */
|
|
writeConsoleMessage(message:ODConsoleMessage){
|
|
this.#writeDebugFile(message.toDebugString())
|
|
}
|
|
/**Write an `ODError` to the debug file */
|
|
writeErrorMessage(error:ODError){
|
|
this.#writeDebugFile(error.toDebugString())
|
|
}
|
|
/**Write custom text to the debug file */
|
|
writeText(text:string){
|
|
this.#writeDebugFile(text)
|
|
}
|
|
/**Write a custom note to the debug file (starting with `[NOTE]:`) */
|
|
writeNote(text:string){
|
|
this.#writeDebugFile("[NOTE]: "+text)
|
|
}
|
|
}
|
|
|
|
/**## ODDebugger `class`
|
|
* This is the Open Ticket debugger.
|
|
*
|
|
* It is a simple wrapper around the `ODConsoleManager` to handle debugging (primarily for `ODManagers`).
|
|
* Messages created using this debugger are only logged to the debug file unless specified otherwise.
|
|
*
|
|
* You will probably notice this class being used in the `ODManager` constructor.
|
|
*
|
|
* Using this system, all additions & removals inside a manager are logged to the debug file. This makes searching for errors a lot easier!
|
|
*/
|
|
export class ODDebugger {
|
|
/**An alias to the Open Ticket console manager. */
|
|
console: ODConsoleManager
|
|
/**When enabled, debug logs are also shown in the console. */
|
|
visible: boolean = false
|
|
|
|
constructor(console:ODConsoleManager){
|
|
this.console = console
|
|
}
|
|
|
|
/**Create a debug message. This will always be logged to `otdebug.txt` & sometimes to the console (when enabled). Returns `true` when visible */
|
|
debug(message:string, params?:{key:string,value:string}[]): boolean {
|
|
if (this.visible){
|
|
this.console.log(new ODConsoleDebugMessage(message,params))
|
|
return true
|
|
}else{
|
|
this.console.debugfile.writeConsoleMessage(new ODConsoleDebugMessage(message,params))
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
/**## ODLivestatusColor `type`
|
|
* This is a collection of all the colors available within the LiveStatus system.
|
|
*/
|
|
export type ODLiveStatusColor = "normal"|"red"|"green"|"blue"|"yellow"|"white"|"gray"|"magenta"|"cyan"
|
|
|
|
/**## ODLiveStatusSourceData `interface`
|
|
* This is an interface containing all raw data received from the LiveStatus system.
|
|
*/
|
|
export interface ODLiveStatusSourceData {
|
|
/**The message to display */
|
|
message:{
|
|
/**The title of the message to display */
|
|
title:string,
|
|
/**The title color of the message to display */
|
|
titleColor:ODLiveStatusColor,
|
|
/**The description of the message to display */
|
|
description:string,
|
|
/**The description color of the message to display */
|
|
descriptionColor:ODLiveStatusColor
|
|
},
|
|
/**The message will only be shown when the bot matches all statements */
|
|
active:{
|
|
/**A list of versions to match */
|
|
versions:string[],
|
|
/**A list of languages to match */
|
|
languages:string[],
|
|
/**All languages should match */
|
|
allLanguages:boolean,
|
|
/**Match when the bot is using plugins */
|
|
usingPlugins:boolean,
|
|
/**Match when the bot is not using plugins */
|
|
notUsingPlugins:boolean,
|
|
/**Match when the bot is using slash commands */
|
|
usingSlashCommands:boolean,
|
|
/**Match when the bot is not using slash commands */
|
|
notUsingSlashCommands:boolean,
|
|
/**Match when the bot is not using transcripts */
|
|
notUsingTranscripts:boolean,
|
|
/**Match when the bot is using text transcripts */
|
|
usingTextTranscripts:boolean,
|
|
/**Match when the bot is using html transcripts */
|
|
usingHtmlTranscripts:boolean
|
|
}
|
|
}
|
|
|
|
/**## ODLiveStatusSource `class`
|
|
* This is the Open Ticket livestatus source.
|
|
*
|
|
* It is an empty template for a livestatus source.
|
|
* By default, you should use `ODLiveStatusUrlSource` or `ODLiveStatusFileSource`,
|
|
* unless you want to create one on your own!
|
|
*
|
|
* This class doesn't do anything on it's own! It's just a template!
|
|
*/
|
|
export class ODLiveStatusSource extends ODManagerData {
|
|
/**The raw data of this source */
|
|
data: ODLiveStatusSourceData[]
|
|
|
|
constructor(id:ODValidId, data:ODLiveStatusSourceData[]){
|
|
super(id)
|
|
this.data = data
|
|
}
|
|
|
|
/**Change the current data using this method! */
|
|
setData(data:ODLiveStatusSourceData[]){
|
|
this.data = data
|
|
}
|
|
/**Get all messages relevant to the bot based on some parameters. */
|
|
async getMessages(main:ODMain): Promise<ODLiveStatusSourceData[]> {
|
|
const validMessages: ODLiveStatusSourceData[] = []
|
|
|
|
//parse data from ODMain
|
|
const currentVersion: string = main.versions.get("opendiscord:version").toString(true)
|
|
const usingSlashCommands: boolean = main.configs.get("opendiscord:general").data.slashCommands
|
|
const usingTranscripts: false|"text"|"html" = false as false|"text"|"html" //TODO
|
|
const currentLanguage: string = main.languages.getCurrentLanguageId()
|
|
const usingPlugins: boolean = (main.plugins.getLength() > 0)
|
|
|
|
//check data for each message
|
|
this.data.forEach((msg) => {
|
|
const {active} = msg
|
|
|
|
const correctVersion = active.versions.includes(currentVersion)
|
|
const correctSlashMode = (usingSlashCommands && active.usingSlashCommands) || (!usingSlashCommands && active.notUsingSlashCommands)
|
|
const correctTranscriptMode = (usingTranscripts == "text" && active.usingTextTranscripts) || (usingTranscripts == "html" && active.usingHtmlTranscripts) || (!usingTranscripts && active.notUsingTranscripts)
|
|
const correctLanguage = active.languages.includes(currentLanguage) || active.allLanguages
|
|
const correctPlugins = (usingPlugins && active.usingPlugins) || (!usingPlugins && active.notUsingPlugins)
|
|
|
|
if (correctVersion && correctLanguage && correctPlugins && correctSlashMode && correctTranscriptMode) validMessages.push(msg)
|
|
})
|
|
|
|
//return the valid messages
|
|
return validMessages
|
|
}
|
|
}
|
|
|
|
/**## ODLiveStatusFileSource `class`
|
|
* This is the Open Ticket livestatus file source.
|
|
*
|
|
* It is a LiveStatus source that will read the data from a local file.
|
|
*
|
|
* This can be used for testing/extending the LiveStatus system!
|
|
*/
|
|
export class ODLiveStatusFileSource extends ODLiveStatusSource {
|
|
/**The path to the source file */
|
|
path: string
|
|
|
|
constructor(id:ODValidId, path:string){
|
|
if (fs.existsSync(path)){
|
|
super(id,JSON.parse(fs.readFileSync(path).toString()))
|
|
}else throw new ODSystemError("LiveStatus source file doesn't exist!")
|
|
this.path = path
|
|
}
|
|
}
|
|
|
|
/**## ODLiveStatusUrlSource `class`
|
|
* This is the Open Ticket livestatus url source.
|
|
*
|
|
* It is a LiveStatus source that will read the data from a http URL (json file).
|
|
*
|
|
* This is the default way of receiving LiveStatus messages!
|
|
*/
|
|
export class ODLiveStatusUrlSource extends ODLiveStatusSource {
|
|
/**The url used in the request */
|
|
url: string
|
|
/**The `ODHTTPGetRequest` helper to fetch the url! */
|
|
request: ODHTTPGetRequest
|
|
|
|
constructor(id:ODValidId, url:string){
|
|
super(id,[])
|
|
this.url = url
|
|
this.request = new ODHTTPGetRequest(url,false)
|
|
}
|
|
async getMessages(main:ODMain): Promise<ODLiveStatusSourceData[]> {
|
|
//additional setup
|
|
this.request.url = this.url
|
|
const rawRes = await this.request.run()
|
|
if (rawRes.status != 200) throw new ODSystemError("ODLiveStatusUrlSource => Request Failed!")
|
|
try{
|
|
this.setData(JSON.parse(rawRes.body))
|
|
}catch{
|
|
throw new ODSystemError("ODLiveStatusUrlSource => Request Failed!")
|
|
}
|
|
|
|
//default
|
|
return super.getMessages(main)
|
|
}
|
|
}
|
|
|
|
/**## ODLiveStatusManager `class`
|
|
* This is the Open Ticket livestatus manager.
|
|
*
|
|
* It manages all LiveStatus sources and has the renderer for all LiveStatus messages.
|
|
*
|
|
* You can use this to customise or add stuff to the LiveStatus system.
|
|
* Access it in the global `opendiscord.startscreen.livestatus` variable!
|
|
*/
|
|
export class ODLiveStatusManager extends ODManager<ODLiveStatusSource> {
|
|
/**The class responsible for rendering the livestatus messages. */
|
|
renderer: ODLiveStatusRenderer
|
|
/**A reference to the ODMain or "openticket" global variable */
|
|
#main: ODMain
|
|
|
|
constructor(debug:ODDebugger, main:ODMain){
|
|
super(debug,"livestatus source")
|
|
this.renderer = new ODLiveStatusRenderer(main.console)
|
|
this.#main = main
|
|
}
|
|
|
|
/**Get the messages from all sources combined! */
|
|
async getAllMessages(): Promise<ODLiveStatusSourceData[]> {
|
|
const messages: ODLiveStatusSourceData[] = []
|
|
for (const source of this.getAll()){
|
|
try {
|
|
messages.push(...(await source.getMessages(this.#main)))
|
|
}catch{}
|
|
}
|
|
return messages
|
|
}
|
|
}
|
|
|
|
/**## ODLiveStatusRenderer `class`
|
|
* This is the Open Ticket livestatus renderer.
|
|
*
|
|
* It's responsible for rendering all LiveStatus messages to the console.
|
|
*/
|
|
export class ODLiveStatusRenderer {
|
|
/**A reference to the ODConsoleManager or "opendiscord.console" global variable */
|
|
#console: ODConsoleManager
|
|
|
|
constructor(console:ODConsoleManager){
|
|
this.#console = console
|
|
}
|
|
|
|
/**Render all messages */
|
|
render(messages:ODLiveStatusSourceData[]): string {
|
|
try {
|
|
//process data
|
|
const final: string[] = []
|
|
messages.forEach((msg) => {
|
|
const titleColor = msg.message.titleColor
|
|
const title = "["+msg.message.title+"] "
|
|
|
|
const descriptionColor = msg.message.descriptionColor
|
|
const description = msg.message.description.split("\n").map((text,row) => {
|
|
//first row row doesn't need prefix
|
|
if (row < 1) return text
|
|
//other rows do need a prefix
|
|
let text2 = text
|
|
for (const i of title){
|
|
text2 = " "+text2
|
|
}
|
|
return text2
|
|
}).join("\n")
|
|
|
|
|
|
if (!["red","yellow","green","blue","gray","magenta","cyan"].includes(titleColor)) var finalTitle = ansis.white(title)
|
|
else var finalTitle = ansis[titleColor](title)
|
|
if (!["red","yellow","green","blue","gray","magenta","cyan"].includes(descriptionColor)) var finalDescription = ansis.white(description)
|
|
else var finalDescription = ansis[descriptionColor](description)
|
|
|
|
final.push(finalTitle+finalDescription)
|
|
})
|
|
|
|
//return all messages
|
|
return final.join("\n")
|
|
}catch{
|
|
this.#console.log("Failed to render LiveStatus messages!","error")
|
|
return ""
|
|
}
|
|
}
|
|
} |