src/database/channels.js

   1 var db = require("../database");
   2 var valid = require("../utilities").isValidChannelName;
   3 var Flags = require("../flags");
   4 var util = require("../utilities");
   5 import { createMySQLDuplicateKeyUpdate } from '../util/on-duplicate-key-update';
   6 import Config from '../config';
   7
   8 const LOGGER = require('@calzoneman/jsli')('database/channels');
   9
  10 var blackHole = function () { };
  11
  12 module.exports = {
  13     init: function () {
  14     },
  15
  16     /**
  17      * Checks if the given channel name is registered
  18      */
  19     isChannelTaken: function (name, callback) {
  20         if (typeof callback !== "function") {
  21             return;
  22         }
  23
  24         if (!valid(name)) {
  25             callback("Invalid channel name", null);
  26             return;
  27         }
  28
  29         db.query("SELECT name FROM `channels` WHERE name=?",
  30                      [name],
  31                      function (err, rows) {
  32             if (err) {
  33                 callback(err, true);
  34                 return;
  35             }
  36             callback(null, rows.length > 0);
  37         });
  38     },
  39
  40     /**
  41      * Looks up a channel
  42      */
  43     lookup: function (name, callback) {
  44         if (typeof callback !== "function") {
  45             return;
  46         }
  47
  48         if (!valid(name)) {
  49             callback("Invalid channel name", null);
  50             return;
  51         }
  52
  53         db.query("SELECT * FROM `channels` WHERE name=?",
  54                      [name],
  55                      function (err, rows) {
  56             if (err) {
  57                 callback(err, null);
  58                 return;
  59             }
  60
  61             if (rows.length === 0) {
  62                 callback("No such channel", null);
  63             } else {
  64                 callback(null, rows[0]);
  65             }
  66         });
  67     },
  68
  69     /**
  70      * Searches for a channel
  71      */
  72     search: function (name, callback) {
  73         if (typeof callback !== "function") {
  74             return;
  75         }
  76
  77         db.query("SELECT * FROM `channels` WHERE name LIKE ?",
  78                      ["%" + name + "%"],
  79                      function (err, rows) {
  80             if (err) {
  81                 callback(err, null);
  82                 return;
  83             }
  84             callback(null, rows);
  85         });
  86     },
  87
  88     /**
  89      * Searches for a channel by owner
  90      */
  91     searchOwner: function (name, callback) {
  92         if (typeof callback !== "function") {
  93             return;
  94         }
  95
  96         db.query("SELECT * FROM `channels` WHERE owner LIKE ?",
  97                      ["%" + name + "%"],
  98                      function (err, rows) {
  99             if (err) {
 100                 callback(err, null);
 101                 return;
 102             }
 103             callback(null, rows);
 104         });
 105     },
 106
 107     /**
 108      * Validates and registers a new channel
 109      */
 110     register: function (name, owner, callback) {
 111         if (typeof callback !== "function") {
 112             callback = blackHole;
 113         }
 114
 115         if (typeof name !== "string" || typeof owner !== "string") {
 116             callback("Name and owner are required for channel registration", null);
 117             return;
 118         }
 119
 120         if (!valid(name)) {
 121             callback("Invalid channel name.  Channel names may consist of 1-30 " +
 122                      "characters a-z, A-Z, 0-9, -, and _", null);
 123             return;
 124         }
 125
 126         module.exports.isChannelTaken(name, function (err, taken) {
 127             if (err) {
 128                 callback(err, null);
 129                 return;
 130             }
 131
 132             if (taken) {
 133                 callback("Channel name " + name + " is already taken", null);
 134                 return;
 135             }
 136
 137             db.query("INSERT INTO `channels` " +
 138                      "(`name`, `owner`, `time`, `last_loaded`) VALUES (?, ?, ?, ?)",
 139                      [name, owner, Date.now(), new Date()],
 140                      function (err, _res) {
 141                 if (err) {
 142                     callback(err, null);
 143                     return;
 144                 }
 145
 146                 db.users.getGlobalRank(owner, function (err, rank) {
 147                     if (err) {
 148                         callback(err, null);
 149                         return;
 150                     }
 151
 152                     rank = Math.max(rank, 5);
 153
 154                     module.exports.setRank(name, owner, rank, function (err) {
 155                         if (err) {
 156                             callback(err, null);
 157                             return;
 158                         }
 159
 160                         callback(null, { name: name });
 161                     });
 162                 });
 163             });
 164         });
 165     },
 166
 167     /**
 168      * Unregisters a channel
 169      */
 170     drop: function (name, callback) {
 171         if (typeof callback !== "function") {
 172             callback = blackHole;
 173         }
 174
 175         if (!valid(name)) {
 176             callback("Invalid channel name", null);
 177             return;
 178         }
 179
 180         db.query("DELETE FROM `channels` WHERE name=?", [name], function (err) {
 181
 182             module.exports.deleteBans(name, function (err) {
 183                 if (err) {
 184                     LOGGER.error("Failed to delete bans for " + name + ": " + err);
 185                 }
 186             });
 187
 188             module.exports.deleteLibrary(name, function (err) {
 189                 if (err) {
 190                     LOGGER.error("Failed to delete library for " + name + ": " + err);
 191                 }
 192             });
 193
 194             module.exports.deleteAllRanks(name, function (err) {
 195                 if (err) {
 196                     LOGGER.error("Failed to delete ranks for " + name + ": " + err);
 197                 }
 198             });
 199
 200             callback(err, !err);
 201         });
 202     },
 203
 204     /**
 205      * Looks up channels registered by a given user
 206      */
 207     listUserChannels: function (owner, callback) {
 208         if (typeof callback !== "function") {
 209             return;
 210         }
 211
 212         db.query("SELECT * FROM `channels` WHERE owner=?", [owner],
 213         function (err, res) {
 214             if (err) {
 215                 callback(err, []);
 216                 return;
 217             }
 218
 219             callback(err, res);
 220         });
 221     },
 222
 223     listUserChannelsAsync: owner => {
 224         return new Promise((resolve, reject) => {
 225             module.exports.listUserChannels(owner, (error, rows) => {
 226                 if (error) {
 227                     reject(error);
 228                 } else {
 229                     resolve(rows);
 230                 }
 231             });
 232         });
 233     },
 234
 235     /**
 236      * Loads the channel from the database
 237      */
 238     load: function (chan, callback) {
 239         if (typeof callback !== "function") {
 240             callback = blackHole;
 241         }
 242
 243         if (!valid(chan.name)) {
 244             callback("Invalid channel name", null);
 245             return;
 246         }
 247
 248         db.query("SELECT * FROM `channels` WHERE name=?", chan.name, function (err, res) {
 249             if (err) {
 250                 callback(err, null);
 251                 return;
 252             }
 253
 254             if (res.length === 0) {
 255                 callback("Channel is not registered", null);
 256                 return;
 257             }
 258
 259             if (chan.dead) {
 260                 callback("Channel is dead", null);
 261                 return;
 262             }
 263
 264             // Note that before this line, chan.name might have a different capitalization
 265             // than the database has stored.  Update accordingly.
 266             chan.name = res[0].name;
 267             chan.uniqueName = chan.name.toLowerCase();
 268             chan.id = res[0].id;
 269             chan.ownerName = typeof res[0].owner === 'string' ? res[0].owner.toLowerCase() : null;
 270             chan.setFlag(Flags.C_REGISTERED);
 271             chan.logger.log("[init] Loaded channel from database");
 272             callback(null, true);
 273         });
 274     },
 275
 276     /**
 277      * Looks up a user's rank
 278      */
 279     getRank: function (chan, name, callback) {
 280         if (typeof callback !== "function") {
 281             return;
 282         }
 283
 284         if (!valid(chan)) {
 285             callback("Invalid channel name", null);
 286             return;
 287         }
 288
 289         db.query("SELECT * FROM `channel_ranks` WHERE name=? AND channel=?",
 290                  [name, chan],
 291         function (err, rows) {
 292             if (err) {
 293                 callback(err, -1);
 294                 return;
 295             }
 296
 297             if (rows.length === 0) {
 298                 callback(null, 1);
 299                 return;
 300             }
 301
 302             callback(null, rows[0].rank);
 303         });
 304     },
 305
 306     /**
 307      * Looks up multiple users' ranks at once
 308      */
 309     getRanks: function (chan, names, callback) {
 310         if (typeof callback !== "function") {
 311             return;
 312         }
 313
 314         if (!valid(chan)) {
 315             callback("Invalid channel name", null);
 316             return;
 317         }
 318
 319         var replace = "(" + names.map(function () { return "?"; }).join(",") + ")";
 320
 321         /* Last substitution is the channel to select ranks for */
 322         const sub = names.concat([chan]);
 323
 324         db.query("SELECT * FROM `channel_ranks` WHERE name IN " +
 325                  replace + " AND channel=?", sub,
 326         function (err, rows) {
 327             if (err) {
 328                 callback(err, []);
 329                 return;
 330             }
 331
 332             callback(null, rows.map(function (r) { return r.rank; }));
 333         });
 334     },
 335
 336     /**
 337      * Query all user ranks at once
 338      */
 339     allRanks: function (chan, callback) {
 340         if (typeof callback !== "function") {
 341             return;
 342         }
 343
 344         if (!valid(chan)) {
 345             callback("Invalid channel name", null);
 346             return;
 347         }
 348
 349         db.query("SELECT * FROM `channel_ranks` WHERE channel=?", [chan], callback);
 350     },
 351
 352     /**
 353      * Updates a user's rank
 354      */
 355     setRank: function (chan, name, rank, callback) {
 356         if (typeof callback !== "function") {
 357             callback = blackHole;
 358         }
 359
 360         if (rank < 2) {
 361             module.exports.deleteRank(chan, name, callback);
 362             return;
 363         }
 364
 365         if (!valid(chan)) {
 366             callback("Invalid channel name", null);
 367             return;
 368         }
 369
 370         db.query("INSERT INTO `channel_ranks` VALUES (?, ?, ?) " +
 371                  "ON DUPLICATE KEY UPDATE `rank`=?",
 372                  [name, rank, chan, rank], callback);
 373     },
 374
 375     /**
 376      * Removes a user's rank entry
 377      */
 378     deleteRank: function (chan, name, callback) {
 379         if (typeof callback !== "function") {
 380             callback = blackHole;
 381         }
 382
 383         if (!valid(chan)) {
 384             callback("Invalid channel name", null);
 385             return;
 386         }
 387
 388         db.query("DELETE FROM `channel_ranks` WHERE name=? AND channel=?", [name, chan],
 389             callback);
 390     },
 391
 392     /**
 393      * Removes all ranks for a channel
 394      */
 395     deleteAllRanks: function (chan, callback) {
 396         if (typeof callback !== "function") {
 397             callback = blackHole;
 398         }
 399
 400         if (!valid(chan)) {
 401             callback("Invalid channel name", null);
 402             return;
 403         }
 404
 405         db.query("DELETE FROM `channel_ranks` WHERE channel=?", [chan], callback);
 406     },
 407
 408     /**
 409      * Adds a media item to the library
 410      */
 411     addToLibrary: function (chan, media, callback) {
 412         if (typeof callback !== "function") {
 413             callback = blackHole;
 414         }
 415
 416         if (!valid(chan)) {
 417             callback("Invalid channel name", null);
 418             return;
 419         }
 420
 421         var meta = JSON.stringify({
 422             bitrate: media.meta.bitrate,
 423             codec: media.meta.codec,
 424             scuri: media.meta.scuri,
 425             embed: media.meta.embed,
 426             direct: media.meta.direct
 427         });
 428
 429         db.query("INSERT INTO `channel_libraries` " +
 430                  "(id, title, seconds, type, meta, channel) " +
 431                  "VALUES (?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE id=id",
 432                  [media.id, media.title, media.seconds, media.type, meta, chan], callback);
 433     },
 434
 435     /**
 436      * Adds a list of media items to the library
 437      */
 438     addListToLibrary: async function addListToLibrary(chan, list) {
 439         if (!valid(chan)) {
 440             throw new Error("Invalid channel name");
 441         }
 442
 443         if (list.length > Config.get("playlist.max-items")) {
 444             throw new Error("Cannot save list to library: exceeds max-items");
 445         }
 446
 447         const items = list.map(item => ({
 448             id: item.id,
 449             title: item.title,
 450             seconds: item.seconds,
 451             type: item.type,
 452             meta: JSON.stringify({
 453                 bitrate: item.meta.bitrate,
 454                 codec: item.meta.codec,
 455                 scuri: item.meta.scuri,
 456                 embed: item.meta.embed,
 457                 direct: item.meta.direct
 458             }),
 459             channel: chan
 460         }));
 461
 462         await db.getDB().runTransaction(tx => {
 463             const insert = tx.table('channel_libraries')
 464                     .insert(items);
 465
 466             const update = tx.raw(createMySQLDuplicateKeyUpdate(
 467                     ['title', 'seconds', 'meta']
 468             ));
 469
 470             return tx.raw(insert.toString() + update.toString());
 471         });
 472     },
 473
 474     /**
 475      * Retrieves a media item from the library by id
 476      */
 477     getLibraryItem: function (chan, id, callback) {
 478         if (typeof callback !== "function") {
 479             return;
 480         }
 481
 482         if (!valid(chan)) {
 483             callback("Invalid channel name", null);
 484             return;
 485         }
 486
 487         db.query("SELECT * FROM `channel_libraries` WHERE id=? AND channel=?", [id, chan],
 488         function (err, rows) {
 489             if (err) {
 490                 callback(err, null);
 491                 return;
 492             }
 493
 494             if (rows.length === 0) {
 495                 callback("Item not in library", null);
 496             } else {
 497                 callback(null, rows[0]);
 498             }
 499         });
 500     },
 501
 502     /**
 503      * Search the library by title
 504      */
 505     searchLibrary: function (chan, search, callback) {
 506         if (typeof callback !== "function") {
 507             return;
 508         }
 509
 510         db.query("SELECT * FROM `channel_libraries` WHERE title LIKE ? AND channel=?",
 511                  ["%" + search + "%", chan], callback);
 512     },
 513
 514     /**
 515      * Deletes a media item from the library
 516      */
 517     deleteFromLibrary: function (chan, id, callback) {
 518         if (typeof callback !== "function") {
 519             callback = blackHole;
 520         }
 521
 522         if (!valid(chan)) {
 523             callback("Invalid channel name", null);
 524             return;
 525         }
 526
 527         db.query("DELETE FROM `channel_libraries` WHERE id=? AND channel=?",
 528             [id, chan], callback);
 529     },
 530
 531     /**
 532      * Deletes all library entries for a channel
 533      */
 534     deleteLibrary: function (chan, callback) {
 535         if (typeof callback !== "function") {
 536             callback = blackHole;
 537         }
 538
 539         if (!valid(chan)) {
 540             callback("Invalid channel name", null);
 541             return;
 542         }
 543
 544         db.query("DELETE FROM `channel_libraries` WHERE channel=?", [chan], callback);
 545     },
 546
 547     /**
 548      * Add a ban to the banlist
 549      */
 550     ban: function (chan, ip, name, note, bannedby, callback) {
 551         if (typeof callback !== "function") {
 552             callback = blackHole;
 553         }
 554
 555         if (!valid(chan)) {
 556             callback("Invalid channel name", null);
 557             return;
 558         }
 559
 560         db.query("INSERT INTO `channel_bans` (ip, name, reason, bannedby, channel) " +
 561                  "VALUES (?, ?, ?, ?, ?)",
 562             [ip, name, note, bannedby, chan], callback);
 563     },
 564
 565     /**
 566      * Check if an IP address or range is banned
 567      */
 568     isIPBanned: function (chan, ip, callback) {
 569         if (typeof callback !== "function") {
 570             return;
 571         }
 572
 573         if (!valid(chan)) {
 574             callback("Invalid channel name", null);
 575             return;
 576         }
 577
 578         var range = util.getIPRange(ip);
 579         var wrange = util.getWideIPRange(ip);
 580
 581         db.query("SELECT * FROM `channel_bans` WHERE ip IN (?, ?, ?) AND channel=?",
 582         [ip, range, wrange, chan],
 583         function (err, rows) {
 584             callback(err, err ? false : rows.length > 0);
 585         });
 586     },
 587
 588     /**
 589      * Check if a username is banned
 590      */
 591     isNameBanned: function (chan, name, callback) {
 592         if (typeof callback !== "function") {
 593             return;
 594         }
 595
 596         if (!valid(chan)) {
 597             callback("Invalid channel name", null);
 598             return;
 599         }
 600
 601         db.query("SELECT * FROM `channel_bans` WHERE name=? AND channel=?", [name, chan],
 602         function (err, rows) {
 603             callback(err, err ? false : rows.length > 0);
 604         });
 605     },
 606
 607     /**
 608      * Check if a user's name or IP is banned
 609      */
 610     isBanned: function (chan, ip, name, callback) {
 611         if (typeof callback !== "function") {
 612             return;
 613         }
 614
 615         if (!valid(chan)) {
 616             callback("Invalid channel name", null);
 617             return;
 618         }
 619
 620         var range = util.getIPRange(ip);
 621         var wrange = util.getWideIPRange(ip);
 622
 623         db.query("SELECT COUNT(1) AS count FROM `channel_bans` WHERE (ip IN (?, ?, ?) OR name=?) AND channel=?",
 624         [ip, range, wrange, name, chan],
 625         function (err, rows) {
 626             callback(err, err ? false : rows.length > 0 && rows[0].count > 0);
 627         });
 628     },
 629
 630     /**
 631      * Lists all bans
 632      */
 633     listBans: function (chan, callback) {
 634         if (typeof callback !== "function") {
 635             return;
 636         }
 637
 638         if (!valid(chan)) {
 639             callback("Invalid channel name", null);
 640             return;
 641         }
 642
 643         db.query("SELECT * FROM `channel_bans` WHERE channel=?", [chan], callback);
 644     },
 645
 646     /**
 647      * Removes a ban from the banlist
 648      */
 649     unbanId: function (chan, id, callback) {
 650         if (typeof callback !== "function") {
 651             callback = blackHole;
 652         }
 653
 654         if (!valid(chan)) {
 655             callback("Invalid channel name", null);
 656             return;
 657         }
 658
 659         db.query("DELETE FROM `channel_bans` WHERE id=? AND channel=?",
 660                  [id, chan], callback);
 661     },
 662
 663     /**
 664      * Removes all bans from a channel
 665      */
 666     deleteBans: function (chan, id, callback) {
 667         if (typeof callback !== "function") {
 668             callback = blackHole;
 669         }
 670
 671         if (!valid(chan)) {
 672             callback("Invalid channel name", null);
 673             return;
 674         }
 675
 676         db.query("DELETE FROM `channel_bans` WHERE channel=?", [chan], callback);
 677     },
 678
 679     /**
 680      * Updates the `last_loaded` column to be the current timestamp
 681      */
 682     updateLastLoaded: function updateLastLoaded(channelId) {
 683         if (channelId <= 0) {
 684             return;
 685         }
 686
 687         db.query("UPDATE channels SET last_loaded = ? WHERE id = ?", [new Date(), channelId], error => {
 688             if (error) {
 689                 LOGGER.error(`Failed to update last_loaded column for channel ID ${channelId}: ${error}`);
 690             }
 691         });
 692     },
 693
 694     /**
 695      * Updates the `owner_last_seen` column to be the current timestamp
 696      */
 697     updateOwnerLastSeen: function updateOwnerLastSeen(channelId) {
 698         if (channelId <= 0) {
 699             return;
 700         }
 701
 702         db.query("UPDATE channels SET owner_last_seen = ? WHERE id = ?", [new Date(), channelId], error => {
 703             if (error) {
 704                 LOGGER.error(`Failed to update owner_last_seen column for channel ID ${channelId}: ${error}`);
 705             }
 706         });
 707     }
 708 };