Merge branch 'fixes_shuffle_and_search' of tarfeef101/viki into master

README.md

@@ -1,7 +1,7 @@
 # Viki
 Viki is a bot focused mainly on music streaming. Specifically, streaming from a `beets` music library on the docker host on which the `viki` container is run. Yes, this is a very specific, narrow use case.
 
-## Usage
+## Deployment
 To get this running on your server, other than the normal creation of a bot user stuff on the discord, side, do the following:
 - create `src/config.json` and add:
   - `"token"`, your bot's token
@@ -16,6 +16,48 @@ To get this running on your server, other than the normal creation of a bot user
   - ensure the version of `beets` to be installed is equal or at least compatible with the host's
 - run `docker-compose up --build -d` to run the bot
 
+## Usage
+The bot recognizes commands sent by non-bot users, prepended with the `prefix` character set in the `config.json`. Below is a list of commands the bot recognizes.
+- `ping`
+  - responds to the commands with the one-way and round-trip latency for the bot
+  - e.g. `!ping`
+- `join channelname`
+  - Joins the voice channel named `channelname`
+  - e.g. `!join General`
+- `leave channelname`
+  - Leaves the voice channel named `channelname`
+  - e.g. `!leave General`
+- `price type weapon`
+  - Returns riven price data for the `weapon` of mod type `type`, where `type` is either `rolled` or `unrolled`
+  - e.g. `!price unrolled kuva bramma`
+- `search querytype querystring`
+  - Looks up music in the host DB, and adds responds w/ the results
+  - Valid `querytypes` include `['track', 'title', 'song', 'artist', 'album']`
+  - `querystring` is the actual query, so if `querytype` was `artist`, a valid `querystring` would be `green day`
+- `addmusic querytype querystring`
+  - Looks up music in the host DB, and adds matching songs to the playlist, and starts playing if nothing is playing already
+  - Same argument syntax as `search`
+- `stop`
+  - Stops playback and clears the playlist
+- `next`
+  - Returns the next song in the playlist
+- `previous`
+  - Returns the previous song that was played
+- `playlist`
+  - Returns the contents of the current playlist
+- `pause`
+  - Pauses playback
+- `resume`
+  - Resumes playback
+- `repeat setting`
+  - Sets repeat behaviour to `off`, `one`, or `all`.  The default behaviour of the bot is `off`
+- `skip`
+  - Skips to the next song in the playlist
+- `back`
+  - Goes back to replay the previous song, and adds the song that was playing at the time of the command back onto the front of the playlist
+- `shuffle`
+  - Shuffles the playlist's order
+
 ## Caveats
 - as mentioned above, yes, this is a very narrow use case
 - anyone you whitelist can technically execute arbitrary code in your container (and since there's bind mounts, place code on the host) through `addmusic`. so that's great

src/Queue.js

@@ -71,6 +71,24 @@ class Queue
   {
     this.arr = [];
   }
+
+  // randomizes remaining elements of the Queue
+  shuffle()
+  {
+    function rand(min, max)
+    {
+      return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+
+    for (var i = 0; i < this.arr.length; i++)
+    {
+      // we want a random index between the end and i, inclusive
+      const index = rand(i, this.arr.length - 1);
+      const temp = this.arr[index];
+      this.arr[index] = this.arr[i];
+      this.arr[i] = temp;
+    }
+  }
 }
 
 module.exports = Queue;

src/Queue.js.bad

@@ -1,90 +0,0 @@
-class Queue
-{
-  // initializes the queue
-  constructor()
-  {
-    this.arr = [];
-    this.pos = 0;
-  }
-  
-  // uses the array x to fill the queue
-  makeFilled(x)
-  {
-    this.arr = x;
-    this.pos = 0;
-  }
-
-  // Returns true if the queue is empty, and false otherwise.
-  isEmpty()
-  {
-    return (this.arr.length == 0 || this.pos == (this.arr.length - 1));
-  }
-  
-  getPos()
-  {
-    return this.pos;
-  }
-
-  // Enqueues x in the queue (to the end)
-  enqueue(x)
-  {
-    this.arr.push(x);
-  }
-  
-  // enqueues x to position i
-  insert(x, i)
-  {
-    this.arr.splice(i, 0, x);
-  }
-  
-  // removes item at index i
-  remove(i)
-  {
-    this.arr.splice(i, 1);
-  }
-
-  // Dequeues an item and returns it. If the queue is empty, throws an error
-  dequeue()
-  {
-    // if the queue is empty, throw
-    if (this.arr.length == 0)
-    {
-      throw "Queue empty!";
-    }
-    
-    // if the queue is at the end already, return undefined
-    if (this.pos >= this.arr.length)
-    {
-      return undefined;
-    }
-
-    // store the item at the front of the queue
-    var item = this.arr[this.pos];
-    ++this.pos;
-
-    // return the dequeued item
-    return item;
-  }
-
-  // Returns the item at the front of the queue (without dequeuing it). If the
-  // queue is empty then undefined is returned.
-  peek()
-  {
-    return (this.arr.length > 0 ? this.arr[this.pos] : undefined);
-  }
-  
-  // returns an array of all items in the queue (again, without dequeuing) from the current pos.
-  read()
-  {
-    return this.arr.slice(this.pos);
-  }
-  
-  // Deletes all the data, resets to as on construction
-  reset()
-  {
-    this.arr = [];
-    this.pos = 0;
-  }
-}
-
-module.exports = QueueButBad;

src/viki.js

@@ -57,7 +57,6 @@ function play()
   }
 
   dispatcher = connection.play(nextSong[0]);
