taapi-cache/dist/schema/RESTSchema.js

TAAPI.IO Cache Package. A convenient way to fetch candles, store them and reuse them.

const config = require("../config/config");

const chalk = require("chalk");

const database = require("../utilities/Database"); // Errors


const {
  Errors,
  ErrorTypes
} = require("../config/Errors");

class RESTSchema {
  constructor(api) {
    this.api = api;
  }
  /* async resolv(user, provider, endpoint, args, requiredParameters) {
       let hasErrors = false;
      let errors = [];
       for(let requiredParameterKey in requiredParameters) {
           const requiredParameter = requiredParameters[requiredParameterKey];
          if(!args[requiredParameter] || args[requiredParameter] === "") {
              hasErrors = true;
              errors.push(`'${requiredParameter}' is a required parameter!`);
          }
      }
      
      if(hasErrors) {
          return {
              statusCode: 400,
              response: { errors },
          };
      }
       delete args.secret;
       return {
          statusCode: calculateResponse.statusCode,
          response: calculateResponse.data,
      };
  } */


  async configureEndpoints() {
    // Get cache tickers
    this.api.get(`/tickers`, async (req, res) => {
      if (!req.isAuthenticated) {
        res.status(ErrorTypes.UNAUTHORIZED.statusCode).send(ErrorTypes.UNAUTHORIZED);
      } else {
        const parametersEvaluation = this.evaluateRequiredParameters(req.query, []);

        if (!parametersEvaluation.hasErrors) {
          // All good, let's fetch the parameters
          const cacheTickers = await database.getCacheTickers(req.query.provider, req.query.source, req.query.symbol, req.query.interval);
          res.status(200).send({
            data: cacheTickers
          });
        } else {
          res.status(400).send({
            errors: parametersEvaluation.errors
          });
        }
      }
    }); // Get cached candles

    this.api.get(`/candles`, async (req, res) => {
      if (!req.isAuthenticated) {
        res.status(ErrorTypes.UNAUTHORIZED.statusCode).send(ErrorTypes.UNAUTHORIZED);
      } else {
        const parametersEvaluation = this.evaluateRequiredParameters(req.query, ["provider", "source", "symbol", "interval"]);

        if (!parametersEvaluation.hasErrors) {
          // All good, let's fetch the parameters
          const candles = await database.getCachedCandles(req.query.provider, req.query.source, req.query.symbol, req.query.interval, parseInt(req.query.limit));
          res.status(200).send({
            data: candles
          });
        } else {
          res.status(400).send({
            errors: parametersEvaluation.errors
          });
        }
      }
    }); // Set cache ticker(s)

    this.api.post(`/ticker`, async (req, res) => {
      if (!req.isAuthenticated) {
        res.status(ErrorTypes.UNAUTHORIZED.statusCode).send(ErrorTypes.UNAUTHORIZED);
      } else {
        const parametersEvaluation = this.evaluateRequiredParameters(req.body, ["provider", "source", "symbol", "interval"]);

        if (!parametersEvaluation.hasErrors) {
          database.addCacheTicker(req.body.provider, req.body.source, req.body.symbol, req.body.interval);
          res.status(200).send({
            data: "Monitoring candles!"
          });
        } else {
          res.status(400).send({
            errors: parametersEvaluation.errors
          });
        }
      }
    }); // Delete cache tickers

    this.api.delete(`/tickers`, async (req, res) => {
      if (!req.isAuthenticated) {
        res.status(ErrorTypes.UNAUTHORIZED.statusCode).send(ErrorTypes.UNAUTHORIZED);
      } else {
        let errors = [];

        if (!req.query.id && !req.query.provider && !req.query.source && !req.query.symbol && !req.query.interval) {
          errors.push("At least one of the parameters: [id, provider, source, symbol, interval] is required!");
        }

        if (errors.length === 0) {
          // All good, let's fetch the parameters
          let deletedCount = await database.deleteCacheTickers(req.query.id, req.query.provider, req.query.source, req.query.symbol, req.query.interval);
          res.status(200).send({
            data: `${deletedCount} Tickers removed!`
          });
        } else {
          res.status(400).send({
            errors: errors
          });
        }
      }
    });
  }

  evaluateRequiredParameters(suppliedParameters, requiredParameters) {
    let response = {
      hasErrors: false,
      errors: []
    };

    for (let requiredParameterKey in requiredParameters) {
      const requiredParameter = requiredParameters[requiredParameterKey];

      if (!suppliedParameters[requiredParameter] || suppliedParameters[requiredParameter] === "") {
        response.hasErrors = true;
        response.errors.push(`'${requiredParameter}' is a required parameter!`);
      }
    }

    return response;
  }

}

module.exports = RESTSchema;