Support variable distribution period length

frontend/model/contracts/group.js

@@ -14,9 +14,9 @@ import {
 import { paymentStatusType, paymentType, PAYMENT_COMPLETED } from './shared/payments/index.js'
 import { createPaymentInfo, paymentHashesFromPaymentPeriod } from './shared/functions.js'
 import { merge, deepEqualJSONType, omit, cloneDeep } from './shared/giLodash.js'
-import { addTimeToDate, dateToPeriodStamp, compareISOTimestamps, dateFromPeriodStamp, isPeriodStamp, comparePeriodStamps, periodStampGivenDate, dateIsWithinPeriod, DAYS_MILLIS } from './shared/time.js'
+import { addTimeToDate, dateToPeriodStamp, compareISOTimestamps, dateFromPeriodStamp, isIsoString, isPeriodStamp, comparePeriodStamps, dateIsWithinPeriod, DAYS_MILLIS } from './shared/time.js'
 import { unadjustedDistribution, adjustedDistribution } from './shared/distribution/distribution.js'
-import currencies, { saferFloat } from './shared/currencies.js'
+import currencies from './shared/currencies.js'
 import { inviteType, chatRoomAttributesType } from './shared/types.js'
 import { arrayOf, mapOf, objectOf, objectMaybeOf, optional, string, number, boolean, object, unionOf, tupleOf } from '~/frontend/model/contracts/misc/flowTyper.js'
 
@@ -312,32 +312,138 @@ sbp('chelonia/defineContract', {
     groupMincomeCurrency (state, getters) {
       return getters.groupSettings.mincomeCurrency
     },
+    // Oldest period key first.
+    groupSortedPeriodKeys (state, getters) {
+      // The .sort() call might be only necessary in older browser which don't maintain object key ordering.
+      // A comparator function isn't required for now since our keys are ISO strings.
+      return Object.keys(getters.currentGroupState.paymentsByPeriod ?? {}).sort()
+    },
+    // Returns either the known period stamp for the given date,
+    // or the predicted one according to the period length.
+    // May return 'undefined', in which case the caller should check archived data.
     periodStampGivenDate (state, getters) {
       return (recentDate: string | Date) => {
-        if (typeof recentDate !== 'string') {
-          recentDate = recentDate.toISOString()
-        }
+        if (typeof recentDate !== 'string') recentDate = recentDate.toISOString()
+        if (!isIsoString(recentDate)) throw new TypeError('must be date or isostring')
         const { distributionDate, distributionPeriodLength } = getters.groupSettings
-
-        if (!distributionDate) return null
-
-        return periodStampGivenDate({
-          recentDate,
-          periodStart: distributionDate,
-          periodLength: distributionPeriodLength
-        })
+        if (!distributionDate) return
+        const sortedPeriodKeys = getters.groupSortedPeriodKeys
+        // Maybe the distribution date has just been updated,
+        // but the corresponding period has not started or is not stored yet.
+        // So we try to use the distribution date first.
+        if (recentDate >= distributionDate) {
+          // Only extrapolate one period length in the future.
+          const extrapolatedDistributionDate = addTimeToDate(
+            distributionDate, distributionPeriodLength
+          ).toISOString()
+          if (recentDate >= extrapolatedDistributionDate) {
+            return dateToPeriodStamp(extrapolatedDistributionDate)
+          }
+          return dateToPeriodStamp(distributionDate)
+        }
+        // For dates before the distribution date, we check the stored data first,
+        // as simply substracting the default period length won't give the previous period stamp
+        // if the distribution date was updated during that period.
+        if (!sortedPeriodKeys.length) {
+          // Looks like we're in the waiting period but haven't stored it yet.
+          const waitingPeriodStamp = dateToPeriodStamp(
+            addTimeToDate(distributionDate, -distributionPeriodLength)
+          )
+          return recentDate >= dateFromPeriodStamp(waitingPeriodStamp).toISOString() ? waitingPeriodStamp : undefined
+        }
+        const oldestKnownStamp = sortedPeriodKeys[0]
+        const latestKnownStamp = sortedPeriodKeys[sortedPeriodKeys.length - 1]
+        if (recentDate < oldestKnownStamp) return
+        if (recentDate >= latestKnownStamp) {
+          const extrapolatedPeriodStamp = dateToPeriodStamp(
+            addTimeToDate(dateFromPeriodStamp(latestKnownStamp), distributionPeriodLength)
+          )
+          if (recentDate >= extrapolatedPeriodStamp) return extrapolatedPeriodStamp
+          return latestKnownStamp
+        }
+        for (let i = 1; i < sortedPeriodKeys.length; i++) {
+          if (recentDate < sortedPeriodKeys) return sortedPeriodKeys[i - 1]
+        }
+        // This should not happen
       }
     },
+    // May return 'undefined', in which case the caller should check archived data.
     periodBeforePeriod (state, getters) {
       return (periodStamp: string) => {
-        const len = getters.groupSettings.distributionPeriodLength
-        return dateToPeriodStamp(addTimeToDate(dateFromPeriodStamp(periodStamp), -len))
+        if (!isPeriodStamp(periodStamp)) throw new TypeError('must be periodStamp')
+        const { distributionDate, distributionPeriodLength } = getters.groupSettings
+        if (!distributionDate) return
+        // This is not always the current period stamp.
+        const distributionDateStamp = dateToPeriodStamp(distributionDate)
+        const sortedPeriodKeys = getters.groupSortedPeriodKeys
+        const latestKnownStamp = sortedPeriodKeys[sortedPeriodKeys.length - 1]
+        // Maybe the distribution date has just been updated,
+        // but the corresponding period has not started or is not stored yet.
+        // So we try to use the distribution date first.
+        if (periodStamp > distributionDateStamp) {
+          // Only extrapolate one period length in the future.
+          const onePeriodLenghtAhead = addTimeToDate(distributionDate, distributionPeriodLength)
+          if (periodStamp === dateToPeriodStamp(onePeriodLenghtAhead)) return distributionDate
+          else return
+        }
+        if (periodStamp === distributionDateStamp) {
+          if (sortedPeriodKeys.length) {
+            // If the distribution date doesn't match the latest known period stamp,
+            // then either that stamp is for the waiting period,
+            // or the distribution date has just been updated.
+            // In both cases we can return it.
+            if (latestKnownStamp !== distributionDateStamp) return latestKnownStamp
+            // Otherwise it's a normal period, therefore substracting the period length would not be reliable.
+            else return sortedPeriodKeys[sortedPeriodKeys.length - 2] ?? undefined
+          } else {
+            // If no period has been stored yet, then we're in the waiting period and can do arithmetic.
+            return dateToPeriodStamp(addTimeToDate(distributionDate, -distributionPeriodLength))
+          }
+        }
+        const index = sortedPeriodKeys.indexOf(periodStamp)
+        if (index === -1) {
+          // Maybe the given stamp is wrong and has no associated period,
+          // but is one period length ahead of a known one.
+          // TODO: just return 'undefined' when sure it's always safe.
+          const maybePreviousStamp = dateToPeriodStamp(
+            addTimeToDate(dateFromPeriodStamp(periodStamp), -distributionPeriodLength)
+          )
+          return sortedPeriodKeys.includes(maybePreviousStamp) ? maybePreviousStamp : undefined
+        }
+        // If index is 0 then the caller will have to check the archive.
+        if (index === 0) return
+        return sortedPeriodKeys[index - 1]
       }
     },
+    // May return 'undefined', in which case the caller should check archived data.
     periodAfterPeriod (state, getters) {
       return (periodStamp: string) => {
-        const len = getters.groupSettings.distributionPeriodLength
-        return dateToPeriodStamp(addTimeToDate(dateFromPeriodStamp(periodStamp), len))
+        if (!isPeriodStamp(periodStamp)) throw new TypeError('must be periodStamp')
+        const { distributionDate, distributionPeriodLength } = getters.groupSettings
+        if (!distributionDate) return
+        // This is not always the current period stamp.
+        const distributionDateStamp = dateToPeriodStamp(distributionDate)
+        const sortedPeriodKeys = getters.groupSortedPeriodKeys
+
+        // Maybe the distribution date has just been updated,
+        // and the corresponding period has not started or is not stored yet.
+        if (periodStamp > distributionDateStamp) return
+        if (periodStamp === distributionDateStamp) {
+          return dateToPeriodStamp(addTimeToDate(distributionDate, distributionPeriodLength))
+        }
+        // Maybe we're in the waiting period but haven't stored it yet.
+        if (!sortedPeriodKeys.length) {
+          const waitingPeriodStamp = dateToPeriodStamp(
+            addTimeToDate(distributionDate, -distributionPeriodLength)
+          )
+          return periodStamp === waitingPeriodStamp ? distributionDate : undefined
+        }
+        const index = sortedPeriodKeys.indexOf(periodStamp)
+        if (index === -1) return
+        // Maybe the given stamp is the last stored one but doesn't match the distribution date.
+        if (index === sortedPeriodKeys.length - 1) return dateToPeriodStamp(distributionDate)
+        // Now 'index + 1' is always a valid index.
+        return sortedPeriodKeys[index + 1]
       }
     },
     dueDateForPeriod (state, getters) {
@@ -348,37 +454,6 @@ sbp('chelonia/defineContract', {
         return getters.periodAfterPeriod(periodStamp)
       }
     },
-    paymentTotalFromUserToUser (state, getters) {
-      return (fromUser, toUser, periodStamp) => {
-        const payments = getters.currentGroupState.payments
-        const periodPayments = getters.groupPeriodPayments
-        const { paymentsFrom, mincomeExchangeRate } = periodPayments[periodStamp] || {}
-        // NOTE: @babel/plugin-proposal-optional-chaining would come in super-handy
-        //       here, but I couldn't get it to work with our linter. :(
-        //       https://github.com/babel/babel-eslint/issues/511
-        const total = (((paymentsFrom || {})[fromUser] || {})[toUser] || []).reduce((a, hash) => {
-          const payment = payments[hash]
-          let { amount, exchangeRate, status } = payment.data
-          if (status !== PAYMENT_COMPLETED) {
-            return a
-          }
-          const paymentCreatedPeriodStamp = getters.periodStampGivenDate(payment.meta.createdDate)
-          // if this payment is from a previous period, then make sure to take into account
-          // any proposals that passed in between the payment creation and the payment
-          // completion that modified the group currency by multiplying both period's
-          // exchange rates
-          if (periodStamp !== paymentCreatedPeriodStamp) {
-            if (paymentCreatedPeriodStamp !== getters.periodBeforePeriod(periodStamp)) {
-              console.warn(`paymentTotalFromUserToUser: super old payment shouldn't exist, ignoring! (curPeriod=${periodStamp})`, JSON.stringify(payment))
-              return a
-            }
-            exchangeRate *= periodPayments[paymentCreatedPeriodStamp].mincomeExchangeRate
-          }
-          return a + (amount * exchangeRate * mincomeExchangeRate)
-        }, 0)
-        return saferFloat(total)
-      }
-    },
     paymentHashesForPeriod (state, getters) {
       return (periodStamp) => {
         const periodPayments = getters.groupPeriodPayments[periodStamp]
@@ -415,7 +490,7 @@ sbp('chelonia/defineContract', {
     },
     groupProposalSettings (state, getters) {
       return (proposalType = PROPOSAL_GENERIC) => {
-        return getters.groupSettings.proposals[proposalType]
+        return getters.groupSettings.proposals?.[proposalType]
       }
     },
     groupCurrency (state, getters) {
@@ -1262,8 +1337,11 @@ sbp('chelonia/defineContract', {
       process ({ meta }, { state, getters }) {
         const period = getters.periodStampGivenDate(meta.createdDate)
         const current = getters.groupSettings?.distributionDate
-
-        if (current !== period) {
+        const inWaitingPeriod = !current || new Date().toISOString() < current
+        // Maybe we're updating the distribution date while in the waiting period.
+        if (inWaitingPeriod && meta.createdDate !== current) {
+          getters.groupSettings.distributionDate = meta.createdDate
+        } else if (current !== period) {
           // right before updating to the new distribution period, make sure to update various payment-related group streaks.
           updateGroupStreaks({ state, getters })
           getters.groupSettings.distributionDate = period

frontend/model/contracts/manifests.json

@@ -1,7 +1,7 @@
 {
   "manifests": {
     "gi.contracts/chatroom": "21XWnNS9zeT2tws6KkJqkibLGfTivPdiGYbSjjqFEkDjL5Q775",
-    "gi.contracts/group": "21XWnNGw4mX4hBGLwq5TXPY1JWcBzEWXFqRhkWWdeBGvBCVhtj",
+    "gi.contracts/group": "21XWnNSdFZtCUSLtqdTnNeFLQdKFc2hWjsbYZkMZg3PjceNnZW",
     "gi.contracts/identity": "21XWnNN7wGNxzFZmiS4ft2TumavYYAgemSuFrGavTVJpxqtnyg",
     "gi.contracts/mailbox": "21XWnNHJ7MALCinR7vnu4GM82nq5DLhe6nhEDzruTuTw9CTnXP"
   }

frontend/model/contracts/shared/time.js

@@ -132,13 +132,17 @@ export function humanDate (
 }
 
 export function isPeriodStamp (arg: string): boolean {
-  return /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(arg)
+  return isIsoString(arg)
 }
 
 export function isFullMonthstamp (arg: string): boolean {
   return /^\d{4}-(0[1-9]|1[0-2])$/.test(arg)
 }
 
+export function isIsoString (arg: string): boolean {
+  return typeof arg === 'string' && /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(arg)
+}
+
 export function isMonthstamp (arg: string): boolean {
   return isShortMonthstamp(arg) || isFullMonthstamp(arg)
 }

frontend/views/containers/contributions/SupportHistory.vue

@@ -20,8 +20,6 @@ div(:class='isReady ? "" : "c-ready"')
 
 <script>
 import { mapGetters } from 'vuex'
-import { comparePeriodStamps } from '@model/contracts/shared/time.js'
-import { MAX_HISTORY_PERIODS } from '@model/contracts/shared/constants.js'
 import { L } from '@common/common.js'
 import PaymentsMixin from '@containers/payments/PaymentsMixin.js'
 import BarGraph from '@components/graphs/bar-graph/BarGraph.vue'
@@ -41,32 +39,18 @@ export default ({
   computed: {
     ...mapGetters([
       'currentPaymentPeriod',
-      'periodStampGivenDate',
-      'periodBeforePeriod',
       'withGroupCurrency',
       'groupTotalPledgeAmount',
       'groupCreatedDate'
-    ]),
-    firstDistributionPeriod () {
-      // group's first distribution period
-      return this.periodStampGivenDate(this.groupCreatedDate)
-    },
-    periods () {
-      const periods = [this.currentPaymentPeriod]
-      for (let i = 0; i < MAX_HISTORY_PERIODS - 1; i++) {
-        const period = this.periodBeforePeriod(periods[0])
-        if (comparePeriodStamps(period, this.firstDistributionPeriod) < 0) break
-        else periods.unshift(period)
-      }
-      return periods
-    }
+    ])
   },
   mounted () {
     this.updateHistory()
   },
   methods: {
     async updateHistory () {
-      this.history = await Promise.all(this.periods.map(async (period, i) => {
+      const periods = await this.getSortedPeriodKeys()
+      this.history = await Promise.all(periods.map(async (period, i) => {
         const totalTodo = await this.getTotalTodoAmountForPeriod(period)
         const totalDone = await this.getTotalPledgesDoneForPeriod(period)
 
@@ -82,7 +66,7 @@ export default ({
     }
   },
   watch: {
-    periods () {
+    currentPaymentPeriod () {
       this.updateHistory()
     }
   }

frontend/views/containers/contributions/TodoHistory.vue

@@ -37,15 +37,8 @@ export default ({
   computed: {
     ...mapGetters([
       'currentPaymentPeriod',
-      'periodStampGivenDate',
-      'periodBeforePeriod',
-      'groupCreatedDate',
-      'dueDateForPeriod'
-    ]),
-    firstDistributionPeriod () {
-      // group's first distribution period
-      return this.periodStampGivenDate(this.groupCreatedDate)
-    }
+      'groupCreatedDate'
+    ])
   },
   created () {
     this.updateHistory()
@@ -55,17 +48,17 @@ export default ({
       this.history = []
 
       let period = null
+      const firstDistributionPeriod = await this.getPeriodStampGivenDate(this.groupCreatedDate)
       const getLen = obj => Object.keys(obj).length
 
       for (let i = 0; i < MAX_HISTORY_PERIODS; i++) {
-        period = period === null ? this.currentPaymentPeriod : this.periodBeforePeriod(period)
-        if (comparePeriodStamps(period, this.firstDistributionPeriod) < 0) break
+        period = period === null ? this.currentPaymentPeriod : await this.getPeriodBeforePeriod(period)
+        if (!period || comparePeriodStamps(period, firstDistributionPeriod) < 0) break
 
         const paymentDetails = await this.getPaymentDetailsByPeriod(period)
         const { lastAdjustedDistribution } = await this.getPeriodPayment(period)
         const doneCount = getLen(paymentDetails)
         const missedCount = getLen(lastAdjustedDistribution || {})
-
         this.history.unshift({
           total: doneCount === 0 ? 0 : doneCount / (doneCount + missedCount),
           title: this.getPeriodFromStartToDueDate(period),

frontend/views/containers/payments/MonthOverview.vue

@@ -2,9 +2,9 @@
 .c-summary(data-test='monthOverview')
   i18n.c-summary-title.is-title-4(
     tag='h4'
-    data-test='thisMonth'
-    :args='{ month: humanDate(Date.now(), { month: "long" }) }'
-  ) {month} overview
+    data-test='monthOverviewTitle'
+    :args='{ start: humanDate(getStartDate()), end: humanDate(getDueDate()) }'
+  ) Period: {start} - {end}
 
   ul
     li.c-summary-item(
@@ -36,14 +36,20 @@ import { mapGetters } from 'vuex'
 import { PAYMENT_NOT_RECEIVED } from '@model/contracts/shared/payments/index.js'
 import ProgressBar from '@components/graphs/Progress.vue'
 import { L } from '@common/common.js'
-import { humanDate } from '@model/contracts/shared/time.js'
+import { addTimeToDate, humanDate } from '@model/contracts/shared/time.js'
 
 export default ({
   name: 'MonthOverview',
   components: {
     ProgressBar
   },
   methods: {
+    getDueDate () {
+      return addTimeToDate(this.getStartDate(), this.groupSettings.distributionPeriodLength)
+    },
+    getStartDate () {
+      return this.periodStampGivenDate(new Date())
+    },
     humanDate,
     statusIsSent (user) {
       return ['completed', 'pending'].includes(user.status)
@@ -54,10 +60,12 @@ export default ({
   },
   computed: {
     ...mapGetters([
+      'currentPaymentPeriod',
       'ourGroupProfile',
       'groupSettings',
       'ourPaymentsSummary',
-      'ourPayments'
+      'ourPayments',
+      'periodStampGivenDate'
     ]),
     currency () {
       return currencies[this.groupSettings.mincomeCurrency].displayWithCurrency