This code processes user commands, checks for duplicates, retrieves user settings, and prepares the command for potential execution, likely as a scheduled Google Calendar event.

Run example

npm run import -- "filter command permission"

filter command permission

var importer = require('../Core');
var getPermissions = importer.import("rpc permissions");
var getDaysEvents = importer.import("days events");
var getSettings = importer.import("google contact settings");
var getOauthClient = importer.import("import google calendar api");

var options = {
    calendarId: 'Commands'
};

var alreadyRun = (date, id) => getDaysEvents(new Date(date), options)
    .then(events => events
          .filter(e => e.event.summary.indexOf('Result:') > -1
                  && e.event.summary.indexOf(id) > -1).length > 0);

// TODO: move this logic out to a higher level coordinator?
function filterCommand(command, date, id, user) {
    const props = {};
    return authorizeCalendar(options)
        .then(() => getSettings(user))
        .then(settings => {
            // assign user controls and interpreted command
            try {
                Object.assign(props, settings, {
                    result: importer.interpret(command)
                });
                // TODO: accept parameters from message context
            } catch (e) {
                if((e + '').indexOf('Nothing found') > -1) {
                    Object.assign(props, {result: null});
                } else {
                    throw e;
                }
            }
        })
        .then(() => alreadyRun(date, id))
        .catch(e => console.log(e))
        .then(already => Object.assign(props, {already: already || null}))
}
module.exports = filterCommand;

const { importCore } = require('../Core');
const {
  getPermissions,
  getDaysEvents,
  getSettings,
  getOauthClient
} = importCore([
  'rpc permissions',
  'days events',
  'google contact settings',
  'import google calendar api'
]);

const filterCommand = async (command, date, id, userId) => {
  const calendarId = 'Commands';
  const settings = await getSettings(userId);
  const props = {...settings };

  try {
    props.result = await importCore.interpret(command);
    const alreadyRun = await getDaysEvents(new Date(date), { calendarId })
     .then(events => events
       .filter(event => event.summary.includes('Result:') && event.summary.includes(id))
       .length > 0);

    props.already = alreadyRun;
    return props;
  } catch (error) {
    if (error.message.includes('Nothing found')) {
      props.result = null;
    } else {
      console.error(error);
      throw error;
    }
    return props;
  }
};

module.exports = filterCommand;

This code defines a function filterCommand that processes a user command, checks for existing events, and prepares data for potential execution.

Here's a breakdown:

1. Imports:

   • Imports functions for handling RPC permissions, retrieving daily events, accessing Google contact settings, and importing the Google Calendar API.

2. options Object:

   • Defines a configuration object with a calendarId for interacting with the Google Calendar API.

3. alreadyRun Function:

   • Helper function to check if an event with a specific summary (containing "Result:" and the command ID) already exists for a given date.

4. filterCommand Function:

   • Takes command, date, ID, and user as input.
   • Authorizes access to the Google Calendar API.
   • Retrieves user settings.
   • Interprets the command using importer.interpret.
   • Checks if the command has already been run on the specified date.
   • Combines the interpreted command, user settings, and run status into a props object.

In essence, this code prepares a command for execution by checking for existing events, retrieving user settings, and interpreting the command itself. It likely serves as a part of a system that manages user commands and schedules them as Google Calendar events.