-  console.log(`Playing ${nextSong[2]}.`);
   nextSong[1].channel.send(`Playing ${nextSong[2]}.`);
   dispatcher.setVolume(0.2);
   dispatcher.setBitrate(96);
@@ -76,7 +75,6 @@ function play()
         playlist.makeFilled(played);
         played = [];
         play();
-        console.log("Repeat all encountered.");
       }
       else
       {
@@ -156,14 +154,16 @@ client.on("guildCreate", guild =>
   client.user.setActivity(`Serving ${client.guilds.cache.size} servers`);
 });
 
-client.on("guildDelete", guild => {
+client.on("guildDelete", guild =>
+{
   // this event triggers when the bot is removed from a guild.
   console.log(`I have been removed from: ${guild.name} (id: ${guild.id})`);
   client.user.setActivity("Taking Over Chicago");
 });
 
 
-client.on('message', async msg => {
+client.on('message', async msg => 
+{
   // Ignores bot msgs
   if (msg.author.bot) return;
   
@@ -177,331 +177,372 @@ client.on('message', async msg => {
   const args = msg.content.slice(config.prefix.length).trim().split(/ +/g);
   const command = args.shift().toLowerCase();
 
-  if (command === 'ping')
+  switch (command)
   {
-    const m = await msg.channel.send('pong');
-    m.edit(`Pong! Latency is ${m.createdTimestamp - msg.createdTimestamp}ms. API Latency is ${Math.round(client.ws.ping)}ms`);
-  }
+    // respond w/ bot latency
+    case 'ping':
+      var m = await msg.channel.send('pong');
+      m.edit(`Pong! Latency is ${m.createdTimestamp - msg.createdTimestamp}ms. API Latency is ${Math.round(client.ws.ping)}ms`);
+      break;
+
+    // join the specified void channel
+    case 'join':
+      var channelName = args.join(' ');
+      var channel = msg.guild.channels.cache.find(each => each.name === channelName && each.type === "voice");
+
+      if (channel)
+      {
+        channel.join().then(conn =>
+        {
+          connection = conn;
+        }).catch(console.error);
+      }
+      else
+      {
+        msg.reply(`Sorry ${msg.author.username}, that channel doesn't appear to exist.`);
+      }
+      break;
 
-  if (command === 'join')
-  {
-    const channelName = args.join(' ');
-    const channel = msg.guild.channels.cache.find(each => each.name === channelName && each.type === "voice");
+    // leave the specified voice channel
+    case 'leave':
+      var channelName = args.join(' ');
+      var channel = msg.guild.channels.cache.find(each => each.name === channelName && each.type === "voice");
 
-    if (channel)
-    {
-      channel.join().then(conn =>
+      if (channel)
       {
-        connection = conn;
-      }).catch(console.error);
-    }
-    else
-    {
-      msg.reply(`Sorry ${msg.author.username}, that channel doesn't appear to exist.`);
-    }
-  }
+        channel.leave();
+      }
+      else
+      {
+        msg.reply(`Sorry ${msg.author.username}, that channel doesn't appear to exist.`);
+      }
+      break;
 
-  if (command === 'leave')
-  {
-    const channelName = args.join(' ');
-    const channel = msg.guild.channels.cache.find(each => each.name === channelName && each.type === "voice");
+    // return the price of a riven for the specified weapon
+    case 'price':
+      // parse args 
+      var type = args[0];
+      args.splice(0, 1);
+      var query = args.join(' ');
+      query = query.toUpperCase();
 
-    if (channel)
-    {
-      channel.leave();
-    }
-    else
-    {
-      msg.reply(`Sorry ${msg.author.username}, that channel doesn't appear to exist.`);
-    }
-  }
+      // check cache freshness
+      delta = (new Date().getTime() / 1000) - cacheTime;
+      if (delta > 3600) updateRivens();
 
-  if (command === "prices")
-  {
-    // parse args 
-    var type = args[0];
-    args.splice(0, 1);
-    var query = args.join(' ');
-    query = query.toUpperCase();
-   
-    // check cache freshness
-    delta = (new Date().getTime() / 1000) - cacheTime;
-    if (delta > 3600) updateRivens();
- 
-    if (type == "rolled")
-    {
-      var result = rolledStats.get(query);
-      if (!(result))
+      if (type == "rolled")
       {
-        return msg.channel.send("Sorry, I couldn't find that weapon. Please check your message and try again.");
+        var result = rolledStats.get(query);
+        if (!(result))
+        {
+          return msg.channel.send("Sorry, I couldn't find that weapon. Please check your message and try again.");
+        }
+        result = JSON.stringify(result, undefined, 2);
+        return msg.channel.send(result);
       }
-      result = JSON.stringify(result, undefined, 2);
-      return msg.channel.send(result);
-    }
-    else if (type == "unrolled")
-    {
-      var result = unrolledStats.get(query);
-      if (!(result))
+      else if (type == "unrolled")
       {
-        return msg.channel.send("Sorry, I couldn't find that weapon. Please check your message and try again.");
+        var result = unrolledStats.get(query);
+        if (!(result))
+        {
+          return msg.channel.send("Sorry, I couldn't find that weapon. Please check your message and try again.");
+        }
+        result = JSON.stringify(result, undefined, 2);
+        return msg.channel.send(result);
       }
-      result = JSON.stringify(result, undefined, 2);
-      return msg.channel.send(result);
-    }
-    else
-    {
-      return msg.channel.send("Sorry, please enter a command in the form: prices unrolled/rolled [weapon_name]");
-    }
-  }
+      else
+      {
+        return msg.channel.send("Sorry, please enter a command in the form: price unrolled/rolled [weapon_name]");
+      }
+      break;
 
-  if (command === "addmusic") // adds songs to queue, starts playback if none already
-  {
-    if (!(config.whitelist.includes(msg.author.tag)))
-    {
-      return msg.channel.send("Sorry, you're not allowed to run this command. Please contact the server owner to acquire that permission.")
-    }
+    // searches the DB for songs matching the user query, and responds w/ that info in chat
+    case 'search':
+      if (!(config.whitelist.includes(msg.author.tag)))
+      {
+        return msg.channel.send("Sorry, you're not allowed to run this command. Please contact the server owner to acquire that permission.")
+      }
 
-    if (!connection)
-    {
-      return msg.channel.send("Please add me to a voice channel before adding music.")
-    }
+      var type = args[0];
+      if (!(musicTypes.includes(type)))
+      {
+        return msg.channel.send("Sorry, that is not a valid command. Please enter something from: " + musicTypesString);
+      }
+      if (type == 'song' || type == 'track') type = 'title'; // account for poor beets API
+      args.splice(0, 1);
+      var query = args.join(' '); // creates a single string of all args (the query)
+      var path; // this will hold the filepaths from our query
+      exec(`beet ls ${type}:${query}`, function (error, stdout, stderr)
+      {
+        if (error)
+        {
+          return msg.channel.send(`Sorry, I encountered an issue looking for that: ${error}`);
+        }
+        else if (stdout === '\n' || stdout === '' || stdout === undefined)
+        {
+          return msg.channel.send('There were no results that matched your search. Please give the type and name of your query (e.g. song songname, album albumname...)');
+        }
+        else
+        {
+          var result = 'Results:\n';
+          result += stdout.trim();
+          msg.channel.send(result);
+        }
+      });
+      break;
 
-    var type = args[0];
-    if (!(musicTypes.includes(type)))
-    {
-      return msg.channel.send("Sorry, that is not a valid command. Please enter something from: " + musicTypesString);
-    }
-    if (type == 'song' || type == 'track') type = 'title'; // account for poor beets API
-    args.splice(0, 1);
-    const query = args.join(' '); // creates a single string of all args (the query)
-    var path; // this will hold the filepaths from our query
-    exec(`beet ls -p ${type}:${query} | wc -l`, function (error, stdout, stderr)
-    {
-      if (error)
+    // add the songs returned by the user query to the playlist, start if nothing playing
+    case 'addmusic':
+      if (!(config.whitelist.includes(msg.author.tag)))
       {
-        return msg.channel.send(`Sorry, I encountered an issue looking for that: ${error}`);
+        return msg.channel.send("Sorry, you're not allowed to run this command. Please contact the server owner to acquire that permission.")
       }
-      else if (stdout === '\n' || stdout === '' || stdout === undefined)
+
+      if (!connection)
       {
-        return msg.channel.send(`There were no results that matched your search. Please give the type and name of your query (e.g. song songname, album albumname...)`);
+        return msg.channel.send("Please add me to a voice channel before adding music.")
       }
-      else
-      {  
-        exec(`beet ls -p ${type}:${query}`, function (error, stdout, stderr)
+
+      var type = args[0];
+      if (!(musicTypes.includes(type)))
+      {
+        return msg.channel.send("Sorry, that is not a valid command. Please enter something from: " + musicTypesString);
+      }
+      if (type == 'song' || type == 'track') type = 'title'; // account for poor beets API
+      args.splice(0, 1);
+      query = args.join(' '); // creates a single string of all args (the query)
+      var path; // this will hold the filepaths from our query
+      exec(`beet ls -p ${type}:${query} | wc -l`, function (error, stdout, stderr)
+      {
+        if (error)
         {
-          if (error)
-          {
-            return msg.channel.send(`Sorry, I encountered an issue looking for that: ${error}`);
-          }
-          else
+          return msg.channel.send(`Sorry, I encountered an issue looking for that: ${error}`);
+        }
+        else if (stdout === '\n' || stdout === '' || stdout === undefined)
+        {
+          return msg.channel.send(`There were no results that matched your search. Please give the type and name of your query (e.g. song songname, album albumname...)`);
+        }
+        else
+        {  
+          exec(`beet ls -p ${type}:${query}`, function (error, stdout, stderr)
           {
-            path = stdout.trim();
-            path = path.split("\n"); // now an array of paths (with spaces)
-            
-            // for each song, get the path and readable info, send to queue
-            for (var i = 0; i < path.length; i++)
+            if (error)
+            {
+              return msg.channel.send(`Sorry, I encountered an issue looking for that: ${error}`);
+            }
+            else
             {
-              let filepathRaw = path[i];
-              path[i] = path[i].replaceAll(" ", "\\ ");
-              path[i] = path[i].replaceAll("'", "\\'");
-              path[i] = path[i].replaceAll("&", "\\\46");
-              path[i] = path[i].replaceAll("(", "\\(");
-              path[i] = path[i].replaceAll(")", "\\)");
-              let filepath = path[i]; // path[i] descoped in callback
-
-              exec(`beet ls ${path[i]}`, function (error, stdouts, stderr)
+              path = stdout.trim();
+              path = path.split("\n"); // now an array of paths (with spaces)
+
+              // for each song, get the path and readable info, send to queue
+              for (var i = 0; i < path.length; i++)
               {
-                if (error)
-                {
-                  return msg.channel.send(`Sorry, I encountered an issue looking for song ${i}: ${error}`);
-                }
-                else
+                let filepathRaw = path[i];
+                path[i] = path[i].replaceAll(" ", "\\ ");
+                path[i] = path[i].replaceAll("'", "\\'");
+                path[i] = path[i].replaceAll("&", "\\\46");
+                path[i] = path[i].replaceAll("(", "\\(");
+                path[i] = path[i].replaceAll(")", "\\)");
+                let filepath = path[i]; // path[i] descoped in callback
+
+                exec(`beet ls ${path[i]}`, function (error, stdouts, stderr)
                 {
-                  stdouts = stdouts.trim();
-                  playlist.enqueue([filepathRaw, msg, stdouts]);
-                  
-                  // check if music is playing, if not start it
-                  if ((!dispatcher || dispatcher.ended || dispatcher.destroyed || dispatcher.writableFinished || dispatcher.writableEnded) && !(playlist.isEmpty()))
+                  if (error)
+                  {
+                    return msg.channel.send(`Sorry, I encountered an issue looking for song ${i}: ${error}`);
+                  }
+                  else
                   {
-                    play();
+                    stdouts = stdouts.trim();
+                    playlist.enqueue([filepathRaw, msg, stdouts]);
+                    
+                    // check if music is playing, if not start it
+                    if ((!dispatcher || dispatcher.ended || dispatcher.destroyed || dispatcher.writableFinished || dispatcher.writableEnded) && !(playlist.isEmpty()))
+                    {
+                      play();
+                    }
                   }
-                }
-              });
+                });
+              }
             }
-          }
-        });
-      }
+          });
+        }
 
-      let amt = stdout.trim();
-      msg.channel.send(`${amt} songs added!`);
-    });
-  }
-  
-  if (command === 'stop') // clears playlist, stops music
-  {
-    playlist.reset();
-    repeatone = false;
-    repeatall = false;
-    played = [];
-    dispatcher.end();
-    console.log("Playback stopped, playlist cleared.");
-    msg.channel.send("Playback stopped, playlist cleared.");
-  }
-  
-  if (command === 'next') // returns next song in playlist, or informs that there is none
-  {
-    if (playlist.isEmpty())
-    {
-      msg.channel.send("The playlist is empty.");
-    }
-    else
-    {
-      const next = playlist.peek();
-      msg.channel.send(`Next song is: ${next[2]}.`);
-    }
-  }
+        let amt = stdout.trim();
+        msg.channel.send(`${amt} songs added!`);
+      });
+      break;
 
-  if (command === 'previous')
-  {
-    if (played.length <= 1)
-    {
-      msg.channel.send("No previous song.");
-    }
-    else
-    {
-      let temp = played.slice(-1).pop();
-      msg.channel.send(`Previous song was: ${temp[2]}`);
-    }
-  }
+    // stops playback
+    case 'stop':
+      playlist.reset();
+      repeatone = false;
+      repeatall = false;
+      played = [];
+      dispatcher.end();
+      console.log("Playback stopped, playlist cleared.");
+      msg.channel.send("Playback stopped, playlist cleared.");
+      break;
+
+    // returns the next song in the playlist
+    case 'next':
+      if (playlist.isEmpty())
+      {
+        msg.channel.send("The playlist is empty.");
+      }
+      else
+      {
+        var next = playlist.peek();
+        msg.channel.send(`Next song is: ${next[2]}.`);
+      }
+      break;
 
-  if (command === 'playlist')
-  {
-    if (playlist.isEmpty())
-    {
-      msg.channel.send("The playlist is empty.");
-    }
-    else
-    {
-      const list = playlist.read();
-      var retstr = ""
-      
-      for (var i = 0; i < list.length; i++)
+    // returns the last song played before the current one
+    case 'previous':
+      if (played.length < 1)
       {
-        retstr += `Song #${i + 1} is: ${list[i][2]}.\n`;
+        msg.channel.send("No previous song.");
       }
-      msg.channel.send(retstr);
-    }
-  }
-  
-  if (command === 'pause') // pauses the dispatcher if playing, or does nothing
-  {
-    dispatcher.pause(true);
-    msg.channel.send("Playback paused.");
-  }
+      else
+      {
+        let temp = played.slice(-1).pop();
+        msg.channel.send(`Previous song was: ${temp[2]}`);
+      }
+      break;
 
-  if (command === 'resume') // resumes the dispatcher, or does nothing
-  {
-    dispatcher.resume();
-    msg.channel.send("Playback resumed.");
-  }
+    // returns the playlist
+    case 'playlist':
+      if (playlist.isEmpty())
+      {
+        msg.channel.send("The playlist is empty.");
+      }
+      else
+      {
+        var list = playlist.read();
+        var retstr = ""
+        
+        for (var i = 0; i < list.length; i++)
+        {
+          retstr += `Song #${i + 1} is: ${list[i][2]}.\n`;
+        }
+        msg.channel.send(retstr);
+      }
+      break;
 
-  if (command === 'repeat')
-  {
-    var param = args[0];
-    
-    if (param === 'one' && cursong)
-    {
-      repeatone = true; // causes play function to repeat current cursong
-      repeatall = false;
-      msg.channel.send(`Repeating ${cursong[2]}.`);
-    }
-    else if (param === 'all') // track playlist, and repeat whole thing once empty
-    {
-      repeatone = false;
-      repeatall = true;
-      msg.channel.send("Repeating playlist.");
-    }
-    else if (param === 'off') // resets repeat variables
-    {
-      repeatone = false;
-      repeatall = false;
-      msg.channel.send("Repeat off.");
-    }
-    else
-    {
-      msg.channel.send("There was nothing to repeat, or an invalid option was given. Valid options are one, all, and off.");
-    }
-  }
+    // pauses the playback
+    case 'pause':
+      dispatcher.pause(true);
+      msg.channel.send("Playback paused.");
+      break;
 
-  if (command === 'skip') // starts playing the next song in the queue if it exists
-  {
-    if (playlist.isEmpty())
-    {
-      msg.channel.send("Sorry, the playlist is empty.");
-    }
-    else
-    {
-      function resolveEnd()
+    // resumes the playback
+    case 'resume':
+      dispatcher.resume();
+      msg.channel.send("Playback resumed.");
+      break;
+
+    // sets repeat behaviour
+    case 'repeat':
+      var param = args[0];
+
+      if (param === 'one' && cursong)
       {
-        return new Promise((success, fail) =>
-        {
-          dispatcher.end();
+        repeatone = true; // causes play function to repeat current cursong
+        repeatall = false;
+        msg.channel.send(`Repeating ${cursong[2]}.`);
+      }
+      else if (param === 'all') // track playlist, and repeat whole thing once empty
+      {
+        repeatone = false;
+        repeatall = true;
+        msg.channel.send("Repeating playlist.");
+      }
+      else if (param === 'off') // resets repeat variables
+      {
+        repeatone = false;
+        repeatall = false;
+        msg.channel.send("Repeat off.");
+      }
+      else
+      {
+        msg.channel.send("There was nothing to repeat, or an invalid option was given. Valid options are one, all, and off.");
+      }
+      break;
 
-          dispatcher.on("finish", () =>
+    // skips to the next song
+    case 'skip':
+      if (playlist.isEmpty())
+      {
+        msg.channel.send("Sorry, the playlist is empty.");
+      }
+      else
+      {
+        function resolveEnd()
+        {
+          return new Promise((success, fail) =>
           {
-            success('Track skipped!');
+            dispatcher.end();
+  
+            dispatcher.on("finish", () =>
+            {
+              success('Track skipped!');
+            });
+  
+            dispatcher.on("error", () =>
+            {
+              fail('Couldn\'t skip :(');
+            });
           });
+        }
 
-          dispatcher.on("error", () =>
-          {
-            fail('Couldn\'t skip :(');
-          });
-        });
+        resolveEnd();
       }
+      break;
 
-      resolveEnd();
-    }
-  }
-
-  if (command === 'back') // if possible, adds cursong to queue at the front, starts playing last song
-  {
-    if (played.length == 0)
-    {
-      msg.channel.send("Sorry, there is no song to skip back to.");
-    }
-    else
-    {
-      function resolveEnd()
+    // goes back 1 song (plays last song, adds cursong back to the queue)
+    case 'back':
+      if (played.length == 0)
       {
-        return new Promise((success, fail) =>
+        msg.channel.send("Sorry, there is no song to skip back to.");
+      }
+      else
+      {
+        function resolveEnd()
         {
-          /*
-          playlist.reset();
-          repeatone = false;
-          repeatall = false;
-          played = [];
-          dispatcher.end();
-          */
-          playlist.cut(cursong); // put cursong back on
-          let tempsong = played[played.length - 1]; // captures the song to go back to
-          played = played.splice(played.length - 1, 1); // removes the last song from played
-          playlist.cut(tempsong); // put old song on the front
-          dispatcher.end(); // stop playing wrong song
-
-          dispatcher.on("finish", () =>
+          return new Promise((success, fail) =>
           {
-            success('Track reversed!');
-          });
+            playlist.insert(cursong, 0); // put cursong back on the front
+            let tempsong = played[played.length - 1]; // captures the song to go back to
+            played = played.splice(played.length - 1, 1); // removes the last song from played
+            playlist.insert(tempsong, 0); // put old song on the front
+            dispatcher.end(); // stop playing wrong song
 
-          dispatcher.on("error", () =>
-          {
-            fail('Couldn\'t skip :(');
+            dispatcher.on("finish", () =>
+            {
+              success('Track reversed!');
+            });
+  
+            dispatcher.on("error", () =>
+            {
+              fail('Couldn\'t skip :(');
+            });
           });
-        });
+        }
+
+        resolveEnd();
       }
+      break;
 
-      resolveEnd();
-    }
+    // shuffles the playlist
+    case 'shuffle':
+      playlist.shuffle();
+      msg.channel.send('Done!');
+      break;
+
+    // respond w/ error if command not recognized
+    default:
+      msg.channel.send("Sorry, that command isn't recognized.");
   }
 });