calender-events-mapper

import moment from 'moment';
import cloneDeep from 'lodash/cloneDeep';
import querystring from 'querystring';

const calendarDateFormat = 'YYYY-MM-DD HH:mm:ss';
const displayDateFormat = 'DD-MM-YYYY hh:mm A';

const createEvents = (event, query) => {
  let events = [];

  const endOfMonth = moment(parseFloat(querystring.parse(query).toDate));
  const eventStartDate = moment(event.startDateTime);
  const endHours = moment(event.endDateTime).hours();
  const endMinutes = moment(event.endDateTime).minutes();

  let eventEndDate = moment(event.endDateTime);

  if (event.isRecurring) {
    if (event.recurringEnds) {
      eventEndDate = event.recurringEndDate < endOfMonth ? moment(event.recurringEndDate) : endOfMonth;
    } else {
      eventEndDate = endOfMonth;
    }
  }
  let addType = 'days';

  let daysToAdd = 1;

  let diffType = 'days';

  switch (event.recurringOrder) {
    case 'daily':
      addType = 'days';
      daysToAdd = 1;
      diffType = 'days';
      break;

    case 'weekly':
      daysToAdd = 7;
      addType = 'days';
      diffType = 'days';
      break;

    case 'monthly':
      daysToAdd = 1;
      addType = 'months';
      diffType = 'month';
      break;

    case 'yearly':
      daysToAdd = 1;
      addType = 'years';
      diffType = 'year';
      break;

    default:
      break;
  }

  const eventStartEndDifference = eventEndDate.diff(eventStartDate, diffType);
  const daysDifference = moment(event.endDateTime)
    .startOf('day')
    .diff(moment(event.startDateTime).startOf('day'), 'days');

  if (!event.isRecurring && !event.allDay) {
    const cloneEvent = cloneDeep(event);

    for (let i = 0; i <= daysDifference; i++) {
      const cloneDate = moment(cloneEvent.startDateTime).add(i, addType);
      const cloneStudentEvent = cloneDeep(event);

      if (i === 0 && daysDifference === 0) {
        cloneStudentEvent.start = moment(cloneDate.clone()).format(calendarDateFormat);
        cloneStudentEvent.end = moment(cloneDate.clone()).format(calendarDateFormat);
      } else if (i === 0 && daysDifference === 1) {
        cloneStudentEvent.start = moment(cloneDate.clone()).format(calendarDateFormat);
        cloneStudentEvent.end = moment(cloneDate.clone())
          .endOf('day')
          .format(calendarDateFormat);
      } else if (i === daysDifference) {
        cloneStudentEvent.start = moment(cloneDate.clone())
          .startOf('day')
          .format(calendarDateFormat);
        cloneStudentEvent.end = moment(cloneDate.clone())
          .startOf('day')
          .add(endHours, 'hours')
          .add(endMinutes, 'minutes')
          .format(calendarDateFormat);
      } else if (i !== 0 && i !== daysDifference) {
        cloneStudentEvent.start = moment(cloneDate.clone())
          .startOf('day')
          .format(calendarDateFormat);
        cloneStudentEvent.end = moment(cloneDate.clone())
          .endOf('day')
          .format(calendarDateFormat);
      } else {
        cloneStudentEvent.start = moment(cloneDate.clone()).format(calendarDateFormat);
        cloneStudentEvent.end = moment(cloneDate.clone())
          .endOf('day')
          .format(calendarDateFormat);
      }

      const displayStartDateTime = moment(cloneStudentEvent.start);

      let displayEndDateTime = moment(cloneStudentEvent.end)
        .startOf('day')
        .add(endHours, 'hours')
        .add(endMinutes, 'minutes');

      displayEndDateTime = displayEndDateTime.add(daysDifference, 'days');

      cloneStudentEvent.displayDateTime = `${displayStartDateTime.format(
        displayDateFormat
      )} - ${displayEndDateTime.format(displayDateFormat)}`;

      events.push(cloneStudentEvent);
    }
  } else {
    for (let j = 0; j <= eventStartEndDifference; j += daysToAdd) {
      const cloneEvent = cloneDeep(event);
      const cloneDate = moment(cloneEvent.startDateTime).add(j, addType);

      cloneEvent.start = moment(cloneDate.clone()).format(calendarDateFormat);
      cloneEvent.end = moment(cloneDate.clone())
        .add(daysDifference)
        .format(calendarDateFormat);

      if (cloneEvent.allDay) {
        cloneEvent.displayDateTime = 'All Day';
      } else {
        const displayStartDateTime = moment(cloneEvent.start);

        let displayEndDateTime = moment(cloneEvent.end)
          .startOf('day')
          .add(endHours, 'hours')
          .add(endMinutes, 'minutes');

        displayEndDateTime = displayEndDateTime.add(daysDifference, 'days');

        cloneEvent.displayDateTime = `${displayStartDateTime.format(displayDateFormat)} - ${displayEndDateTime.format(
          displayDateFormat
        )}`;
      }

      events.push(cloneEvent);
    }
  }

  const repeated = [];

  events = events.map((singleEvent) => {
    const cloneSingleEvent = cloneDeep(singleEvent);

    if (event.isRecurring && !cloneSingleEvent.allDay && daysDifference > 0) {
      cloneSingleEvent.start = moment(cloneSingleEvent.start).format(calendarDateFormat);
      cloneSingleEvent.end = moment(cloneSingleEvent.end)
        .endOf('day')
        .format(calendarDateFormat);

      for (let i = 1; i <= daysDifference; i++) {
        // TWO EVENTS IN SINGLE DATE PENDING
        const repeatedEvent = cloneDeep(cloneSingleEvent);

        repeatedEvent.start = moment(cloneSingleEvent.start)
          .add(i, 'day')
          .startOf('day')
          .format(calendarDateFormat);
        if (i === daysDifference) {
          repeatedEvent.end = moment(singleEvent.start)
            .add(i, 'day')
            .startOf('day')
            .add(endHours, 'hours')
            .add(endMinutes, 'minutes')
            .format(calendarDateFormat);
        } else {
          repeatedEvent.end = moment(singleEvent.start)
            .add(i, 'day')
            .endOf('day')
            .format(calendarDateFormat);
        }

        repeated.push(repeatedEvent);
      }
    } else if (event.isRecurring && cloneSingleEvent.allDay && daysDifference > 0) {
      cloneSingleEvent.start = moment(cloneSingleEvent.start)
        .startOf('day')
        .format(calendarDateFormat);
      cloneSingleEvent.end = moment(cloneSingleEvent.end)
        .endOf('day')
        .format(calendarDateFormat);
      cloneSingleEvent.displayDateTime = 'All Day';

      for (let i = 1; i <= daysDifference; i++) {
        // REPEATED EVENTS BETWEEN TWO DATES
        const repeatedEvent = cloneDeep(cloneSingleEvent);

        repeatedEvent.start = moment(cloneSingleEvent.start)
          .add(i, 'day')
          .format(calendarDateFormat);
        repeatedEvent.end = moment(cloneSingleEvent.end)
          .add(i, 'day')
          .endOf('day')
          .subtract(1, 'minute')
          .format(calendarDateFormat);
        repeatedEvent.displayDateTime = 'All Day';

        repeated.push(repeatedEvent);
      }
    } else if (!event.isRecurring && cloneSingleEvent.allDay && daysDifference > 0) {
      cloneSingleEvent.start = moment(cloneSingleEvent.start)
        .startOf('day')
        .format(calendarDateFormat);
      cloneSingleEvent.end = moment(cloneSingleEvent.end)
        .endOf('day')
        .format(calendarDateFormat);

      cloneSingleEvent.displayDateTime = 'All Day';
    } else if (daysDifference === 0 && !cloneSingleEvent.allDay) {
      cloneSingleEvent.start = moment(cloneSingleEvent.start).format(calendarDateFormat);
      cloneSingleEvent.end = moment(cloneSingleEvent.end)
        .startOf('day')
        .add(endHours, 'hours')
        .add(endMinutes, 'minutes')
        .format(calendarDateFormat);
    } else if (daysDifference === 0 && cloneSingleEvent.allDay) {
      cloneSingleEvent.start = moment(cloneSingleEvent.start)
        .startOf('day')
        .format(calendarDateFormat);
      cloneSingleEvent.end = moment(cloneSingleEvent.end)
        .endOf('day')
        .format(calendarDateFormat);
      cloneSingleEvent.displayDateTime = 'All Day';
    }

    return cloneSingleEvent;
  });

  return [...events, ...repeated];
};

export const mapCalendarEvents = (request, query) => {
  const cloneEvents = cloneDeep(request);
  const allDay = [];

  let events = [];

  cloneEvents.forEach((event) => {
    const cloneEvent = cloneDeep(event);
    const listing = createEvents(cloneEvent, query);

    events = [...events, ...listing];
  });

  return {
    allDay,
    events,
  };
};