Skip to content

Commit

Permalink
feat: return payment trail per sub plan id
Browse files Browse the repository at this point in the history
  • Loading branch information
@stfsy
stfsy committed Sep 11, 2022
1 parent ab0a2ec commit 9437d7d
Show file tree
Hide file tree
Showing 2 changed files with 127 additions and 105 deletions.
139 changes: 76 additions & 63 deletions lib/index.js
View file
Expand Up @@ -271,74 +271,87 @@ class Subscriptions {
/**
*
* @param {Object} subscription
* @returns {Array<Object>} containing the start and end date
* @returns {Object}
*/
async getPaymentsTrail(subscription) {
const payments = subscription.payments
.sort((a, b) => new Date(a.event_time).getTime() - new Date(b.event_time).getTime())
const paymentsByPlanId = this._getById(subscription.payments)

return payments.map(payment => {
if (payment.alert_name === 'subscription_payment_failed') {
return {
event_time: payment.event_time,
description: payment.alert_name,
amount: {
currency: payment.currency,
total: payment.amount,
quantity: payment.quantity,
unit_price: payment.unit_price,
},
next_try: {
date: payment.next_retry_date
},
instalments: payment.instalments,
subscription_plan_id: payment.subscription_plan_id,
}
} else if (payment.alert_name === 'subscription_payment_refunded') {
return {
event_time: payment.event_time,
description: payment.alert_name,
amount: {
currency: payment.currency,
total: payment.gross_refund,
quantity: payment.quantity,
tax: payment.tax_refund,
unit_price: payment.unit_price
},
refund: {
reason: payment.refund_reason,
type: payment.refund_type
},
instalments: payment.instalments,
subscription_plan_id: payment.subscription_plan_id,
}
} else if (payment.alert_name === 'subscription_payment_succeeded') {
return {
event_time: payment.event_time,
description: payment.alert_name,
amount: {
currency: payment.currency,
total: payment.sale_gross,
quantity: payment.quantity,
tax: payment.payment_tax,
unit_price: payment.unit_price,
method: payment.payment_method,
},
next_payment: {
date: payment.next_bill_date,
return Object.entries(paymentsByPlanId).reduce((context, [subscriptionPlanId, payments]) => {
context[subscriptionPlanId] = this._getPaymentsTrail(payments)
return context
}, {})
}

/**
*
* @param {Object} subscription
* @returns {Array<Object>} containing the start and end date
*/
_getPaymentsTrail(payments) {
return payments //
.sort((a, b) => new Date(a.event_time).getTime() - new Date(b.event_time).getTime())
.map(payment => {
if (payment.alert_name === 'subscription_payment_failed') {
return {
event_time: payment.event_time,
description: payment.alert_name,
amount: {
currency: payment.currency,
total: payment.amount,
quantity: payment.quantity,
unit_price: payment.unit_price,
},
next_try: {
date: payment.next_retry_date
},
instalments: payment.instalments,
subscription_plan_id: payment.subscription_plan_id,
}
} else if (payment.alert_name === 'subscription_payment_refunded') {
return {
event_time: payment.event_time,
description: payment.alert_name,
amount: {
currency: payment.currency,
total: payment.gross_refund,
quantity: payment.quantity,
tax: payment.tax_refund,
unit_price: payment.unit_price
},
refund: {
reason: payment.refund_reason,
type: payment.refund_type
},
instalments: payment.instalments,
subscription_plan_id: payment.subscription_plan_id,
}
} else if (payment.alert_name === 'subscription_payment_succeeded') {
return {
event_time: payment.event_time,
description: payment.alert_name,
amount: {
currency: payment.currency,
total: payment.next_payment_amount
}
},
receipt_url: payment.receipt_url,
instalments: payment.instalments,
subscription_plan_id: payment.subscription_plan_id,
total: payment.sale_gross,
quantity: payment.quantity,
tax: payment.payment_tax,
unit_price: payment.unit_price,
method: payment.payment_method,
},
next_payment: {
date: payment.next_bill_date,
amount: {
currency: payment.currency,
total: payment.next_payment_amount
}
},
receipt_url: payment.receipt_url,
instalments: payment.instalments,
subscription_plan_id: payment.subscription_plan_id,
}
} else {
console.error(`Ignoring payment of unknown type ${payment.alert_name}`)
}
} else {
console.error(`Ignoring payment of unknown type ${payment.alert_name}`)
}
})
})
}

/**
Expand Down Expand Up @@ -388,7 +401,7 @@ class Subscriptions {
* @param {Number} validUntilMillis
* @returns
*/
_getById(statusOrPayments, validUntilMillis) {
_getById(statusOrPayments, validUntilMillis = Date.now()) {
return statusOrPayments.reduce((context, next) => {
if (new Date(next.event_time).getTime() < validUntilMillis) {

Expand Down
93 changes: 51 additions & 42 deletions test/spec/index.spec.js
View file
Expand Up @@ -450,73 +450,82 @@ describe('PaddleIntegration', () => {
beforeEach(async () => {
const subscriptionId = uuid()
const createPayload = Object.assign({}, subscriptionCreated, {
event_time: '2028-08-08 10:47:47',
event_time: '2018-08-08 10:47:47',
subscription_id: subscriptionId,
passthrough: JSON.stringify({ ids }),
})
await paddleIntegration.addSubscriptionCreatedStatus(createPayload)

const paymentSuccesfulPayload = Object.assign({}, paymentSucceded, {
event_time: '2027-08-08 10:47:47',
event_time: '2017-08-08 10:47:47',
subscription_id: subscriptionId,
passthrough: JSON.stringify({ ids }),
})
await paddleIntegration.addSuccessfulPayment(paymentSuccesfulPayload);
await paddleIntegration.addSuccessfulPayment(paymentSuccesfulPayload)

const paymentSuccesfulPayload2 = Object.assign({}, paymentSucceded, {
event_time: '2017-08-08 10:47:47',
subscription_id: subscriptionId,
subscription_plan_id: '4',
passthrough: JSON.stringify({ ids }),
})
await paddleIntegration.addSuccessfulPayment(paymentSuccesfulPayload2)

const paymentRefundedPayload = Object.assign({}, paymentRefunded, {
event_time: '2024-08-08 10:47:47',
event_time: '2014-08-08 10:47:47',
subscription_id: subscriptionId,
passthrough: JSON.stringify({ ids }),
})
await paddleIntegration.addRefundedPayment(paymentRefundedPayload)

const paymentFailedPayload = Object.assign({}, paymentFailed, {
event_time: '2022-08-08 10:47:47',
event_time: '2012-08-08 10:47:47',
subscription_id: subscriptionId,
passthrough: JSON.stringify({ ids }),
})
await paddleIntegration.addFailedPayment(paymentFailedPayload)
})
it('returns a sorted listed of payments', async () => {
it('returns a sorted listed of payments per subscription plan id', async () => {
const { subscription: sub } = await storage.get(ids)
const trail = await paddleIntegration.getPaymentsTrail(sub)

expect(trail).to.have.length(3)
expect(trail[0].description).to.equal('subscription_payment_failed')
expect(trail[0].amount.currency).to.equal(paymentFailed.currency)
expect(trail[0].amount.total).to.equal(paymentFailed.amount)
expect(trail[0].amount.quantity).to.equal(paymentFailed.quantity)
expect(trail[0].amount.unit_price).to.equal(paymentFailed.unit_price)
expect(trail[0].next_try.date).to.equal(paymentFailed.next_retry_date)
expect(trail[0].instalments).to.equal(paymentFailed.instalments)
expect(trail[0].subscription_plan_id).to.equal(paymentFailed.subscription_plan_id)


expect(trail[1].description).to.equal('subscription_payment_refunded')
expect(trail[1].amount.currency).to.equal(paymentRefunded.currency)
expect(trail[1].amount.total).to.equal(paymentRefunded.gross_refund)
expect(trail[1].amount.quantity).to.equal(paymentRefunded.quantity)
expect(trail[1].amount.tax).to.equal(paymentRefunded.tax_refund)
expect(trail[1].amount.unit_price).to.equal(paymentRefunded.unit_price)
expect(trail[1].refund.reason).to.equal(paymentRefunded.refund_reason)
expect(trail[1].refund.type).to.equal(paymentRefunded.refund_type)
expect(trail[1].instalments).to.equal(paymentRefunded.instalments)
expect(trail[1].subscription_plan_id).to.equal(paymentRefunded.subscription_plan_id)


expect(trail[2].description).to.equal('subscription_payment_succeeded')
expect(trail[2].amount.currency).to.equal(paymentSucceded.currency)
expect(trail[2].amount.total).to.equal(paymentSucceded.sale_gross)
expect(trail[2].amount.quantity).to.equal(paymentSucceded.quantity)
expect(trail[2].amount.tax).to.equal(paymentSucceded.payment_tax)
expect(trail[2].amount.unit_price).to.equal(paymentSucceded.unit_price)
expect(trail[2].amount.method).to.equal(paymentSucceded.payment_method)
expect(trail[2].next_payment.date).to.equal(paymentSucceded.next_bill_date)
expect(trail[2].next_payment.amount.currency).to.equal(paymentSucceded.currency)
expect(trail[2].next_payment.amount.total).to.equal(paymentSucceded.next_payment_amount)
expect(trail[2].receipt_url).to.equal(paymentSucceded.receipt_url)
expect(trail[2].instalments).to.equal(paymentSucceded.instalments)
expect(trail[2].subscription_plan_id).to.equal(paymentSucceded.subscription_plan_id)
expect(trail).to.have.keys(paymentSucceded.subscription_plan_id, '4')

const paymentsForSubscription = trail[paymentSucceded.subscription_plan_id]
expect(paymentsForSubscription).to.have.length(3)
expect(paymentsForSubscription[0].description).to.equal('subscription_payment_failed')
expect(paymentsForSubscription[0].amount.currency).to.equal(paymentFailed.currency)
expect(paymentsForSubscription[0].amount.total).to.equal(paymentFailed.amount)
expect(paymentsForSubscription[0].amount.quantity).to.equal(paymentFailed.quantity)
expect(paymentsForSubscription[0].amount.unit_price).to.equal(paymentFailed.unit_price)
expect(paymentsForSubscription[0].next_try.date).to.equal(paymentFailed.next_retry_date)
expect(paymentsForSubscription[0].instalments).to.equal(paymentFailed.instalments)
expect(paymentsForSubscription[0].subscription_plan_id).to.equal(paymentFailed.subscription_plan_id)

expect(paymentsForSubscription[1].description).to.equal('subscription_payment_refunded')
expect(paymentsForSubscription[1].amount.currency).to.equal(paymentRefunded.currency)
expect(paymentsForSubscription[1].amount.total).to.equal(paymentRefunded.gross_refund)
expect(paymentsForSubscription[1].amount.quantity).to.equal(paymentRefunded.quantity)
expect(paymentsForSubscription[1].amount.tax).to.equal(paymentRefunded.tax_refund)
expect(paymentsForSubscription[1].amount.unit_price).to.equal(paymentRefunded.unit_price)
expect(paymentsForSubscription[1].refund.reason).to.equal(paymentRefunded.refund_reason)
expect(paymentsForSubscription[1].refund.type).to.equal(paymentRefunded.refund_type)
expect(paymentsForSubscription[1].instalments).to.equal(paymentRefunded.instalments)
expect(paymentsForSubscription[1].subscription_plan_id).to.equal(paymentRefunded.subscription_plan_id)

expect(paymentsForSubscription[2].description).to.equal('subscription_payment_succeeded')
expect(paymentsForSubscription[2].amount.currency).to.equal(paymentSucceded.currency)
expect(paymentsForSubscription[2].amount.total).to.equal(paymentSucceded.sale_gross)
expect(paymentsForSubscription[2].amount.quantity).to.equal(paymentSucceded.quantity)
expect(paymentsForSubscription[2].amount.tax).to.equal(paymentSucceded.payment_tax)
expect(paymentsForSubscription[2].amount.unit_price).to.equal(paymentSucceded.unit_price)
expect(paymentsForSubscription[2].amount.method).to.equal(paymentSucceded.payment_method)
expect(paymentsForSubscription[2].next_payment.date).to.equal(paymentSucceded.next_bill_date)
expect(paymentsForSubscription[2].next_payment.amount.currency).to.equal(paymentSucceded.currency)
expect(paymentsForSubscription[2].next_payment.amount.total).to.equal(paymentSucceded.next_payment_amount)
expect(paymentsForSubscription[2].receipt_url).to.equal(paymentSucceded.receipt_url)
expect(paymentsForSubscription[2].instalments).to.equal(paymentSucceded.instalments)
expect(paymentsForSubscription[2].subscription_plan_id).to.equal(paymentSucceded.subscription_plan_id)
})
})
describe('.getStatusTrail', () => {
Expand Down

0 comments on commit 9437d7d

Please sign in to comment.