richie-education 3.2.1 → 3.2.2-dev26

package/js/types/Joanie.ts

@@ -3,7 +3,7 @@ import type { Nullable } from 'types/utils';
 import { Resource, ResourcesQuery } from 'hooks/useResources';
 import { OrderResourcesQuery } from 'hooks/useOrders';
 import { Course as RichieCourse } from 'types/Course';
-import { Payment } from 'components/PaymentInterfaces/types';
+import { Payment, PaymentMethod } from 'components/PaymentInterfaces/types';
 import { JoanieUserProfile } from './User';
 
 // - Generic
@@ -65,6 +65,13 @@ export interface Contract {
 
 export type ContractLight = Pick<Contract, 'id' | 'organization_signed_on' | 'student_signed_on'>;
 
+export interface Agreement {
+  id: string;
+  batch_order: BatchOrderQuote;
+  abilities?: ContractAbilities;
+  organization_signed_on?: string;
+}
+
 export interface CourseListItem extends Resource {
   id: string;
   title: string;
@@ -343,6 +350,7 @@ export interface Order {
   organization: Organization;
   payment_schedule?: PaymentSchedule;
   credit_card_id?: CreditCard['id'];
+  from_batch_order?: boolean;
 }
 
 export interface CredentialOrder extends Order {
@@ -449,6 +457,156 @@ export interface Address {
   title: string;
 }
 
+// BatchOrder
+
+export interface Billing {
+  company_name?: string;
+  identification_number?: string;
+  contact_name?: string;
+  contact_email?: string;
+  address?: string;
+  postcode?: string;
+  city?: string;
+  country?: string;
+}
+
+export interface OfferingBatchOrder {
+  product: {
+    id: string;
+    title: string;
+  };
+  course: CourseListItem;
+}
+
+export enum BatchOrderState {
+  DRAFT = 'draft',
+  ASSIGNED = 'assigned',
+  QUOTED = 'quoted',
+  TO_SIGN = 'to_sign',
+  SIGNING = 'signing',
+  PENDING = 'pending',
+  PROCESS_PAYMENT = 'process_payment',
+  FAILED_PAYMENT = 'failed_payment',
+  CANCELED = 'canceled',
+  COMPLETED = 'completed',
+}
+
+export interface BatchOrder {
+  id?: string;
+  offering_id: string;
+  company_name: string;
+  identification_number: string;
+  vat_registration?: string;
+  address: string;
+  postcode: string;
+  city: string;
+  country: string;
+  administrative_lastname: string;
+  administrative_firstname: string;
+  administrative_profession: string;
+  administrative_email: string;
+  administrative_telephone: string;
+  signatory_lastname: string;
+  signatory_firstname: string;
+  signatory_profession: string;
+  signatory_email: string;
+  signatory_telephone: string;
+  billing_address?: Billing;
+  nb_seats: number;
+  payment_method: PaymentMethod;
+  funding_entity?: string;
+  funding_amount?: number;
+  organization_id?: string;
+}
+
+export interface BatchOrderRead {
+  id: string;
+  owner: string;
+  total: number;
+  currency: string;
+  organization: Organization;
+  main_invoice_reference?: string;
+  contract_id?: string;
+  company_name: string;
+  identification_number: string;
+  vat_registration?: string;
+  address: string;
+  postcode: string;
+  city: string;
+  country: string;
+  nb_seats: number;
+  payment_method: PaymentMethod;
+  state: BatchOrderState;
+  administrative_lastname: string;
+  administrative_firstname: string;
+  administrative_profession: string;
+  administrative_email: string;
+  administrative_telephone: string;
+  signatory_lastname: string;
+  signatory_firstname: string;
+  signatory_profession: string;
+  signatory_email: string;
+  signatory_telephone: string;
+  billing_address?: Billing;
+  funding_entity?: string;
+  funding_amount?: number;
+  offering: OfferingBatchOrder;
+}
+
+export interface Relation {
+  id: string;
+  product: {
+    title: string;
+    id: string;
+  };
+  course: {
+    title: string;
+    id: string;
+  };
+}
+
+export type BatchOrderAction =
+  | 'confirm_quote'
+  | 'confirm_purchase_order'
+  | 'confirm_bank_transfer'
+  | 'submit_for_signature';
+
+export type BatchOrderAvailableActions = {
+  [K in BatchOrderAction]: boolean;
+} & {
+  next_action: BatchOrderAction | null;
+};
+
+export interface BatchOrderQuote {
+  id: string;
+  owner_name: string;
+  organization_id: string;
+  state: BatchOrderState;
+  company_name: string;
+  relation: Relation;
+  payment_method: PaymentMethod;
+  contract_submitted: boolean;
+  nb_seats: number;
+  available_actions: BatchOrderAvailableActions;
+}
+
+export interface Definition {
+  id: string;
+  title: string;
+  description: string;
+  name: string;
+  body: string;
+  language: string;
+}
+
+export interface OrganizationQuote {
+  id: string;
+  organization_signed_on: string;
+  has_purchase_order: boolean;
+  batch_order: BatchOrderQuote;
+  total: number;
+}
+
 // Wishlist
 export interface CourseWish extends Resource {
   status: boolean;
@@ -487,6 +645,7 @@ export interface PaymentPlan {
   discount?: string;
   discounted_price?: number;
   payment_schedule: PaymentSchedule;
+  from_batch_order: boolean;
 }
 
 // - API
@@ -563,6 +722,16 @@ export interface OfferingQueryFilters extends PaginatedResourceQuery {
   product_type?: ProductType;
   query?: string;
 }
+export interface BatchOrderQueryFilters extends PaginatedResourceQuery {
+  id?: BatchOrderRead['id'];
+}
+export interface OrganizationQuoteQueryFilters extends PaginatedResourceQuery {
+  organization_id?: Organization['id'];
+  batch_order_id?: BatchOrder['id'];
+  quote_id?: OrganizationQuote['id'];
+  id?: OrganizationQuote['id'];
+  payload?: any;
+}
 
 export enum ContractState {
   UNSIGNED = 'unsigned',
@@ -580,6 +749,7 @@ export interface OrganizationContractSignatureLinksFilters {
   contracts_ids?: string[];
   organization_id: Organization['id'];
   offering_ids?: Offering['id'][];
+  from_batch_order?: boolean;
 }
 
 export interface ContractInvitationLinkResponse {
@@ -638,6 +808,17 @@ interface APIUser {
     ): Promise<Payment>;
     set_payment_method(payload: OrderSetPaymentMethodPayload): Promise<void>;
   };
+  batchOrders: {
+    create(payload: BatchOrder): Promise<BatchOrderRead>;
+    get<Filters extends PaginatedResourceQuery = PaginatedResourceQuery>(
+      filters?: Filters,
+    ): Filters extends { id: string }
+      ? Promise<Nullable<BatchOrderRead>>
+      : Promise<PaginatedResponse<BatchOrderRead>>;
+    submit_for_payment: {
+      create(filters: ResourcesQuery): Promise<any>;
+    };
+  };
   certificates: {
     download(id: string): Promise<File>;
     get<Filters extends CertificateResourcesQuery = CertificateResourcesQuery>(
@@ -674,9 +855,11 @@ interface APIUser {
       create: ({
         organization_id,
         offering_id,
+        from_batch_order,
       }: {
         organization_id?: Organization['id'];
         offering_id?: Offering['id'];
+        from_batch_order?: boolean;
       }) => Promise<{ url: string }>;
       get: (id: string) => Promise<File>;
     };
@@ -719,6 +902,33 @@ export interface API {
         filters?: OrganizationContractSignatureLinksFilters,
       ): Promise<OrganizationContractInvitationLinkResponse>;
     };
+    quotes: {
+      get(
+        filters?: OrganizationQuoteQueryFilters,
+      ): OrganizationQuoteQueryFilters extends { id: string }
+        ? Promise<Nullable<OrganizationQuote>>
+        : Promise<PaginatedResponse<OrganizationQuote>>;
+      update(filters: OrganizationQuoteQueryFilters): Promise<any>;
+      purchase_order: {
+        update(filters: OrganizationQuoteQueryFilters): Promise<any>;
+      };
+      bank_transfer: {
+        create(filters: OrganizationQuoteQueryFilters): Promise<any>;
+      };
+      submit_for_signature: {
+        create(filters: OrganizationQuoteQueryFilters): Promise<any>;
+      };
+      download_quote: {
+        get(filters: OrganizationQuoteQueryFilters): Promise<any>;
+      };
+    };
+    agreements: {
+      get(
+        filters?: ContractResourceQuery,
+      ): ContractResourceQuery extends { id: string }
+        ? Promise<Nullable<Agreement>>
+        : Promise<PaginatedResponse<Agreement>>;
+    };
   };
   courseRuns: {
     get(
@@ -731,6 +941,11 @@ export interface API {
     ): Filters extends { id: string }
       ? Promise<Nullable<Offering>>
       : Promise<PaginatedResponse<OfferingLight>>;
+    organizations: {
+      get<Filters extends ResourcesQuery = ResourcesQuery>(
+        filters?: Filters,
+      ): Filters extends { id: string } ? Promise<Nullable<Organization>> : Promise<Organization[]>;
+    };
   };
   contractDefinitions: {
     previewTemplate(id: string): Promise<File>;

package/js/utils/AbilitiesHelper/agreementAbilities.ts

@@ -0,0 +1,14 @@
+import { Agreement } from 'types/Joanie';
+import { AgreementActions } from './types';
+
+type AgreementAbilityList = {
+  [action in AgreementActions]: (entities: Agreement) => boolean;
+};
+
+const abilities: AgreementAbilityList = {
+  [AgreementActions.SIGN]: (agreement: Agreement) => {
+    return agreement?.abilities?.sign === true;
+  },
+};
+
+export default abilities;

package/js/utils/AbilitiesHelper/index.ts

@@ -1,5 +1,6 @@
 import { Maybe, Nullable } from 'types/utils';
 import contractAbilities from 'utils/AbilitiesHelper/contractAbilities';
+import agreementAbilities from 'utils/AbilitiesHelper/agreementAbilities';
 import joanieUserProfileAbilities from './joanieUserProfileAbilities';
 import {
   Entity,
@@ -8,6 +9,8 @@ import {
   isJoanieUserProfileEntity,
   isContractEntity,
   ContractActions,
+  isAgreementEntity,
+  AgreementActions,
 } from './types';
 
 // further actions can be added here
@@ -37,6 +40,10 @@ const can = (entities: Maybe<Nullable<Entity | Entity[]>>, action: Actions) => {
       return contractAbilities[action as ContractActions](entity);
     }
 
+    if (isAgreementEntity(entity)) {
+      return agreementAbilities[action as AgreementActions](entity);
+    }
+
     return false;
   });
 

package/js/utils/AbilitiesHelper/types.ts

@@ -1,5 +1,5 @@
 import { JoanieUserProfile } from 'types/User';
-import { Contract } from 'types/Joanie';
+import { Agreement, Contract } from 'types/Joanie';
 
 export enum JoanieUserProfileActions {
   ACCESS_TEACHER_DASHBOARD = 'access_teacher_dashboard',
@@ -9,6 +9,10 @@ export enum ContractActions {
   SIGN = 'sign',
 }
 
+export enum AgreementActions {
+  SIGN = 'sign',
+}
+
 const JOANIE_PROFILE_KEYS = [
   'abilities',
   'full_name',
@@ -30,7 +34,12 @@ export const isContractEntity = (entity: Entity): entity is Contract => {
   return CONTRACT_KEYS.every((key) => entity.hasOwnProperty(key));
 };
 
+export function isAgreementEntity(entity: any): entity is Agreement {
+  const AGREEMENT_KEYS = ['batch_order', 'abilities', 'id'];
+  return AGREEMENT_KEYS.every((key) => entity.hasOwnProperty(key));
+}
+
 // further entities and entity actions can be added here
 // like Entity = JoanieUserProfileEntity | CourseEntity
-export type Entity = JoanieUserProfile | Contract;
-export type Actions = JoanieUserProfileActions | ContractActions;
+export type Entity = JoanieUserProfile | Contract | Agreement;
+export type Actions = JoanieUserProfileActions | ContractActions | AgreementActions;

package/js/utils/ObjectHelper/index.ts

@@ -11,4 +11,24 @@ export class ObjectHelper {
     keys.forEach((key) => delete cleanedObject[key]);
     return cleanedObject;
   }
+
+  static removeEmptyFields<T>(obj: T): T | undefined {
+    if (Array.isArray(obj)) {
+      const arr = obj.map((v) => this.removeEmptyFields(v)).filter((v) => v !== undefined);
+      return arr.length > 0 ? (arr as unknown as T) : undefined;
+    }
+    if (obj && typeof obj === 'object') {
+      const cleanedEntries = Object.entries(obj)
+        .map(([k, v]) => [k, this.removeEmptyFields(v)])
+        .filter(([, v]) => {
+          if (v === undefined || v === null) return false;
+          if (typeof v === 'string' && v.trim() === '') return false;
+          if (Array.isArray(v) && v.length === 0) return false;
+          if (typeof v === 'object' && Object.keys(v).length === 0) return false;
+          return true;
+        });
+      return cleanedEntries.length > 0 ? (Object.fromEntries(cleanedEntries) as T) : undefined;
+    }
+    return obj;
+  }
 }

package/js/utils/OrderHelper/index.ts

@@ -104,4 +104,14 @@ export class OrderHelper {
     if (!order) return true;
     return PURCHASABLE_ORDER_STATES.includes(order.state);
   }
+
+  static isFreeWithVoucher(order?: Order) {
+    if (!order) return false;
+    return order.total === 0;
+  }
+
+  static isFreeFromBatchOrder(order?: Order) {
+    if (!order) return false;
+    return order.from_batch_order === true;
+  }
 }

package/js/utils/test/factories/joanie.ts

@@ -38,8 +38,16 @@ import {
   TargetCourse,
   UserLight,
   PaymentPlan,
+  OfferingBatchOrder,
+  BatchOrderRead,
+  BatchOrder,
+  BatchOrderState,
+  OrganizationQuote,
+  BatchOrderQuote,
+  Relation,
+  Agreement,
 } from 'types/Joanie';
-import { Payment, PaymentProviders } from 'components/PaymentInterfaces/types';
+import { Payment, PaymentMethod, PaymentProviders } from 'components/PaymentInterfaces/types';
 import { CourseStateFactory } from 'utils/test/factories/richie';
 import { FactoryHelper } from 'utils/test/factories/helper';
 import { JoanieUserApiAbilityActions, JoanieUserProfile } from 'types/User';
@@ -166,6 +174,51 @@ export const OrganizationFactory = factory((): Organization => {
   };
 });
 
+export const RelationFactory = factory((): Relation => {
+  return {
+    id: faker.string.uuid(),
+    product: {
+      id: faker.string.uuid(),
+      title: faker.commerce.productName(),
+    },
+    course: {
+      id: faker.string.uuid(),
+      title: faker.lorem.words({ min: 2, max: 5 }),
+    },
+  };
+});
+
+export const BatchOrderQuoteFactory = factory((): BatchOrderQuote => {
+  return {
+    id: faker.string.uuid(),
+    owner_name: faker.person.firstName(),
+    organization_id: faker.string.uuid(),
+    state: faker.helpers.arrayElement(Object.values(BatchOrderState)),
+    company_name: faker.company.name(),
+    relation: RelationFactory().one(),
+    payment_method: faker.helpers.arrayElement(Object.values(PaymentMethod)),
+    contract_submitted: faker.datatype.boolean(),
+    nb_seats: faker.number.int({ min: 1, max: 100 }),
+    available_actions: {
+      confirm_quote: false,
+      confirm_purchase_order: false,
+      confirm_bank_transfer: false,
+      submit_for_signature: false,
+      next_action: null,
+    },
+  };
+});
+
+export const OrganizationQuoteFactory = factory((): OrganizationQuote => {
+  return {
+    id: faker.string.uuid(),
+    organization_signed_on: faker.date.past().toISOString(),
+    has_purchase_order: faker.datatype.boolean(),
+    batch_order: BatchOrderQuoteFactory().one(),
+    total: faker.number.float({ min: 1, max: 100 }),
+  };
+});
+
 export const OrganizationLightFactory = factory((): OrganizationLight => {
   return {
     code: faker.string.alphanumeric(5),
@@ -173,6 +226,17 @@ export const OrganizationLightFactory = factory((): OrganizationLight => {
   };
 });
 
+export const AgreementFactory = factory((): Agreement => {
+  return {
+    id: faker.string.uuid(),
+    batch_order: BatchOrderQuoteFactory().one(),
+    abilities: {
+      sign: faker.datatype.boolean(),
+    },
+    organization_signed_on: faker.date.past().toISOString(),
+  };
+});
+
 export const CertificationDefinitionFactory = factory((): CertificateDefinition => {
   return {
     id: faker.string.uuid(),
@@ -336,6 +400,16 @@ export const OfferingFactory = factory((): Offering => {
   };
 });
 
+export const OfferingBatchOrderFactory = factory((): OfferingBatchOrder => {
+  return {
+    product: {
+      id: faker.string.uuid(),
+      title: faker.string.alphanumeric(5),
+    },
+    course: CourseListItemFactory().one(),
+  };
+});
+
 export const CourseListItemFactory = factory((): CourseListItem => {
   return {
     id: faker.string.uuid(),
@@ -367,6 +441,7 @@ export const PaymentPlanFactory = factory((): PaymentPlan => {
     price: faker.number.int({ min: 1, max: 1000, multipleOf: 10 }),
     discount: undefined,
     discounted_price: undefined,
+    from_batch_order: false,
   };
 });
 
@@ -391,6 +466,78 @@ export const OrderLiteFactory = factory((): OrderLite => {
   };
 });
 
+export const BatchOrderFactory = factory((): BatchOrder => {
+  return {
+    id: faker.string.uuid(),
+    offering_id: faker.string.uuid(),
+    company_name: faker.company.name(),
+    identification_number: faker.string.alphanumeric(14),
+    vat_registration: faker.string.alphanumeric(11),
+    address: faker.location.streetAddress(),
+    postcode: faker.location.zipCode(),
+    city: faker.location.city(),
+    country: faker.location.countryCode(),
+    administrative_lastname: faker.person.lastName(),
+    administrative_firstname: faker.person.firstName(),
+    administrative_profession: faker.person.jobTitle(),
+    administrative_email: faker.internet.email(),
+    administrative_telephone: faker.phone.number(),
+    signatory_lastname: faker.person.lastName(),
+    signatory_firstname: faker.person.firstName(),
+    signatory_profession: faker.person.jobTitle(),
+    signatory_email: faker.internet.email(),
+    signatory_telephone: faker.phone.number(),
+    nb_seats: faker.number.int({ min: 1, max: 200 }),
+    payment_method: faker.helpers.arrayElement([
+      PaymentMethod.CARD_PAYMENT,
+      PaymentMethod.BANK_TRANSFER,
+      PaymentMethod.PURCHASE_ORDER,
+    ]),
+    funding_entity: faker.company.name(),
+    funding_amount: faker.number.int({ min: 100, max: 10000 }),
+    organization_id: faker.string.uuid(),
+  };
+});
+
+export const BatchOrderReadFactory = factory((): BatchOrderRead => {
+  return {
+    id: faker.string.uuid(),
+    owner: faker.internet.email(),
+    total: faker.number.int({ min: 100, max: 5000 }),
+    currency: faker.finance.currencyCode(),
+    organization: OrganizationFactory().one(),
+    main_invoice_reference: faker.string.alphanumeric(10),
+    contract_id: faker.string.alphanumeric(12),
+    company_name: faker.company.name(),
+    identification_number: faker.string.alphanumeric(14),
+    vat_registration: faker.string.alphanumeric(11),
+    address: faker.location.streetAddress(),
+    postcode: faker.location.zipCode(),
+    city: faker.location.city(),
+    country: faker.location.countryCode(),
+    nb_seats: faker.number.int({ min: 1, max: 200 }),
+    payment_method: faker.helpers.arrayElement([
+      PaymentMethod.CARD_PAYMENT,
+      PaymentMethod.BANK_TRANSFER,
+      PaymentMethod.PURCHASE_ORDER,
+    ]),
+    state: faker.helpers.arrayElement([BatchOrderState.PENDING, BatchOrderState.COMPLETED]),
+    administrative_lastname: faker.person.lastName(),
+    administrative_firstname: faker.person.firstName(),
+    administrative_profession: faker.person.jobTitle(),
+    administrative_email: faker.internet.email(),
+    administrative_telephone: faker.phone.number(),
+    signatory_lastname: faker.person.lastName(),
+    signatory_firstname: faker.person.firstName(),
+    signatory_profession: faker.person.jobTitle(),
+    signatory_email: faker.internet.email(),
+    signatory_telephone: faker.phone.number(),
+    funding_entity: faker.company.name(),
+    funding_amount: faker.number.int({ min: 100, max: 10000 }),
+    offering: OfferingBatchOrderFactory().one(),
+  };
+});
+
 export const NestedCertificateOrderFactory = factory((): NestedCertificateOrder => {
   return {
     id: faker.string.uuid(),
@@ -494,6 +641,11 @@ export const SaleTunnelContextFactory = factory(
     props: {} as SaleTunnelProps,
     billingAddress: undefined,
     setBillingAddress: noop,
+    batchOrder: undefined,
+    setBatchOrder: noop,
+    batchOrderFormMethods: undefined,
+    setBatchOrderFormMethods: noop,
+    validateBatchOrder: noop,
     setCreditCard: noop,
     setHasWaivedWithdrawalRight: noop,
     hasWaivedWithdrawalRight: false,
@@ -503,5 +655,8 @@ export const SaleTunnelContextFactory = factory(
     runSubmitCallbacks: () => new Promise((resolve) => resolve()),
     nextStep: noop,
     setVoucherCode: noop,
+    setSchedule: noop,
+    needsPayment: true,
+    setNeedsPayment: noop,
   }),
 );

package/js/widgets/Dashboard/components/DashboardBatchOrderLoader/_styles.scss

@@ -0,0 +1,14 @@
+.dashboard-order-loader__banners {
+  .banner {
+    margin-top: 0;
+
+    a {
+      color: white;
+      text-decoration: underline;
+
+      &:hover {
+        color: white;
+      }
+    }
+  }
+}

package/js/widgets/Dashboard/components/DashboardBatchOrderLoader/index.tsx

@@ -0,0 +1,32 @@
+import { useParams } from 'react-router';
+import { defineMessages, FormattedMessage } from 'react-intl';
+import { Spinner } from 'components/Spinner';
+import { useBatchOrder } from 'hooks/useBatchOrder';
+import { DashboardItemBatchOrder } from '../DashboardItem/BatchOrder';
+
+const messages = defineMessages({
+  loading: {
+    defaultMessage: 'Loading order ...',
+    description: 'Message displayed while loading an order',
+    id: 'components.DashboardOrderLoader.loading',
+  },
+});
+
+export const DashboardBatchOrderLoader = () => {
+  const params = useParams<{ batchOrderId: string }>();
+  const { item: batchOrder, states } = useBatchOrder(params.batchOrderId);
+  const fetching = states.isPending;
+
+  return (
+    <>
+      {fetching && !batchOrder && (
+        <Spinner aria-labelledby="loading-courses-data">
+          <span id="loading-courses-data">
+            <FormattedMessage {...messages.loading} />
+          </span>
+        </Spinner>
+      )}
+      {batchOrder && <DashboardItemBatchOrder batchOrder={batchOrder} showDetails />}
+    </>
+  );
+};

package/js/widgets/Dashboard/components/DashboardCard/index.spec.tsx

@@ -17,4 +17,22 @@ describe('<DashboardCard/>', () => {
     fireEvent.click(screen.getByTestId('dashboard-card__header__toggle'));
     expect(screen.getByTestId('dashboard-card__wrapper').style.height).toBe('0px');
   });
+
+  it('is not expanded', async () => {
+    render(
+      <DashboardCard
+        defaultExpanded={false}
+        header="My header"
+        footer={<Button color="primary">Update</Button>}
+      >
+        Content here
+      </DashboardCard>,
+    );
+
+    expect(screen.getByTestId('dashboard-card__wrapper').style.height).toBe('0px');
+    const card = screen.getByText('My header').closest('.dashboard-card');
+    expect(card).toHaveClass('dashboard-card--closed');
+    fireEvent.click(screen.getByTestId('dashboard-card__header__toggle'));
+    expect(card).toHaveClass('dashboard-card--opened');
+  });
 });