Finished enqueue feature

PascalKrieg · PascalKrieg · commit 57c7cbbfa13c · 2020-11-28T23:20:04.000+01:00
diff --git a/bot/src/controller/commandHandler.ts b/bot/src/controller/commandHandler.ts
@@ -7,25 +7,34 @@ import { SpotifyAPI } from "../model/spotifyApi";
 import { getTrackURIFromLink,  isSpotifyURL} from "../model/spotifyLinkUtil"
 
 import * as Logging  from '../logging';
+import { url } from "inspector";
 
 export class CommandHandler {
     readonly commandPrefix = "$";
+    readonly ignorePrefix = "//"
     repository : Repository;
     spotifyApi : SpotifyAPI;
-    logger = Logging.buildLogger("httpsController");
+    logger = Logging.buildLogger("commandHandler");
 
     constructor(repository : Repository, spotifyApi : SpotifyAPI) {
         this.repository = repository;
         this.spotifyApi = spotifyApi;
     }
 
     handleCommand = async (message : Message) => {
+        if (message.content.startsWith(this.ignorePrefix)) {
+            return;
+        }
+
+        this.logger.verbose("Read message in channel " + message.channel.id);
         try {
+            if(await this.repository.isChannelPartyChannel(message.channel.id)){
+                this.logger.verbose("Handling party channel message: " + message.content);
+                this.handlePartyChannelCommand(message);
+            }
             if (this.isMessageBotCommand(message)) {
                 this.handleBotCommand(message);
-                if(await this.repository.isChannelPartyChannel(message.channel.id)){
-                    this.handlePartyChannelCommand(message);
-                }
+                
             }
         } catch(err) {
             this.logger.error(err);
@@ -37,15 +46,25 @@ export class CommandHandler {
     }
 
     async handlePartyChannelCommand(message: Message) {
-        let owner = await this.repository.getPartyChannelOwner(message.channel.id);
-        let commandParts = this.seperateCommandParts(message.content);
-        let urls = commandParts.parameters.filter((value) => isSpotifyURL(value));
-        if (urls.length == 0)
-            return;
+        try {
+            let owner = await this.repository.getPartyChannelOwner(message.channel.id);
+
+            let urls = message.content.split(" ").filter((value) => isSpotifyURL(value));
+            
+            if (urls.length == 0) {
+                this.logger.verbose("No URLs found in party channel message");
+                return
+            }
 
-        getTrackURIFromLink(urls[0]).then(trackURI => {
-            this.spotifyApi.addToQueue(owner.tokenPair, trackURI);
-        });
+            let trackURI = await getTrackURIFromLink(urls[0]);
+            this.logger.debug(`trackURI ${trackURI} extracted`);
+            this.logger.debug("Attempting to use token with expiration time " + owner.tokenPair.expirationTime)
+            await this.spotifyApi.addToQueue(owner.tokenPair, trackURI);
+        } catch(err) {
+            this.logger.error(err)
+            message.channel.send("// Failed to add song. " + err.message);
+            throw err;
+        }
     }
 
     handleBotCommand(message : Message) {
@@ -67,7 +86,8 @@ export class CommandHandler {
                     break;
             }
         } catch (err) {
-            console.error(err);
+            this.logger.error(err)
+            throw err;
         }
     }
 
diff --git a/bot/src/logging.ts b/bot/src/logging.ts
@@ -8,8 +8,9 @@ const myFormat = printf(( {level, message, label, timestamp} ) => {
 })
 
 export function buildLogger(displayLabel : string) : Logger{
+    let loglevel = process.env.LOGLEVEL ? process.env.LOGLEVEL : 'info'
     return createLogger({
-        level: 'debug',
+        level: loglevel,
         format: combine(
             label({ label: displayLabel }),
             timestamp(),
diff --git a/bot/src/model/commands/createPartyCommand.ts b/bot/src/model/commands/createPartyCommand.ts
@@ -1,20 +1,18 @@
 import { Channel, Guild, GuildCreateChannelOptions, Message, MessageMentions, OverwriteData, User } from "discord.js";
 import { Repository } from "../data/repository";
 
+import * as Logging from "../../logging"
+let logger = Logging.buildLogger("createPartyCommand");
 
 export class CreatePartyCommand {
 
-    guild : Guild;
-    creator : User;
+    message : Message;
     mentions : User[];
     partyChannel : Channel|undefined = undefined;
     repository : Repository;
 
     constructor(message : Message, repository : Repository) {
-        if (!message.guild)
-            throw new Error();
-        this.guild = message.guild;
-        this.creator = message.author;
+        this.message = message;
         this.mentions = this.extractUsers(message.mentions);
         this.repository = repository;
     }
@@ -25,19 +23,27 @@ export class CreatePartyCommand {
 
     private async setupPartyChannel(){
         let channelName = this.createChannelName();
+        logger.debug("Attempting to setup party channel " + channelName)
         let options = this.createOptionsObject();
-        this.partyChannel = await this.guild.channels.create(channelName, options);
-        this.repository.addPartyChannel(this.partyChannel, this.creator);
+        if (this.message.guild == null) {
+            return;
+        }
+        try {
+            this.partyChannel = await this.message.guild.channels.create(channelName, options);
+            this.repository.addPartyChannel(this.partyChannel, this.message.author);
+        } catch(err) {
+            this.printErrorMessage(err);
+        }
     }
 
     private extractUsers(mentions : MessageMentions) : User[] {
         let users : User[] = Array.from(mentions.users.values());
-        users.push(this.creator);
+        users.push(this.message.author);
         return users;
     }
 
     private createChannelName() {
-        let authorName = this.creator.tag.split("#")[0].toLowerCase();
+        let authorName = this.message.author.tag.split("#")[0].toLowerCase();
         let date = new Date();
         let channelName = `${authorName}-${date.getDate()}-${date.getMonth() + 1}`;
         return channelName;
@@ -75,4 +81,8 @@ export class CreatePartyCommand {
         return overwrite;
     }
 
+    private printErrorMessage(err : Error) {
+        this.message.channel.send("Failed to create party channel.\n" + err.message);
+    }
+
 }
diff --git a/bot/src/model/commands/registerMeCommand.ts b/bot/src/model/commands/registerMeCommand.ts
@@ -2,7 +2,7 @@ import { Message } from "discord.js";
 import { Repository } from "../data/repository";
 import { SpotifyAPI } from "../spotifyApi";
 import { Command } from "./command";
-
+import * as crypto from "crypto";
 
 export class RegisterMeCommand implements Command {
     message : Message;
@@ -27,8 +27,7 @@ export class RegisterMeCommand implements Command {
     }
 
     private produceState() : string {
-        let now = new Date();
-        let state = this.message.author.tag + "#" + now.getTime();
+        let state = crypto.randomBytes(8).toString('hex');
         return state;
     }
 }
diff --git a/bot/src/model/data/repositoryImpl.ts b/bot/src/model/data/repositoryImpl.ts
@@ -20,7 +20,8 @@ export class RepositoryImpl implements Repository {
                 user: process.env.MYSQL_USER,
                 password: process.env.MYSQL_PASSWORD,
                 connectionLimit: 5,
-                database: "playback_enq"
+                database: "playback_enq",
+                bigNumberStrings : true
             })
             return this.pool;
         } else {
@@ -53,7 +54,12 @@ export class RepositoryImpl implements Repository {
         let conn;
         try {
             conn = await this.getPool().getConnection();
-            await conn.query("INSERT INTO party_channels VALUES (?, ?, ?)", [channel.id, owner.id, autoDelete]);
+
+            if (autoDelete) {
+                await conn.query("INSERT INTO party_channels VALUES (?, ?, ?)", [channel.id, owner.id, autoDelete]);
+            } else {
+                await conn.query("INSERT INTO party_channels VALUES (?, ?, NULL)", [channel.id, owner.id]);
+            }
             logger.debug(`Successfully added party channel ${channel.id} by ${owner.tag}`)
         } catch(err) {
             logger.error(err)
@@ -83,7 +89,7 @@ export class RepositoryImpl implements Repository {
         let conn;
         try {
             conn = await this.getPool().getConnection();
-            let rows : any[] = await conn.query("SELECT * FROM discord_users WHERE id IN (SELECT id FROM party_channels WHERE party_channels.id = ?)", [channelId]);
+            let rows : any[] = await conn.query("SELECT * FROM discord_users WHERE id IN (SELECT owner_id FROM party_channels WHERE id = ?)", [channelId]);
             if (rows.length === 0) {
                 throw new Error("Channel not found");
             }
@@ -171,7 +177,7 @@ export class RepositoryImpl implements Repository {
         let conn;
         try {
             conn = await this.getPool().getConnection();
-            let result = await conn.query("UPDATE discord_users" + 
+            let result = await conn.query("UPDATE discord_users " + 
                 "SET access_token = ?, refresh_token = ?, token_expiration = ? " + 
                 "WHERE access_token=? AND refresh_token=?", 
                 [oldToken.accessToken, oldToken.refreshToken, oldToken.expirationTime, newToken.accessToken, newToken.refreshToken]);
@@ -330,11 +336,18 @@ export class RepositoryImpl implements Repository {
         try {
             conn = await this.getPool().getConnection();
             await conn.beginTransaction();
-            let userId = await conn.query("SELECT discord_user FROM code_requests WHERE request_id = ?", [requestId])
+            let idResult = await conn.query("SELECT discord_user FROM code_requests WHERE request_id = ?", [requestId]);
+            let userId = idResult[0].discord_user;
             if (userId.length == 0) {
                 throw new Error("Not Found");
             }
-            await conn.query("UPDATE discord_users SET access_token = ?, refresh_token = ?, token_expiration = ? WHERE id = ?", [newToken.accessToken, newToken.refreshToken, newToken.expirationTime, userId]);
+            logger.debug(`Code request with id ${requestId} belongs to user with user id ${userId}`);
+
+            let res = await conn.query("UPDATE discord_users SET access_token = ?, refresh_token = ?, token_expiration = ? WHERE id = ?", [newToken.accessToken, newToken.refreshToken, newToken.expirationTime, userId]);
+            if (res.affectedRows === 0) {
+                logger.error("Update of token pair affected 0 rows!");
+            }
+
             await conn.query("DELETE FROM code_requests WHERE request_id = ?", [requestId]);
             logger.debug(`Successfully finished code request with id ${requestId} and deleted it.`)
             await conn.commit();
diff --git a/bot/src/model/spotifyApi.ts b/bot/src/model/spotifyApi.ts
@@ -28,31 +28,35 @@ export class SpotifyAPI {
     }
 
     async addToQueue(tokenPair : TokenPair, trackURI : string, refreshTokenOnFailure : boolean = true) {
-        logger.verbose("Request to add to Queue started.")
-        this.updateTokenIfExpiringSoon(tokenPair).then(token => {
+        try {
+            logger.verbose("Request to add to Queue started.")
+            let token = await this.updateTokenIfExpiringSoon(tokenPair);
             let options = this.createPostSongOptions(trackURI, token.accessToken);
+            
             request(options, (res) => {
                 res.on("end", () => {
                     if (res.statusCode !== 304) {
                         logger.debug("Add to queue request failed with code " + res.statusCode);
                         throw new Error("Status Code not 304");
+                    } else {
+                        logger.debug("Add to queue request finished with code " + res.statusCode);
                     }
                 })
             }).end();
-        }).catch(err => {
+        } catch(err) {
             if (refreshTokenOnFailure) {
                 logger.verbose("Attempting to refresh token after addToQueue api failure.")
-                this.updateToken(tokenPair).then(newToken => {
-                    this.addToQueue(newToken, trackURI, false)
-                }).catch(err => {throw err});
+                let newToken = await this.updateToken(tokenPair)
+                await this.addToQueue(newToken, trackURI, false)
             }
             throw err;
-        })
+        }
     }
 
     async updateTokenIfExpiringSoon(tokenPair : TokenPair) : Promise<TokenPair> {
         let now = new Date();
         if ((tokenPair.expirationTime.getTime() - now.getTime()) / 1000 < this.minimumTokenTimeRemaining) {
+            logger.verbose("Updated token as it was expiring soon or was already expired.");
             return this.updateToken(tokenPair);
         }
         return tokenPair;
@@ -70,6 +74,7 @@ export class SpotifyAPI {
         try {
             let code = await this.repository.getRequestCodeById(requestId);
             let tokenPair = await this.fetchTokenFromCode(code);
+            logger.debug("Fetched token pair with expiration time " + tokenPair.expirationTime)
             this.repository.finishCodeRequest(requestId, tokenPair);
         } catch (err) {
             logger.error("Error while attempting to fetch token pair from code (requestId: " + requestId + ")");
@@ -80,28 +85,28 @@ export class SpotifyAPI {
     private fetchTokenFromRefresh(tokenPair : TokenPair) : Promise<TokenPair> {
         logger.verbose("Attempting to fetch token pair from refresh token")
         let options = this.createRefreshTokenOptions();
-        let body = `{'grant_type' : 'refresh_token', 'refresh_token':'${tokenPair.refreshToken}', 'redirect_uri':'${encodeURIComponent(this.redirectUri)}', 'client_id:${this.clientId}, 'client_secret:${this.clientSecret}'}`;
-        return this.fetchTokenPair(options, body);
+        let body = `grant_type=refresh_token&refresh_token=${tokenPair.refreshToken}&redirect_uri=${encodeURIComponent(this.redirectUri)}&client_id=${this.clientId}&client_secret=${this.clientSecret}`;
+        return this.fetchTokenPair(options, body, tokenPair);
     }
 
     private fetchTokenFromCode(code : string) : Promise<TokenPair> {
         let options = this.createFetchFromCodeOptions();
-        let body = `{'grant_type' : 'authorization_code', 'code' : '${code}', 'redirect_uri':' ${ encodeURIComponent(this.redirectUri)}, 'client_id:${this.clientId}, 'client_secret:${this.clientSecret}'}`
+        let body = `grant_type=authorization_code&code=${code}&redirect_uri=${encodeURIComponent(this.redirectUri)}&client_id=${this.clientId}&client_secret=${this.clientSecret}`
         return this.fetchTokenPair(options, body);
     }
 
-    private fetchTokenPair(requestOptions : RequestOptions, body : string) : Promise<TokenPair>{
+    private fetchTokenPair(requestOptions : RequestOptions, body : string, oldToken? : TokenPair) : Promise<TokenPair>{
         return new Promise((resolve, reject) => {
             let data = ""
-            logger.debug("Making spotify api request:\nBody: " + body + "\nOptions: " + JSON.stringify(requestOptions))
+            logger.debug("Making spotify api token fetch request");
             request(requestOptions, (res) => {
                 res.on('data', (chunk) => {
                     data += chunk;
                 });
 
                 res.on('end', () => {
                     if (res.statusCode === 200) {
-                        let tokenPair = this.createTokenPairFromResponse(data);
+                        let tokenPair = this.createTokenPairFromResponse(data, oldToken);
                         resolve(tokenPair);
                     } else {
                         reject(new Error(data));
@@ -124,6 +129,7 @@ export class SpotifyAPI {
             method : "POST",
             headers : {
                 "Accept" : "Application/json",
+                "Content-Type" : "application/x-www-form-urlencoded"
             }
         }
     }
@@ -137,6 +143,7 @@ export class SpotifyAPI {
             method : "POST",
             headers : {
                 "Accept" : "Application/json",
+                "Content-Type" : "application/x-www-form-urlencoded"
             }
         }
     }
@@ -148,20 +155,22 @@ export class SpotifyAPI {
             path : `/v1/me/player/queue?uri=${trackURI}`,
             method : "POST",
             headers : {
-                "Authorization" : `Bearer ${access_token}`,
+                "Authorization" : `Bearer ${access_token}`
             }
         }
     }
 
-    private createTokenPairFromResponse(response : string) : TokenPair {
+    private createTokenPairFromResponse(response : string, oldTokenPair? : TokenPair) : TokenPair {
         let responseObject = JSON.parse(response);
         
-        if (!responseObject.access_token || !responseObject.token_type || !responseObject.scope || !responseObject.expires_in || !responseObject.refresh_token)
+        if (!responseObject.access_token || !responseObject.token_type || !responseObject.scope || !responseObject.expires_in)
             throw new Error("Not all information received");
         
         let now = new Date();
         let expiration = new Date((new Date()).setSeconds(now.getSeconds() + parseInt(responseObject.expires_in)));
         
-        return new TokenPair(responseObject.access_token, responseObject.refresh_token, expiration);
+        let refreshToken = responseObject.refresh_token ? responseObject.refresh_token : oldTokenPair?.refreshToken;
+
+        return new TokenPair(responseObject.access_token, refreshToken, expiration);
     }
 }
diff --git a/bot/src/model/spotifyLinkUtil.ts b/bot/src/model/spotifyLinkUtil.ts
diff --git a/registration/src/index.js b/registration/src/index.js

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ import { Message } from "discord.js";`
`2`	`2`	`import { Repository } from "../data/repository";`
`3`	`3`	`import { SpotifyAPI } from "../spotifyApi";`
`4`	`4`	`import { Command } from "./command";`
`5`		`-`
	`5`	`+import * as crypto from "crypto";`
`6`	`6`
`7`	`7`	`export class RegisterMeCommand implements Command {`
`8`	`8`	`message : Message;`
`@@ -27,8 +27,7 @@ export class RegisterMeCommand implements Command {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`private produceState() : string {`
`30`		`- let now = new Date();`
`31`		`- let state = this.message.author.tag + "#" + now.getTime();`
	`30`	`+ let state = crypto.randomBytes(8).toString('hex');`
`32`	`31`	`return state;`
`33`	`32`	`}`
`34`	`33`	`}`