service.js

/*!
**|   PonkBot Replacements
**@
*/

'use strict';

const EventEmitter = require('events')
const UserAgent = require('user-agents')
const express = require('express')
const fs = require('fs')
const path = require('path')

const ponkBotPath = path.dirname(require.resolve('ponkbot'))

const PonkBot = require(path.join(ponkBotPath, 'lib', 'ponkbot.js'))
//const CyTubeClient = require(path.join(ponkBotPath, 'lib', 'client.js'))
const PonkDatabase = require(path.join(ponkBotPath, 'lib', 'database.js'))

//const BackupData = require('backupdata.js')
//const ChannelBackup = require('./balloons/channelbackup.js')

class Bot extends PonkBot {
  constructor(config) {
    super(config)
    Object.assign(this, {
      lastImages   : [],                        // A list with lastly posted Images
      randAgent    : new UserAgent().toString() // A random UserAgent
    })
    this.once('dbready', () => {
      this.db.createTableIfNotExists('lastimage', (table) => {
        table.increments();
        table.string('image', 480)
      })
    })
    this.once('clientinit', () => {
      //this.backup = new ChannelBackup({
      //  emotehost  : process.env.emotehost,
      //  headers    : { 'User-Agent': this.randAgent },
      //  backuppath : path.join(__dirname, '..', 'testbackup'),
      //  client     : this.client
      //})
      this.client.on('channelOpts', opts => {
        if (!opts.show_public) return
        this.client.once('readChanLog', ({ data }) => {
          this.client.sendOptions({ show_public: false })
          this.client.createPoll({
            title: `${(data.trim().split('\n').pop().match(/\[mod\] (\w+)/) || [])[1]} ist der huso`,
            opts: ['/gas', '/hinaus', '/pissdich', '/2homo', '/fdax'],
            obscured: false
          })
        })
        this.client.socket.emit('readChanLog')
      })
      this.client.on('updateChatFilter', ({ name }) => {
        if (!name.startsWith('Bot filter ###')) return
        this.sendMessage(name)
        setTimeout(() => this.client.socket.emit('removeFilter', {
          name
        }), 2000)
      })
      this.registerCooldown({
        type           : 'emit',
        name           : 'emit',
        personalType   : 'ignore',
        personalParams : null,
        sharedType     : 'bucket',
        sharedParams   : [10, 1, 'second', null],
      })
    })
    this.once('clientstart', () => {
      const emit = this.client.socket.emit
      const ponk = this
      this.client.socket.emit = function() {
        ponk.checkCooldown({ type: 'emit', user: ponk.name, silent: true }).then(() => {
          emit.apply(this, arguments)
        }, message => setTimeout(() => {
          process.nextTick(() => {
            this.emit(...arguments)
          })
        }, 500))
      }
      this.client.socket.emit('requestChatFilters')
      this.logger.log(`Requested Chat-Filters`)
      super.inflate(path.join(ponkBotPath, 'hammerspace'), [
        'ponk_anagram.js',
        'ponk_horseshoe.js'
      ])
    })
  }
  get emotes() {
    return this.backup?.emotes || this._emotes || []
  }
  set emotes(emotes) {
    this._emotes = emotes
  }
  addLastImage(image) {
    return new Promise((resolve, reject) => {
      if (image === this.lastImages[0]) return resolve(image)
      this.lastImages.unshift(image)
      this.db.knex('lastimage').insert({ image }).then(() => {
        //this.logger.log('Image posted: ' + image)
        resolve(image)
      }, error => {
        this.logger.error('Unexpected error', '\n', error);
        resolve(image)
      })
    })
  }
  getLastImage(back) {
    if (!back) back = 0
    return new Promise(resolve => {
      if (this.lastImages.length > back + 1) return resolve(this.lastImages[back])
      this.db.knex('lastimage')
      .select('image').limit(back + 1).orderBy('id', 'desc').then(result => {
        if (result.length > back) {
          this.lastImages = result.map(row => row.image)
          resolve(this.lastImages[back])
        }
      }, err => resolve(this.sendMessage('fehler')))
    })
  }
  pollAction(poll, callback) {
    return new Promise((resolve, reject) => {
      if (!this.meeseeks('pollctl')) {
        return this.sendMessage('I lack this capability due to channel permission settings.')
      }
      if (callback && typeof callback  === 'function') resolve = callback
      this.client.createPoll(poll)
      this.client.once('newPoll', () => {
        let timeout = false
        if (poll.timeout && poll.timeout > 10) {
          timeout = setTimeout(() => {
            this.sendMessage('Noch 10 Sekunden Zeit abzustimmen.', { ignoremute: true })
          }, (poll.timeout - 10) * 1000)
        }
        this.client.once('closePoll', () => {
          timeout && clearTimeout(timeout)
          resolve(this.poll.counts)
        })
      })
    })
  }
  sendByFilter(message, force) {
    if (!this.meeseeks('filteredit')) {
      if (force) return this.sendMessage('Für diese Funktion muss ich Filter erstellen dürfen')
      return this.sendMessage(message)
    }
    if (message.length < 320 && !force) return this.sendMessage(message)
    const limit = 1000
    const count = Math.ceil(message.length / limit)
    for (let i = 0; i < count; i++) {
      const name = 'Bot filter ###' + Math.random().toString(36).slice(2) + '###'
      this.client.socket.emit('addFilter', {
        name,
        source: name,
        replace: message.substr(i * limit, limit),
        flags: '',
        active: true
      })
    }
  }
  sendMessage(message, meta = {}){
    if(!this.meeseeks('chat')){
      this.logger.error('Unable to send chat messages due to restrictive channel permissions');
      return;
    }
    // Future home of other stuff like modflair and color overrides
    const { ignoremute } = meta;
    if(this.muted && !ignoremute){ return }
    //Repeat if Message too long
    const limit = 320;
    const count = Math.ceil(message.length / limit);
    for (let i = 0; i < count; i++)
    this.client.chat({
      msg: message.substr(i * limit, limit),
      meta: Object.assign({}, this.useflair && this.rank <= 2 ? {
        modflair: this.rank
      } : {})
    });
  }
  handleChatMessage({ username: user, msg: message, time, meta }) {
    if (time < this.started) return
    const triggered = this.commands.trigger.test(this.filterChat(message))
    if (triggered) this.commandDispatcher(user, message)
    else if (!this.bots.concat('[server]').includes(user)) {
      let match
      let regex = /(?<=^|\s)(\/[a-zA-Z0-9ßäöüÄÖÜ]+)(?=\s|$)/g
      const emotes = {}
      while (match = regex.exec(message)) {
        const emote = this.emotes.find(emote => emote.name == match[1])
        if (!emote) continue
        if (!emotes[emote.name]) emotes[emote.name] = 1
        else emotes[emote.name]++
      }
      Object.keys(emotes).forEach(emote => {
        const count = emotes[emote]
        this.db.knex('emotes').insert({ emote, count, lastuser: user}).catch(() => {
          return this.db.knex('emotes').where({ emote }).increment({ count }).update({ lastuser: user })
        }).then(() => {
          //this.logger.log('Emote used: ' + emote + ' ' + count + ' times by ' + user)
        })
      })
      regex = /<img class="image-embed-small" src="(https?:\/\/[^"]+)" \/>/g
      while (match = regex.exec(message)) {
        this.addLastImage(match[1])
      }
      if (message.match(new RegExp('^' + this.name + '|[^!.$/]' + this.name))) {
        if (user === 'melli17') this.sendMessage('/knuddeln')
        else this.sendMessage((arr => arr[Math.floor(Math.random() * arr.length)])([
          'Hiiiiiiii',
          'jaaaah?',
          'ja morgen',
          'w-was?',
          'lass mich',
          'hihi',
          'iiich?'
        ]))
      }
    }
    this.emit('message', { time, user, message });
  }
  handlePrivateMessage({ username, msg }) {
    this.logger.log(`Private Message "${msg}" from: ${username}`)
  }
  mediaSend({ type, id, temp = true, pos = 'end', title }) {
    const media = {
      'type'     : type,
      'id'       : id,
      'pos'      : pos,
      'temp'     : temp,
      'duration' : 0,
    }
    if (title && (media.type === "cu" || media.type === "fi")) media.title = title

    this.checkCooldown({ type: 'mediaSend', user: this.name, silent: true }).then(() => {
      this.logger.log(`Sending queue request for ${media.type}:${media.id}`);
      this.client.socket.emit('queue', media);
    },(message) => {
      setTimeout(()=>{
        process.nextTick(()=>{
          this.mediaSend(media);
        });
      }, 500);
    });
  }
  commandDispatcher(user, message){
    let split = this.filterChat(message).split(' ');
    const command = split.shift().slice(1);
    let params = split.join(' ').trim();
    if(this.bots.includes(user)){
      this.logger.debug(`Command ${command} invoked by self or peer.`);
      return;
    }
    if(this.commands.blacklist.includes(user)){
      this.logger.debug(`Command ${command} invoked by blacklisted user ${user}.`);
      return;
    }
    if(this.commands.disabled.includes(command)){
      this.logger.debug(`Disabled command ${command} invoked.`);
      return;
    }
    if (command in this.commands.handlers){
      this.userCheckBarred(user).then((barred)=>{
        if(barred){
          return this.sendPrivate('You are barred from issuing commands to this bot.', user);
        }
        this.logger.log('Received command dispatch', command);
        const rank = this.getUserRank(user);
        const needrank = this.commands.helpdata[command].rank;
        if (rank < needrank) return this.sendMessage('Geht nur ab lvl ' + needrank);
        let addnext = this.commands.helpdata[command].addnext
        if (addnext) {
          const cleanparams = params.replace(new RegExp(addnext + '$'), '').trim()
          addnext = params != cleanparams
          params = cleanparams
        }
        let repeat = this.commands.helpdata[command].repeat
        if (repeat) {
          repeat = 1
          params = params.replace(/(?:^|\s)\d{1,2}$/, match => {
            if (rank > 3) repeat = Math.min(5, match.trim())
            return ''
          }).trim()
        }
        this.logger.command(`${user} invoked ${command} with ${params ? params : 'no params.'}`);
        this.commands.handlers[command](user, params, { command, message, rank, addnext, repeat });
      });
    }
  }
  registerCommands({ handlers = {}, helpdata = {}, cooldowns = {} }){
    this.logger.debug('', '\n', handlers,'\n', helpdata, '\n', cooldowns);

    for (const handler in handlers) {
      this.logger.log(`Registering command handler ${handler}`);
      if(typeof this.commands.handlers[handler] !== 'undefined'){
        this.logger.log(`Handler ${handler} already exists! Overwriting`);
      }
      this.commands.handlers[handler] = handlers[handler].bind(this);
    }

    if(Object.keys(cooldowns).length){
      for (const cooldown in cooldowns){
        this.registerCooldown(cooldowns[cooldown]);
      }
    }

    // TODO: decide a helpdata structure
    if(Object.keys(helpdata).length){
      for (const help in helpdata){
        this.commands.helpdata[help] = helpdata[help];
      }
    }

    return this;
  }
  createDatabase(config) {
    this.logger.log('Creating database.')
    this.db = new class extends PonkDatabase {

      createTableIfNotExists(tableName, callback) {
        const schema = this.knex.schema
        return schema.hasTable(tableName).then(exists => {
          if (exists) return Promise.resolve()
          else return schema.createTable(tableName, table => {
            callback(table)
          },(error)=>{
            this.logger.error('Unexpected error', '\n', error);
            return reject(error);
          })
        })
      }

      createTables(){
        this.logger.log('Creating Tables');

        // Users
        this.createTableIfNotExists('users', (table)=>{
          table.string('username', 20).primary();
          table.integer('rank');
          table.integer('flags').unsigned();
          table.bigint('last_seen').unsigned();
        })

        // Chat history
        .then(() => this.createTableIfNotExists('chat', (table)=>{
          table.increments();
          table.bigint('timestamp').unsigned();
          table.string('user', 20);
          table.text('message');
          table.string('channel');

          table.foreign('user').references('users.username');
        }))

        // Videos
        .then(() => this.createTableIfNotExists('videos', (table)=>{
          table.string('type', 20);
          table.string('id');
          table.string('title');
          table.integer('duration_ms').unsigned();
          table.bigint('last_played').unsigned();
          table.integer('flags').unsigned();

          table.primary(['type', 'id']);
        }))

        // Playlist statistics
        .then(() => this.createTableIfNotExists('video_stats', (table)=>{
          table.string('type', 20);
          table.string('id');
          table.string('user', 20);
          table.bigint('timestamp').unsigned().primary();

          table.foreign(['type', 'id'])
          .references(['type', 'id'])
          .on('videos')
          ;
          table.foreign('user').references('users.username');
        }))

        // Channel population tracking
        .then(() => this.createTableIfNotExists('user_count', (table)=>{
          table.bigint('timestamp').unsigned();
          table.integer('count').unsigned();
          table.primary(['timestamp', 'count']);
        }))

        // Basic key:value storage
        .then(() => this.createTableIfNotExists('simplestore', (table)=>{
          table.string('key', 40).primary();
          table.string('value');
        }))

        .then(()=>{
          return this.updateTables();
        });
      }

      updateTables(){
        this.logger.log('Updating Tables.');

        this.getKeyValue('dbversion').then((version) => {
          if (typeof version === 'undefined') {
            this.logger.log('First run. Initializing dbversion.')
            return this.setKeyValue('dbversion', 0).then(() => { this.updateTables() });
          }
          if (parseInt(version) === this.latest) {
            this.logger.log('Tables up to date, database is ready.')
            this.version = this.latest;
            this.emit('ready');
            return;
          }

          this.version = parseInt(version);

          let state = 0;
          if (this.version === state) {
            this.logger.log('Creating table for moderator auth to web interface.')
            return this.createTableIfNotExists('webauth', (table) => {
              table.increments();
              table.string('user', 20)
              .references('username').inTable('users')
              ;
              table.string('authkey', 32);
            })
            .then(() => {
              this.setKeyValue('dbversion', ++state).then(() => {
                this.updateTables();
              });
            })
            .catch((error) => {
              throw error;
            });
          }

          state++; // 1
          if (this.version === state) {
            this.logger.log('Creating table for web interface sessions.')
            return this.createTableIfNotExists('sessionstore', (table) => {
              table.string('sessid').primary();
              table.json('sess').notNullable();
              if (['mysql', 'mariasql'].indexOf(this.knex.client.dialect) > -1) {
                table.dateTime('expired').notNullable().index();
              } else {
                table.timestamp('expired').notNullable().index();
              }
            })
            .then(() => {
              this.setKeyValue('dbversion', ++state).then(() => {
                this.updateTables();
              });
            })
            .catch((error) => {
              throw error;
            });
          }

          state++; // 2
          if (this.version === state) {
            this.logger.log('Creating table for user profiles and hybrid permissions.')
            return this.createTableIfNotExists('users_meta', (table) => {
              table.string('user', 20).primary();

              table.text('avatar');
              table.text('profile');
              table.json('hybrid');

              table.foreign('user').references('users.username');
            })
            .then(()=>{
              this.setKeyValue('dbversion', ++state).then(()=>{
                this.updateTables();
              });
            })
            .catch((error) => {
              throw error;
            });
          }

        })
        .catch((error) => {
          throw error;
        });
      }
    }(config, this.log, this);
    return this.db;
  }
  createServer({ weblink, webport }) {
    //this.server = newPonkServer(config, this.log, this);
    this.logger.log('Creating webhost.')

    this.server = {
      host: express(),
      weblink,
      webport
    }
    this.server.host.listen(webport)

    this.server.host.get('/api/:event', (req, res) => {
      if (!this.server.api.emit(req.params.event, req, res)) res.send('')
    })
    this.server.api = new EventEmitter()
    if (!process.env.PORT) this.server.weblink += ':' + this.server.webport

    return this.server
  }
  balloonCheck() {
    this.logger.log('Checking for balloons.')
    const balloons = path.join(__dirname, 'balloons')

    fs.stat(balloons, (err, stats) => {
      if(err) {
        this.logger.debug(err)
        return this.logger.log('No balloon bag found.')
      }
      if(!stats.isDirectory()) {
        return this.logger.error('WARNING! "balloons" exists in path but is not a directory.')
      }
      this.logger.debug('Balloon bag found. Searching.')
      this.balloonWalk(balloons)
    })
  }
  async inflate(bag, stash) {
    for (const balloon of stash.reverse()) await (async (balloon, cutiemark) => {
      if (!cutiemark.meta.active) {
        return this.logger.log(`Skipping inactive balloon: ${balloon}`)
      }
      if (cutiemark.meta.type === 'giggle') {
        this.logger.log(`Inflating API balloon! ${balloon}`)
        try {
          await cutiemark.giggle(this)
        }
        catch (err) {
          console.error(err)
        }
        this.registerCommands(cutiemark)
      }
      else super.inflate(bag, [balloon])
    })(balloon, require(path.join(bag, balloon)))
  }
}

if (fs.existsSync('./.env')) require('dotenv').config()

function getConfig(args){
  let config = './config.js';
  config = typeof args.config == "string" ? args.config : config;

  // Check for relative path without leading "./"
  if(!config.match(/^\//) && config.match(/\//)){
    config = `./${config}`;
  }

  try {
    require.resolve(config);
  }
  catch(err) {
    console.error('Could not locate configuration file');
    process.exit(78);
  }

  return config;
}

const argv = require('minimist')(process.argv.slice(2));
const configfile = getConfig(argv);
const config = require(configfile);
const bot = new Bot(config)