Add documentation and quiet mode to plain routes

Author: scinorandex

src/api.ts

@@ -12,10 +12,17 @@ const app = express();
 app.use(morgan("common"));
 app.use(userAgentMiddleware);
 
+/**
+ * Plain CMD/Basic routes have both quiet and full modes
+ * Same with regular / routes with ansi color codes
+ */
+app.use(["/quiet/basic", "/quiet/cmd", "/quiet/plain"], plainRouter);
 app.use(["/basic", "/cmd", "/plain"], plainRouter);
+
 app.use(["/quiet", "/"], router);
 app.use("/", errorHandler);
 
+// Not found handler
 app.use("*", (_req, res) =>
     res.send(
         `Welcome to COVID-19 Tracker CLI v${version} by Waren Gonzaga with Wareneutron Developers\n

src/api/plainRouter.ts

@@ -6,6 +6,8 @@ import {
     historyPerCountryPlain,
     globalHistoryPlain,
 } from "../utils/plainHandlers";
+import { isQuiet } from "./router";
+
 export const plainRouter = Router({ mergeParams: true });
 
 plainRouter.get(
@@ -19,7 +21,7 @@ plainRouter.get(
 
         // if the mode is not in the api then return to next handler
         if (!["cases", "deaths", "recovered"].includes(mode)) return next();
-        res.send(await globalHistoryPlain(mode));
+        res.send(await globalHistoryPlain(mode, isQuiet(req)));
     })
 );
 
@@ -35,21 +37,21 @@ plainRouter.get(
 
         // if the mode is not in the api then return to next handler
         if (!["cases", "deaths", "recovered"].includes(mode)) return next();
-        res.send(await historyPerCountryPlain(country, mode));
+        res.send(await historyPerCountryPlain(country, mode, isQuiet(req)));
     })
 );
 
 plainRouter.get(
     "/:country",
     handleAsync(async (req, res, _next) => {
         const country = req.params.country;
-        res.send(await informationPerCountryPlain(country));
+        res.send(await informationPerCountryPlain(country, isQuiet(req)));
     })
 );
 
 plainRouter.get(
     "/",
-    handleAsync(async (_req, res, _next) => {
-        res.send(await globalInformationPlain());
+    handleAsync(async (req, res, _next) => {
+        res.send(await globalInformationPlain(isQuiet(req)));
     })
 );

src/api/router.ts

@@ -1,4 +1,4 @@
-import { Router } from "express";
+import { Request, Router } from "express";
 import {
     globalHistory,
     globalInformation,
@@ -7,6 +7,14 @@ import {
 } from "../utils/handlers";
 import handleAsync from "./handleAsync";
 
+/**
+ *
+ * @param req Express request
+ * @returns Boolean if the request starts with /quiet
+ */
+export const isQuiet: (req: Request) => boolean = (req) =>
+    req.baseUrl.startsWith("/quiet");
+
 /**
  * The rootRouter handles all the processing of the requests *after* passing through
  * all middlewares except not found and error handling middleware
@@ -25,7 +33,7 @@ router.get(
 
         // if the mode is not in the api then return to next handler
         if (!["cases", "deaths", "recovered"].includes(mode)) return next();
-        res.send(await globalHistory(mode, req.baseUrl.startsWith("/quiet")));
+        res.send(await globalHistory(mode, isQuiet(req)));
     })
 );
 
@@ -41,32 +49,21 @@ router.get(
 
         // if the mode is not in the api then return to next handler
         if (!["cases", "deaths", "recovered"].includes(mode)) return next();
-        res.send(
-            await historyPerCountry(
-                country,
-                mode,
-                req.baseUrl.startsWith("/quiet")
-            )
-        );
+        res.send(await historyPerCountry(country, mode, isQuiet(req)));
     })
 );
 
 router.get(
     "/:country",
     handleAsync(async (req, res, _next) => {
         const country = req.params.country;
-        res.send(
-            await informationPerCountry(
-                country,
-                req.baseUrl.startsWith("/quiet")
-            )
-        );
+        res.send(await informationPerCountry(country, isQuiet(req)));
     })
 );
 
 router.get(
     "/",
     handleAsync(async (req, res, _next) => {
-        res.send(await globalInformation(req.baseUrl.startsWith("/quiet")));
+        res.send(await globalInformation(isQuiet(req)));
     })
 );

src/utils/generatePlainOutput.ts

@@ -6,8 +6,9 @@ const { version } = require("../../package.json");
 export const generatePlainOutput: (
     info: PlainData,
     chartType: string,
+    quiet: boolean,
     extraRows?: string[]
-) => string = ({ data, metainfo }, chartType, extraRows) => {
+) => string = ({ data, metainfo }, chartType, quiet, extraRows) => {
     // Set line depending if it contains a chart or not
     let line = extraRows === undefined ? "-".repeat(60) : "-".repeat(68);
     line += "\n";
@@ -43,10 +44,11 @@ export const generatePlainOutput: (
         if (normalizedArray.length !== 0) table += `\n`; // do not add whitespace at the end of the table
     }
 
-    /**
-     * responseArray is the array of the raw data **before** adding the separator lines
-     */
-    let responseArray: string[] = [header, timestamp, table];
+    // responseArray is the array of the raw data **before** adding the separator lines
+
+    let responseArray: string[] = [timestamp, table];
+
+    if (!quiet) responseArray.unshift(header);
 
     // Add extraRows to responseArray
     if (extraRows !== undefined) {
@@ -56,14 +58,22 @@ export const generatePlainOutput: (
     }
 
     // Add the help msg and other messages
-    responseArray = responseArray.concat([
-        "Help: Try to append the URL with /help to learn more...",
-        "Source: https://www.worldometers.info/coronavirus/",
-        "Code: https://github.com/warengonzaga/covid19-tracker-cli",
-        `\n${saying}\n`,
-        `Love this project? Help us to help others by means of coffee!\n${GCashMessage}(Buy Me A Coffee) warengonza.ga/coffee4dev`,
-        "Follow me on twitter for more updates!\n@warengonzaga #covid19trackercli",
-    ]);
+    if (!quiet)
+        responseArray = responseArray.concat([
+            "Help: Try to append the URL with /help to learn more...",
+            "Source: https://www.worldometers.info/coronavirus/",
+            "Code: https://github.com/warengonzaga/covid19-tracker-cli",
+            `\n${saying}\n`,
+        ]);
+
+    responseArray.push(
+        `Love this project? Help us to help others by means of coffee!\n${GCashMessage}(Buy Me A Coffee) warengonza.ga/coffee4dev`
+    );
+
+    if (!quiet)
+        responseArray.push(
+            `Follow me on twitter for more updates!\n@warengonzaga #covid19trackercli`
+        );
 
     // Construct the final output
     let response: string = "\n";

src/utils/plainHandlers.ts

@@ -3,9 +3,17 @@ import { generateAsciichart } from "./generateAsciichart";
 import { generatePlainOutput } from "./generatePlainOutput";
 import { getAllInfo, getCountryInfo, PlainData } from "./getInformation";
 
-export const globalHistoryPlain: (mode: string) => Promise<string> = async (
-    mode
-) => {
+/**
+ * globalHistory shows a tablechart of the cases of all the countries
+ * Shows Cases, Deaths, Recovered, Active, Cases/Million
+ * and a graph of a country's cases
+ * @param mode Mode that the user wants to query, must be: "cases" | "deaths" | "recoveries"
+ * @param quiet tells the response to be in quiet mode or not
+ */
+export const globalHistoryPlain: (
+    mode: string,
+    quiet: boolean
+) => Promise<string> = async (mode, quiet) => {
     // Get summary info
     const info = (await getAllInfo(true)) as PlainData;
 
@@ -24,13 +32,26 @@ export const globalHistoryPlain: (mode: string) => Promise<string> = async (
     // Generate historical graph
     const chart = generateAsciichart(Object.values(data), true, 7);
 
-    return generatePlainOutput(info, `Global Historical Chart`, [date, chart]);
+    return generatePlainOutput(info, `Global Historical Chart`, quiet, [
+        date,
+        chart,
+    ]);
 };
 
+/**
+ * historyPerCountry shows a tablechart of the <mode> of a country
+ * Shows Cases, Deaths, Recovered, Active, Cases/Million
+ * Today Cases, Today Deaths, Critical, Mortality %, Recovery in a chart
+ * @param country country code or country name that the user wants to query
+ * @param mode Mode that the user wants to query, must be: "cases" | "deaths" | "recoveries"
+ * @param quiet tells the response to be in quiet mode or not
+ */
+
 export const historyPerCountryPlain: (
     country: string,
-    mode: string
-) => Promise<string> = async (country, mode) => {
+    mode: string,
+    quiet: boolean
+) => Promise<string> = async (country, mode, quiet) => {
     // Get summary info about a country
     const info = (await getCountryInfo(country, true)) as PlainData;
 
@@ -49,20 +70,41 @@ export const historyPerCountryPlain: (
     // Generate historical graph
     const chart = generateAsciichart(Object.values(data), true, 7);
 
-    return generatePlainOutput(info, `${info.metainfo.countryName} Chart`, [
-        date,
-        chart,
-    ]);
+    return generatePlainOutput(
+        info,
+        `${info.metainfo.countryName} Chart`,
+        quiet,
+        [date, chart]
+    );
 };
 
+/**
+ *  informationPerCountry tracks the info of a country
+ * 	Shows Cases, Deaths, Recovered, Active, Cases/Million
+ *  Today Cases, Today Deaths, Critical, Mortality %, Recovery in a chart
+ * 	@param country country code or country name that the user wants to query
+ *  @param quiet tells the response to be in quiet mode or not
+ */
 export const informationPerCountryPlain: (
-    country: string
-) => Promise<string> = async (country) => {
+    country: string,
+    quiet: boolean
+) => Promise<string> = async (country, quiet) => {
     const info = (await getCountryInfo(country, true)) as PlainData;
-    return generatePlainOutput(info, `${info.metainfo.countryName} Update`);
+    return generatePlainOutput(
+        info,
+        `${info.metainfo.countryName} Update`,
+        quiet
+    );
 };
 
-export const globalInformationPlain: () => Promise<string> = async () => {
+/**
+ *  globalInformation tracks the info of all countries
+ * 	Shows Cases, Deaths, Recovered, Mortality %, Recovered% in a chart
+ *  @param quiet tells the response to be in quiet mode or not
+ */
+export const globalInformationPlain: (
+    quiet: boolean
+) => Promise<string> = async (quiet) => {
     const info = (await getAllInfo(true)) as PlainData;
-    return generatePlainOutput(info, "Global Update");
+    return generatePlainOutput(info, "Global Update", quiet);
 };