Added a debug API call for fixing a station-skip issue

backend/logic/api.js

@@ -1,5 +1,8 @@
 const CoreClass = require("../core.js");
 
+const async = require("async");
+const crypto = require("crypto");
+
 class APIModule extends CoreClass {
     constructor() {
         super("api");
@@ -7,11 +10,15 @@ class APIModule extends CoreClass {
 
     initialize() {
         return new Promise((resolve, reject) => {
-            const app = this.moduleManager.modules["app"];
+            this.app = this.moduleManager.modules["app"];
+            this.stations = this.moduleManager.modules["stations"];
+            this.db = this.moduleManager.modules["db"];
+            this.cache = this.moduleManager.modules["cache"];
+            this.notifications = this.moduleManager.modules["notifications"];
 
             const actions = require("./actions");
 
-            app.runJob("GET_APP", {})
+            this.app.runJob("GET_APP", {})
                 .then((response) => {
                     response.app.get("/", (req, res) => {
                         res.json({
@@ -20,6 +27,83 @@ class APIModule extends CoreClass {
                         });
                     });
 
+                    response.app.get("/debug_station", async (req, res) => {
+                        const responseObject = {};
+
+                        const stationModel = await this.db.runJob(
+                            "GET_MODEL",
+                            {
+                                modelName: "station",
+                            }
+                        );
+
+                        async.waterfall([
+                            next => {
+                                stationModel.find({}, next);
+                            },
+
+                            (stations, next) => {
+                                responseObject.mongo = {
+                                    stations
+                                };
+                                next();
+                            },
+
+                            next => {
+                                this.cache
+                                    .runJob("HGETALL", { table: "stations" })
+                                    .then(stations => next(null, stations))
+                                    .catch(next);
+                            },
+
+                            (stations, next) => {
+                                responseObject.redis = {
+                                    stations
+                                };
+                                next();
+                            },
+
+                            next => {
+                                responseObject.cryptoExamples = {};
+                                responseObject.mongo.stations.forEach(station => {
+                                    const payloadName = `stations.nextSong?id=${station._id}`;
+                                    responseObject.cryptoExamples[station._id] = crypto
+                                        .createHash("md5")
+                                        .update(`_notification:${payloadName}_`)
+                                        .digest("hex")
+                                });
+                                next();
+                            },
+
+                            next => {
+                                this.notifications.pub.keys("*", next);
+                            },
+
+                            (redisKeys, next) => {
+                                responseObject.redis = {
+                                    ...redisKeys,
+                                    ttl: {}
+                                };
+                                async.eachLimit(redisKeys, 1, (redisKey, next) => {
+                                    this.notifications.pub.ttl(redisKey, (err, ttl) => {
+                                        responseObject.redis.ttl[redisKey] = ttl;
+                                        next(err);
+                                    })
+                                }, next);
+                            }
+                        ], (err, response) => {
+                            if (err) {
+                                console.log(err);
+                                return res.json({
+                                    error: err,
+                                    objectSoFar: responseObject
+                                });
+                            }
+
+                            res.json(responseObject);
+                        });
+                    });
+
                     // Object.keys(actions).forEach(namespace => {
                     //     Object.keys(actions[namespace]).forEach(action => {
                     //         let name = `/${namespace}/${action}`;