derma/src/logic.js

const { hasPath, pathOr, props, uniqBy, eqBy, prop, union } = require('ramda');
const parseArgs = require('minimist');
const process = require('process');

const page_url = (page_id) => `https://www.facebook.com/${page_id}`;
const page_events_url = (page_id) => page_url(page_id) + '/events/';

const fs = require('fs').promises;
const filesystem = require('fs');

const flatten_string = (page_id) => {
  if (page_id.startsWith('"') && page_id.endsWith('"')) {
    return page_id.slice(1, page_id.length - 1);
  }
  if (page_id.startsWith("'") && page_id.endsWith("'")) {
    return page_id.slice(1, page_id.length - 1);
  }
  return page_id;
};

const parse_output = (argv) => {
  let [res = ''] = props(['output', 'o'], argv).filter(
    (item) => item !== undefined,
  );

  res = flatten_string(res);

  if (res === '') {
    res = null;
  }

  return res;
};

const parse_args = (args) => {
  const argv = parseArgs(args);
  const has_help_param =
    hasPath(['h'], argv) || hasPath(['help'], argv) || hasPath(['?'], argv);
  if (has_help_param) {
    process.exit(1);
  }

  const away_empty_strings = (str) => str.length !== 0;
  const page_id_to_page_events_url = page_events_url;
  const parse_param = (param) =>
    flatten_string(pathOr('', [param], argv))
      .split(',')
      .filter(away_empty_strings)
      .map(page_id_to_page_events_url);

  let events = flatten_string(pathOr('', ['events'], argv));
  if (events === '') {
    events = null;
  }

  const output = parse_output(argv);

  const get_upcoming_events = !pathOr(false, ['skip-upcoming-events'], argv);
  const get_past_events = pathOr(false, ['past-events'], argv);
  const headless = pathOr(true, ['headless'], argv);

  return {
    page_ids: [
      ...parse_param('page'),
      ...parse_param('p'),
      ...parse_param('pages'),
    ],
    events,
    output,
    get_upcoming_events,
    get_past_events,
    headless,
  };
};

const get_upcoming_events_from_page = pathOr(
  null,
  'data.page.upcoming_events'.split('.'),
);

const get_past_events_from_page = pathOr(
  null,
  'data.page.past_events'.split('.'),
);

const merge_edges = (acc, current) => {
  return [
    ...acc.filter((event) => event.event_id !== current.event_id),
    current,
  ];
};

const get_city_name = (event) =>
  pathOr('', 'event_place.city.contextual_name'.split('.'), event);

const get_event_host = (event) =>
  pathOr('', 'event_place.contextual_name'.split('.'), event);

const read_previous_events = (path) => {
  if (path !== null) {
    if (filesystem.existsSync(path)) {
      return fs
        .readFile(path, { encoding: 'utf-8' })
        .then((content) => JSON.parse(content))
        .catch((error) => {
          console.error(error);
          process.exit(1);
        });
    }
  }
  return Promise.resolve([]);
};

const map_event = ({ node: event }) => {
  const ticket_url = pathOr('', ['event_buy_ticket_url'], event);
  const city = get_city_name(event);
  const host = get_event_host(event);
  const canceled = pathOr(false, ['is_canceled'], event);
  return {
    date: event.time_range,
    name: event.name,
    event_id: event.id,
    ticket_url,
    canceled,
    location: {
      host: host,
      location: city,
    },
  };
};

const get_body_inner_text = async (page) =>
  await page.evaluate('document.querySelector("body").innerText;');

const has_upcoming_events = (body) =>
  body.includes('upcoming events') &&
  !body.includes('not have any upcoming events');

const has_past_events = (body) =>
  body.includes('past events') && !body.includes('not have any past events');

const merge_events = (a, b) => uniqBy(eqBy(prop('event_id')))(union(a, b));

module.exports = {
  get_body_inner_text,
  get_past_events_from_page,
  get_upcoming_events_from_page,
  has_past_events,
  has_upcoming_events,
  map_event,
  merge_edges,
  merge_events,
  parse_args,
  read_previous_events,
};