get_my/server/main.js

// this file has been converted for meteor 3 and later

import { Meteor } from 'meteor/meteor';
import { SysConfig } from '../imports/api/systemConfig';
import { MenuItems } from '../imports/api/menuItems';
import { Products } from '../imports/api/products.js';
import { Menus } from '../imports/api/menu.js';
import { MScripts } from '../imports/api/mScripts.js';
import { UpdateInfo } from '../imports/api/updateInfo.js';
import { Roles } from 'meteor/roles';

Meteor.startup(async() => {
  // code to run on server at startup
  Roles.createRoleAsync("user", {unlessExists: true});
  Roles.createRoleAsync("admin", {unlessExists: true});
  Roles.createRoleAsync("systemadmin", {unlessExists: true});

  // set the systemconfig defaults for registration
  // check if this has already been run
  let regPolRun = await MScripts.findOneAsync({ scriptName: "DefaultRegPolicy", scriptRun: true });
  if (!regPolRun) {
    try {
        let regPolicy = await SysConfig.findOneAsync({});
        if (!regPolicy) {
          SysConfig.insertAsync({
            SysAdminReg: false,
            dateAdded: new Date(),
            allowReg: true,
            allowUpdates: true,
          });
          markScriptRun("DefaultRegPolicy");
        } else {
          // console.log("Registration policy already set.");
          markScriptRun("DefaultRegPolicy");
        }
    } catch(error) {
      console.log("    ERROR trying to check if registration policy was set.");
      console.log(error.message);
      console.log(error.stack);
    } 
  }
  
  // check if the isLInked item exists on menuitems, and if not, add it (data cleanup task)
  // see if already updated
  let linkUpdateRun = await MScripts.findOneAsync({ scriptName: "updateMenuItemLinks", scriptRun: true });
  try {
    if (!linkUpdateRun) {
      let itemInfoNoLink = MenuItems.find({ isLinked: { $exists: false } }).fetch();
      // console.log("No Ites with isLinked not set: " + itemInfoNoLink.length);
      if (itemInfoNoLink.length > 0) {
        // console.log("Found items with isLinked not set. Updating...");
        // console.dir(itemInfoNoLink);
        let infoLength = itemInfoNoLink.length;
        for (i=0; i < infoLength; i++) {
          MenuItems.updateAsync({ _id: itemInfoNoLink[i]._id }, {
            $set: {
                isLinked: false,
            }
          });
          if (i == (infoLength -1)) {
            markScriptRun("updateMenuItemLinks");
          }
        }
      } else {
        // this will show if all items are found to have isLInked set.
        // console.log("No items with isLinked not set.");
        markScriptRun("updateMenuItemLinks");
      }
    }
  } catch(error) {
    console.log("    ERROR running check for isLinked items.");
    console.log(error.message);
    console.log(error.stack);
  }

  // update Products to be able to have multiple stores in the document
  // check if update already run
  let prodStoreArrayRun = await MScripts.findOneAsync({ scriptName: "changeProdStoreToArray", scriptRun: true });
  if (!prodStoreArrayRun) {
    try {
      let prodInfo = Products.find({}).fetch();
      let prodCount = prodInfo.length;
      // console.log("Updating Products to allow multiple store assocation for " + prodCount + " products.");
      for (let j = 0; j < prodCount; j++) {
        if (typeof prodInfo[j].prodStore == 'object') {
          // console.log(typeof prodInfo[j].prodStore);
          // console.log("Is Array already");
        } else {
          let prodStoreArray = [];
          // console.log("----    ----    ----");
          // console.log(typeof prodInfo[j].prodStore);
          // console.log("---- Is Not Array.");
          let prodStore = prodInfo[j].prodStore;

          prodStoreArray.push(prodStore);
          // console.dir(prodStoreArray);
          Products.update({ _id: prodInfo[j]._id }, {
            $set: {
              prodStore: prodStoreArray,
            }
          });
        }
        if (j == (prodCount -1)) {
          markScriptRun("changeProdStoreToArray");
        }
      }
    } catch(error) {
      console.log("Script to update product stores couldn't run.");
      console.log(error.message);
      console.log(error.stack);
    } 
  }

  // update menu items to new format so they get the linked products
  // check if this update has run
  let menuItemUpdRun = await MScripts.findOneAsync({ scriptName: "updateMenuProdLinks", scriptRun: true });
  if (!menuItemUpdRun) {
    try {
      let openMenus = Menus.find({ menuComplete: false }).fetch();
      let openMenuCount = openMenus.length;
      // console.log("Open Menu count is: " + openMenuCount);
      for (let k = 0; k < openMenuCount; k++) {
        if (typeof openMenus.menuItems == 'object') {
          // console.log(openMenus.menuName + " appears to be converted.");
          markScriptRun("updateMenuProdLinks");
        } else {
          let menuId = openMenus[k]._id;

          let thisMenuItems = MenuItems.find({ menuId: menuId }).fetch();

          let itemCount = thisMenuItems.length;

          for (l = 0; l < itemCount; l++) {
            Menus.update({ _id: menuId }, {
              $addToSet: {
                menuItems:
                {
                  menuItemId: thisMenuItems[l]._id,
                  menuItemName: thisMenuItems[l].itemName,
                  serveDate: thisMenuItems[l].serveDate,
                  serveDateActual: thisMenuItems[l].serveDateActual,
                  isLinked: thisMenuItems[l].isLinked
                },
              }
            });
          }
        }
        if (k == (openMenuCount - 1)) {
          markScriptRun("updateMenuProdLinks");
        }
      }
    } catch(error) {
      console.log("    ERROR updating the menu product links: ");
      console.log(error.message);
      console.log(error.stack);
    } 
  } else {
    // console.log("Menu Item updates have already been run.");
  }

  // get update available information if enabled in system confiuration
  let currConfig = await SysConfig.findOneAsync({});
  if (!currConfig) {
    // console.log("No Current Config found.")
  } else {
    try {
      let feedurl = "https://gitlab.com/bmcgonag/get_my/-/releases.atom"
      if (currConfig.allowUpdates == true) {
        // console.log("Allow Updates is true");
        startCronForUpdates(feedurl);
      } else if (typeof currConfig.allowUpdates == 'undefined' || currConfig.allowUpdates == null) {
        SysConfig.update({ _id: currConfig._id }, { $set: {
          allowUpdates: true,
        }});
        startCronForUpdates(feedurl);
      }
    } catch(error) {
      console.log("    ERROR checking current config for updates: " + error);
      console.log(error.message);
      console.log(error.stack);
    }
  }
});

