@getoccasion/sdk/src/construct_calendar.js

An SDK library that enables access to Occasion's application, providing a rich DSL for creating and managing bookings.

// @todo Remove includes({ product: 'merchant' }) when AR supports owner assignment to has_many children
//   in non-load queries
Occasion.__constructCalendar = function __constructCalendar(
  month,
  {
    calendar,
    monthlyTimeSlotDaysBatchSize,
    monthlyTimeSlotPreloadSize,
    preload,
    prevPagePromise,
    relation,
    status,
    timeZone
  } = {}
) {
  var today = moment.tz(timeZone)
  status = status || 'bookable'

  var lowerRange
  if (month) {
    lowerRange = month.tz(timeZone)
  } else {
    lowerRange = today
  }
  lowerRange = lowerRange.startOf('month')
  var upperRange = lowerRange.clone().endOf('month')

  var numRequests = Math.ceil(upperRange.diff(lowerRange, 'days') / monthlyTimeSlotDaysBatchSize)
  if (numRequests < 1) numRequests = 1

  var i = 0
  var requests = []

  var lower = lowerRange.clone()
  var upper = lowerRange.clone().add(monthlyTimeSlotDaysBatchSize, 'days')
  while (i < numRequests) {
    if (i + 1 == numRequests) upper = upperRange.clone()

    requests.push(
      relation
        .includes({
          product: 'merchant'
        })
        .where({
          startsAt: {
            ge: lower.toDate(),
            le: upper.toDate()
          },
          status
        })
        .all()
    )

    lower.add(monthlyTimeSlotDaysBatchSize, 'days')
    upper.add(monthlyTimeSlotDaysBatchSize, 'days')
    i++
  }

  calendar = calendar || {}
  if (_.isUndefined(calendar.__currentPage)) calendar.__currentPage = 0
  if (_.isUndefined(calendar.__preloadedPages)) calendar.__preloadedPages = 0

  calendar.__preloading = true

  var currentPromise = Promise.all(requests).then(function(timeSlotsArray) {
    var allTimeSlots = ActiveResource.Collection.build(timeSlotsArray)
      .map(function(ts) {
        return ts.toArray()
      })
      .flatten()

    let startDate = moment(lowerRange).startOf('month')
    let endDate = moment(lowerRange).endOf('month')

    var response = ActiveResource.CollectionResponse.build()

    let day = startDate
    while (day.isSameOrBefore(endDate)) {
      response.push({
        day,
        timeSlots: allTimeSlots.select(timeSlot => {
          return timeSlot.startsAt.isSame(day, 'day')
        })
      })

      day = day.clone().add(1, 'days')
    }

    response.hasNextPage = function() {
      return true
    }

    let commonPaginationOptions = {
      calendar,
      monthlyTimeSlotDaysBatchSize,
      monthlyTimeSlotPreloadSize,
      relation,
      status,
      timeZone
    }

    response.nextPage = function(preloadCount) {
      if (!this.nextPromise) {
        this.nextPromise = Occasion.__constructCalendar(
          moment(upperRange)
            .add(1, 'days')
            .startOf('month'),
          {
            ...commonPaginationOptions,
            preload: preloadCount,
            prevPagePromise: currentPromise
          }
        )
      }

      if (_.isUndefined(preloadCount)) {
        calendar.__currentPage += 1

        if (
          !calendar.__preloading &&
          calendar.__preloadedPages <= calendar.__currentPage + monthlyTimeSlotPreloadSize / 2
        ) {
          calendar.__lastPreloadedPage.nextPage(monthlyTimeSlotPreloadSize)
        }
      }

      return this.nextPromise
    }

    if (status !== 'bookable' || (month && !month.isSame(today, 'month'))) {
      response.hasPrevPage = function() {
        return true
      }

      response.prevPage = function() {
        this.prevPromise =
          this.prevPromise ||
          prevPagePromise ||
          Occasion.__constructCalendar(moment(lowerRange).subtract(1, 'months'), {
            ...commonPaginationOptions,
            preload: 0
          })

        calendar.__currentPage -= 1

        return this.prevPromise
      }
    }

    if (monthlyTimeSlotPreloadSize > 0) {
      if (_.isUndefined(preload)) {
        response.nextPage(monthlyTimeSlotPreloadSize - 1)
      } else if (preload > 0) {
        response.nextPage(--preload)
      } else {
        calendar.__preloading = false
      }
    }

    calendar.__preloadedPages += 1
    calendar.__lastPreloadedPage = response

    return response
  })

  return currentPromise
}