richie-education 2.29.2 → 2.29.3-dev48

package/js/types/Joanie.ts

@@ -259,14 +259,42 @@ export interface EnrollmentLight {
 
 // Order
 export enum OrderState {
-  DRAFT = 'draft',
-  SUBMITTED = 'submitted',
+  ASSIGNED = 'assigned',
   CANCELED = 'canceled',
+  COMPLETED = 'completed',
+  DRAFT = 'draft',
+  FAILED_PAYMENT = 'failed_payment',
+  NO_PAYMENT = 'no_payment',
   PENDING = 'pending',
-  VALIDATED = 'validated',
-}
-
-export const ACTIVE_ORDER_STATES = [OrderState.PENDING, OrderState.VALIDATED, OrderState.SUBMITTED];
+  PENDING_PAYMENT = 'pending_payment',
+  SIGNING = 'signing',
+  TO_SAVE_PAYMENT_METHOD = 'to_save_payment_method',
+  TO_SIGN = 'to_sign',
+}
+
+export const PURCHASABLE_ORDER_STATES = [
+  OrderState.DRAFT,
+  OrderState.ASSIGNED,
+  OrderState.TO_SIGN,
+  OrderState.SIGNING,
+  OrderState.TO_SAVE_PAYMENT_METHOD,
+];
+
+export const ACTIVE_ORDER_STATES = [
+  OrderState.PENDING,
+  OrderState.PENDING_PAYMENT,
+  OrderState.NO_PAYMENT,
+  OrderState.FAILED_PAYMENT,
+  OrderState.COMPLETED,
+];
+
+export const NOT_CANCELED_ORDER_STATES = [...ACTIVE_ORDER_STATES, ...PURCHASABLE_ORDER_STATES];
+
+export const ENROLLABLE_ORDER_STATES = [
+  OrderState.COMPLETED,
+  OrderState.PENDING_PAYMENT,
+  OrderState.FAILED_PAYMENT,
+];
 
 export interface Order {
   id: string;
@@ -286,6 +314,8 @@ export interface Order {
   organization_id: Organization['id'];
   organization: Organization;
   order_group_id?: OrderGroup['id'];
+  payment_schedule?: PaymentSchedule;
+  credit_card_id?: CreditCard['id'];
 }
 
 export interface CredentialOrder extends Order {
@@ -293,20 +323,12 @@ export interface CredentialOrder extends Order {
   enrollment: null;
 }
 
-export interface CredentialOrderWithPaymentInfo extends CredentialOrder {
-  payment_info: Payment;
-}
-
 export interface CertificateOrder extends Order {
   course: null;
   enrollment: EnrollmentLight;
   target_courses: never[];
 }
 
-export interface CertificateOrderWithPaymentInfo extends CertificateOrder {
-  payment_info: Payment;
-}
-
 export type OrderLite = Pick<
   Order,
   | 'id'
@@ -325,9 +347,11 @@ export interface AbstractNestedOrder {
   product_title: string;
   owner_name: string;
   state: OrderState;
+  course: Nullable<CourseLight>;
+  enrollment: Nullable<EnrollmentLight>;
 }
 export interface NestedCertificateOrder extends AbstractNestedOrder {
-  course: undefined;
+  course: null;
   enrollment: EnrollmentLight;
 }
 export const isNestedCredentialOrder = (
@@ -338,10 +362,13 @@ export const isNestedCredentialOrder = (
 
 export interface NestedCredentialOrder extends AbstractNestedOrder {
   course: CourseLight;
-  enrollment: undefined;
+  enrollment: null;
 }
 
-export type OrderEnrollment = Pick<Order, 'id' | 'state' | 'product_id' | 'certificate_id'>;
+export type OrderEnrollment = Pick<
+  Order,
+  'id' | 'state' | 'product_id' | 'certificate_id' | 'payment_schedule'
+>;
 
 export interface NestedCourseOrder {
   id: Order['id'];
@@ -372,10 +399,10 @@ export interface OrderGroup {
 }
 
 export enum CreditCardBrand {
-  MASTERCARD = 'Mastercard',
-  MAESTRO = 'Maestro',
-  VISA = 'Visa',
-  CB = 'CB',
+  MASTERCARD = 'mastercard',
+  MAESTRO = 'maestro',
+  VISA = 'visa',
+  CB = 'cb',
 }
 
 // Credit Card
@@ -416,6 +443,22 @@ export interface OrderPaymentInfo {
   payment_info: Payment;
 }
 
+export enum PaymentScheduleState {
+  PENDING = 'pending',
+  PAID = 'paid',
+  REFUSED = 'refused',
+}
+
+export interface PaymentInstallment {
+  id: string;
+  amount: number;
+  currency: string;
+  due_date: string;
+  state: PaymentScheduleState;
+}
+
+export type PaymentSchedule = readonly PaymentInstallment[];
+
 // - API
 export interface AddressCreationPayload extends Omit<Address, 'id' | 'is_main'> {
   is_main?: boolean;
@@ -424,7 +467,7 @@ export interface AddressCreationPayload extends Omit<Address, 'id' | 'is_main'>
 interface AbstractOrderProductCreationPayload {
   product_id: Product['id'];
   order_group_id?: OrderGroup['id'];
-  has_consent_to_terms: boolean;
+  billing_address: Omit<Address, 'id' | 'is_main'>;
 }
 
 interface OrderCertificateCreationPayload extends AbstractOrderProductCreationPayload {
@@ -436,15 +479,13 @@ export interface OrderCredentialCreationPayload extends AbstractOrderProductCrea
 
 export type OrderCreationPayload = OrderCertificateCreationPayload | OrderCredentialCreationPayload;
 
-interface OrderAbortPayload {
-  id: Order['id'];
-  payment_id?: string;
-}
+export type OrderSubmitInstallmentPayment = {
+  credit_card_id?: string;
+};
 
-interface OrderSubmitPayload {
+interface OrderSetPaymentMethodPayload {
   id: Order['id'];
-  billing_address: Omit<Address, 'id' | 'is_main'>;
-  credit_card_id?: CreditCard['id'];
+  credit_card_id: CreditCard['id'];
 }
 
 export interface PaginatedResourceQuery extends ResourcesQuery {
@@ -539,14 +580,15 @@ interface APIUser {
     update(payload: Address): Promise<Address>;
   };
   creditCards: {
-    create(payload: Omit<CreditCard, 'id'>): Promise<CreditCard>;
     delete(id: CreditCard['id']): Promise<void>;
+    get(): Promise<PaginatedResponse<CreditCard>>;
     get(filters?: ResourcesQuery): Promise<CreditCard>;
     get(): Promise<CreditCard[]>;
     update(payload: CreditCard): Promise<CreditCard>;
+    tokenize(): Promise<Payment>;
   };
   orders: {
-    abort(payload: OrderAbortPayload): Promise<void>;
+    cancel(id: Order['id']): Promise<void>;
     create(payload: OrderCreationPayload): Promise<CredentialOrder | CertificateOrder>;
     get<Filters extends OrderResourcesQuery = OrderResourcesQuery>(
       filters?: Filters,
@@ -556,8 +598,12 @@ interface APIUser {
     invoice: {
       download(payload: { order_id: Order['id']; invoice_reference: string }): Promise<File>;
     };
-    submit(payload: OrderSubmitPayload): Promise<OrderPaymentInfo>;
     submit_for_signature(id: string): Promise<ContractInvitationLinkResponse>;
+    submit_installment_payment(
+      id: string,
+      payload?: OrderSubmitInstallmentPayment,
+    ): Promise<Payment>;
+    set_payment_method(payload: OrderSetPaymentMethodPayload): Promise<void>;
   };
   certificates: {
     download(id: string): Promise<File>;
@@ -614,6 +660,9 @@ export interface API {
       : Promise<PaginatedResponse<CourseListItem>>;
     products: {
       get(filters?: CourseProductQueryFilters): Promise<Nullable<CourseProductRelation>>;
+      paymentSchedule: {
+        get(filters?: CourseProductQueryFilters): Promise<Nullable<PaymentSchedule>>;
+      };
     };
     orders: {
       get(

package/js/utils/OrderHelper/index.ts

@@ -1,49 +1,52 @@
 import {
-  OrderEnrollment,
   ACTIVE_ORDER_STATES,
+  ENROLLABLE_ORDER_STATES,
+  NestedCourseOrder,
   Order,
+  OrderEnrollment,
   OrderState,
-  ContractDefinition,
-  NestedCourseOrder,
+  PURCHASABLE_ORDER_STATES,
 } from 'types/Joanie';
 
 export enum OrderStatus {
+  ASSIGNED = 'assigned',
+  CANCELED = 'canceled',
+  COMPLETED = 'completed',
   DRAFT = 'draft',
-  SUBMITTED = 'submitted',
+  FAILED_PAYMENT = 'failed_payment',
+  NO_PAYMENT = 'no_payment',
+  PASSED = 'passed',
   PENDING = 'pending',
-  CANCELED = 'canceled',
-  WAITING_SIGNATURE = 'waiting_signature',
+  PENDING_PAYMENT = 'pending_payment',
   WAITING_COUNTER_SIGNATURE = 'waiting_counter_signature',
-  COMPLETED = 'completed',
-  ON_GOING = 'on_going',
+  WAITING_PAYMENT_METHOD = 'waiting_payment_method',
+  WAITING_SIGNATURE = 'waiting_signature',
 }
 
 /**
  * Helper class for orders
  */
 export class OrderHelper {
-  static getState(order: Order | NestedCourseOrder, contractDefinition?: ContractDefinition) {
-    const { certificate_id: certificateId } = order;
-
-    if (order.state === OrderState.VALIDATED) {
-      if (OrderHelper.orderNeedsSignature(order, contractDefinition)) {
-        return OrderStatus.WAITING_SIGNATURE;
-      }
-      if (OrderHelper.orderNeedsCounterSignature(order)) {
-        return OrderStatus.WAITING_COUNTER_SIGNATURE;
-      }
-      if (certificateId) {
-        return OrderStatus.COMPLETED;
-      } else {
-        return OrderStatus.ON_GOING;
-      }
+  static getState(order: Order | NestedCourseOrder) {
+    if (OrderHelper.allowEnrollment(order) && OrderHelper.orderNeedsCounterSignature(order)) {
+      return OrderStatus.WAITING_COUNTER_SIGNATURE;
+    }
+    if (order.state === OrderState.COMPLETED && order.certificate_id) {
+      return OrderStatus.PASSED;
     }
 
     const orderStatusMap = {
+      [OrderState.ASSIGNED]: OrderStatus.ASSIGNED,
+      [OrderState.CANCELED]: OrderStatus.CANCELED,
+      [OrderState.COMPLETED]: OrderStatus.COMPLETED,
       [OrderState.DRAFT]: OrderStatus.DRAFT,
-      [OrderState.SUBMITTED]: OrderStatus.SUBMITTED,
+      [OrderState.FAILED_PAYMENT]: OrderStatus.FAILED_PAYMENT,
+      [OrderState.NO_PAYMENT]: OrderStatus.NO_PAYMENT,
       [OrderState.PENDING]: OrderStatus.PENDING,
-      [OrderState.CANCELED]: OrderStatus.CANCELED,
+      [OrderState.PENDING_PAYMENT]: OrderStatus.PENDING_PAYMENT,
+      [OrderState.SIGNING]: OrderStatus.WAITING_SIGNATURE,
+      [OrderState.TO_SAVE_PAYMENT_METHOD]: OrderStatus.WAITING_PAYMENT_METHOD,
+      [OrderState.TO_SIGN]: OrderStatus.WAITING_SIGNATURE,
     };
 
     if (order.state in orderStatusMap) {
@@ -62,18 +65,8 @@ export class OrderHelper {
     return orders.find(filter);
   }
 
-  /**
-   * tell us if a order need to be sign by it's owner (the learner user).
-   */
-  static orderNeedsSignature(
-    order: Order | NestedCourseOrder,
-    contractDefinition?: ContractDefinition,
-  ) {
-    return (
-      order?.state === OrderState.VALIDATED &&
-      contractDefinition &&
-      !(order.contract && order.contract.student_signed_on)
-    );
+  static orderNeedsSignature(order: Order | NestedCourseOrder) {
+    return [OrderState.TO_SIGN, OrderState.SIGNING].includes(order.state);
   }
 
   /**
@@ -81,10 +74,25 @@ export class OrderHelper {
    */
   static orderNeedsCounterSignature(order: Order | NestedCourseOrder) {
     return (
-      order?.state === OrderState.VALIDATED &&
+      ACTIVE_ORDER_STATES.includes(order.state) &&
       order.contract &&
       order.contract.student_signed_on &&
       !order.contract.organization_signed_on
     );
   }
+
+  static allowEnrollment(order?: Order | NestedCourseOrder | OrderEnrollment) {
+    if (!order) return false;
+    return ENROLLABLE_ORDER_STATES.includes(order.state);
+  }
+
+  static isActive(order?: Order | NestedCourseOrder | OrderEnrollment) {
+    if (!order) return false;
+    return ACTIVE_ORDER_STATES.includes(order.state);
+  }
+
+  static isPurchasable(order?: Order | NestedCourseOrder | OrderEnrollment) {
+    if (!order) return true;
+    return PURCHASABLE_ORDER_STATES.includes(order.state);
+  }
 }

package/js/utils/PaymentScheduleHelper/index.spec.tsx

@@ -0,0 +1,78 @@
+/**
+ * Test suite for the helper `PaymentScheduleHelper`.
+ */
+import PaymentScheduleHelper from 'utils/PaymentScheduleHelper/index';
+import { PaymentInstallmentFactory } from 'utils/test/factories/joanie';
+import { PaymentScheduleState } from 'types/Joanie';
+
+describe('PaymentScheduleHelper', () => {
+  describe('getFailedInstallment', () => {
+    it('should return undefined if payment_schedule is undefined', () => {
+      const foundInstallment = PaymentScheduleHelper.getFailedInstallment(undefined);
+
+      expect(foundInstallment).toBeUndefined();
+    });
+
+    it('should return undefined if payment schedule does not have a failed installment', () => {
+      const schedule = PaymentInstallmentFactory({ state: PaymentScheduleState.PENDING }).many(3);
+      const foundInstallment = PaymentScheduleHelper.getFailedInstallment(schedule);
+
+      expect(foundInstallment).toBeUndefined();
+    });
+
+    it('should return the older failed installment', () => {
+      const schedule = [
+        PaymentInstallmentFactory({
+          state: PaymentScheduleState.PAID,
+          due_date: '2024-06-21',
+        }).one(),
+        PaymentInstallmentFactory({
+          state: PaymentScheduleState.REFUSED,
+          due_date: '2024-08-20',
+        }).one(),
+        PaymentInstallmentFactory({
+          state: PaymentScheduleState.REFUSED,
+          due_date: '2024-07-20',
+        }).one(),
+      ];
+      const foundInstallment = PaymentScheduleHelper.getFailedInstallment(schedule);
+
+      expect(foundInstallment?.due_date).toBe(schedule[2].due_date);
+    });
+  });
+
+  describe('getPendingInstallment', () => {
+    it('should return undefined if payment_schedule is undefined', () => {
+      const foundInstallment = PaymentScheduleHelper.getPendingInstallment(undefined);
+
+      expect(foundInstallment).toBeUndefined();
+    });
+
+    it('should return undefined if payment schedule does not have a pending installment', () => {
+      const schedule = PaymentInstallmentFactory({ state: PaymentScheduleState.PAID }).many(3);
+      const foundInstallment = PaymentScheduleHelper.getPendingInstallment(schedule);
+
+      expect(foundInstallment).toBeUndefined();
+    });
+
+    it('should return the older pending installment', () => {
+      const schedule = [
+        PaymentInstallmentFactory({
+          state: PaymentScheduleState.PAID,
+          due_date: '2024-06-21',
+        }).one(),
+        PaymentInstallmentFactory({
+          state: PaymentScheduleState.PENDING,
+          due_date: '2024-08-20',
+        }).one(),
+        PaymentInstallmentFactory({
+          state: PaymentScheduleState.PENDING,
+          due_date: '2024-07-20',
+        }).one(),
+      ];
+
+      const foundInstallment = PaymentScheduleHelper.getPendingInstallment(schedule);
+      expect(foundInstallment?.due_date).toBe(schedule[2].due_date);
+    });
+  });
+});

package/js/utils/PaymentScheduleHelper/index.ts

@@ -0,0 +1,30 @@
+import { PaymentInstallment, PaymentSchedule, PaymentScheduleState } from 'types/Joanie';
+import { Maybe } from 'types/utils';
+
+export default class PaymentScheduleHelper {
+  static #sortByDueDateAsc(a: PaymentInstallment, b: PaymentInstallment) {
+    const dateA = new Date(a.due_date).getTime();
+    const dateB = new Date(b.due_date).getTime();
+    return dateA - dateB;
+  }
+
+  static #getInstallmentByState(
+    payment_schedule: Maybe<PaymentSchedule>,
+    state: PaymentScheduleState,
+  ) {
+    if (!payment_schedule) return undefined;
+
+    const installments = [...payment_schedule];
+    return installments
+      ?.sort(this.#sortByDueDateAsc)
+      .find((installment) => installment.state === state);
+  }
+
+  static getFailedInstallment(payment_schedule: Maybe<PaymentSchedule>) {
+    return this.#getInstallmentByState(payment_schedule, PaymentScheduleState.REFUSED);
+  }
+
+  static getPendingInstallment(payment_schedule: Maybe<PaymentSchedule>) {
+    return this.#getInstallmentByState(payment_schedule, PaymentScheduleState.PENDING);
+  }
+}