floriday/index.js

import fetch from "node-fetch";
import moment from "moment";

const _accessTokenEndpoint =
  "https://idm.staging.floriday.io/oauth2/ausmw6b47z1BnlHkw0h7/v1/token";

import models from "./models/index.js";

let AccessToken = await getClientToken();

let tokenValue = AccessToken[0];
let tokenExpirationDate = AccessToken[1];

try {
  // Every 30 sec query the database
  setInterval(async () => {
    console.log("Querying the API to check for new data...");
    console.log("Current token expiration date: ", tokenExpirationDate);
    console.log("Now is: ", moment().format("YYYY-MM-DD HH:mm:ss"));

    if(moment().isAfter(tokenExpirationDate)){
      console.log("Token expired, getting a new one...");
      AccessToken = await getClientToken();
      tokenValue = AccessToken[0];
      tokenExpirationDate = AccessToken[1];
    }

    const query = models.tradeItem.findAll({
      include: [
        {
          model: models.characteristics,
          association: models.tradeItem.hasMany(models.characteristics, {
            foreignKey: "tradeItemFk",
            sourceKey: "id",
          }),
          as: "characteristics",
        },
        {
          model: models.photos,
          association: models.tradeItem.hasMany(models.photos, {
            foreignKey: "tradeItemFk",
            sourceKey: "id",
          }),
          as: "photos",
          include: [
            {
              model: models.seasonalPeriod,
              association: models.photos.hasOne(models.seasonalPeriod, {
                foreignKey: "id",
                sourceKey: "seasonalPeriodFk",
              }),
              as: "seasonalPeriod",
            },
          ],
        },
        {
          model: models.packagingConfigurations,
          association: models.tradeItem.hasMany(models.packagingConfigurations, {
            foreignKey: "tradeItemFk",
            sourceKey: "id",
          }),
          as: "packagingConfigurations",
          include: [
            {
              model: models.package,
              association: models.packagingConfigurations.hasOne(models.package, {
                foreignKey: "packingConfigurationsFk",
                sourceKey: "id",
              }),
              as: "package",
            },
            {
              model: models.additionalPricePerPiece,
              association: models.packagingConfigurations.hasOne(
                models.additionalPricePerPiece,
                {
                  foreignKey: "packingConfigurationsFk",
                  sourceKey: "id",
                }
              ),
              as: "additionalPricePerPiece",
            },
          ],
        },
        {
          model: models.botanicalNames,
          association: models.tradeItem.hasMany(models.botanicalNames, {
            foreignKey: "tradeItemFk",
            sourceKey: "id",
          }),
          as: "botanicalNames",
        },
        {
          model: models.countryOfOriginIsoCodes,
          association: models.tradeItem.hasMany(models.countryOfOriginIsoCodes, {
            foreignKey: "tradeItemFk",
            sourceKey: "id",
          }),
          as: "countryOfOriginIsoCodes",
        },
      ],
    });

    const result = await query;

    console.log(JSON.stringify(result, null, 2));
  }, 5000);
} catch (error) {
  console.error("Unable to connect to the database:", error);
}

async function getClientToken() {

  let clientConfigData = await models.clientConfig.findAll();

  const now = moment().format("YYYY-MM-DD HH:mm:ss");
  const tokenExpirationDate = clientConfigData[0].tokenExpiration;

  if (
    clientConfigData[0].tokenExpiration == null ||
    moment(now).isAfter(tokenExpirationDate)
  ) {
    let clientId = clientConfigData[0].clientId;
    let clientSecret = clientConfigData[0].clientSecret;

    const tokenRequest = await fetch(_accessTokenEndpoint, {
      method: "POST",
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
      },
      body: `grant_type=client_credentials&client_id=${clientId}&client_secret=${clientSecret}&scope=role:app catalog:read`,
    });

    const tokenResponse = await tokenRequest.json();

    const accessToken = tokenResponse.access_token;
    let now = moment().format("YYYY-MM-DD HH:mm:ss");

    let tokenExpirationDate = moment(now)
      .add(tokenResponse.expires_in, "s")
      .format("YYYY-MM-DD HH:mm:ss");

    updateClientConfig(
      clientId,
      clientSecret,
      accessToken,
      tokenExpirationDate
    );

    return [accessToken, tokenExpirationDate];
  } else {
    console.log("Using the current token...");
    return [clientConfigData[0].currentToken, tokenExpirationDate];
  }
}

async function updateClientConfig(
  clientId,
  clientSecret,
  accessToken,
  tokenExpirationDate
) {
  try {
    await models.clientConfig.update(
      {
        clientId: clientId,
        clientSecret: clientSecret,
        currentToken: accessToken,
        tokenExpiration: tokenExpirationDate,
      },
      {
        where: {
          id: 1,
        },
      }
    );
    console.log("Client config updated, new Token set");
    console.log("New token expiration date: ", tokenExpirationDate );
  } catch (error) {
    console.log("There was a error while updating the client config");
    console.log(error);
  }
}

console.log = function () {
  var args = Array.prototype.slice.call(arguments);
  args.unshift(new moment().format("HH:mm:ss") + " -");
  console.info.apply(console, args);
};