var startCronForUpdates = function(feedurl) {
  var cron = require('node-cron');

  cron.schedule('*/30 * * * *', () => {
    getUpdateInfoNow(feedurl);
  });
}

var markScriptRun = async function(scriptName) {
  // check if this is already set
  let scriptRun = await MScripts.findOneAsync({ scriptName: scriptName });
  if (!scriptRun) {
    try {
      return MScripts.insertAsync({
          scriptName: scriptName,
          scriptRun: true,
          runOn: new Date()
        });
    } catch(error) {
      console.log("    ERROR inserting the script run log: " + error);
      console.log(error.message);
      console.log(error.stack);
    }
  } else {
    // console.log(scriptName + " already set as run on " + scriptRun.runOn);
  }
}

var getUpdateInfoNow = async function(feedurl) {
    const parser = require('rss-url-parser')

    const data = await parser(feedurl)
    let dataLength = data.length;
    // console.dir(data[0].title);

    // check if this title already exists in db
    let updatesExist = await UpdateInfo.findOneAsync({ title: data[0].title });
    try {
      if (!updatesExist) {
        UpdateInfo.insertAsync({
            title: data[0].title,
            description: data[0].description,
            dateRelease: data[0].date,
            releaseLink: data[0].link,
            viewed: false
        });
      } else {
        console.log("No new updates available at this time.");
      }
    } catch(error) {
      console.log("    ERROR checking for update: " + error);
      console.log(error.message);
      console.log(error.stack);
    }
}