richie-education 2.24.0 → 2.25.0-b2.dev101

package/js/types/Joanie.ts

@@ -1,14 +1,15 @@
-import type { CourseState } from 'types';
-import type { Nullable } from 'types/utils';
+import type { CourseState, OpenEdXEnrollment } from 'types';
+import type { Maybe, Nullable } from 'types/utils';
 import { Resource, ResourcesQuery } from 'hooks/useResources';
 import { OrderResourcesQuery } from 'hooks/useOrders';
 import { Course as RichieCourse } from 'types/Course';
+import { JoanieUserProfile } from './User';
 
 // - Generic
 export interface PaginatedResponse<T> {
   count: number;
   next: string | null;
-  prev: string | null;
+  previous: string | null;
   results: Array<T>;
 }
 
@@ -21,30 +22,40 @@ export interface Organization {
   id: string;
   code: string;
   title: string;
-  logo: {
-    filename: string;
-    src: string;
-    srcset: string[];
-    height: number;
-    width: number;
-    size: number;
-  };
+  logo: Nullable<JoanieFile>;
+}
+
+export interface ContractDefinition {
+  id: string;
+  description: string;
+  language: string;
+  title: string;
+}
+
+type ContractAbilities = {
+  sign: boolean;
+};
+
+export interface Contract {
+  id: string;
+  abilities?: ContractAbilities;
+  created_on: string;
+  student_signed_on: Nullable<string>;
+  organization_signed_on: Nullable<string>;
+  organization_signatory: Nullable<JoanieUserProfile>;
+  definition: ContractDefinition;
+  order: NestedCertificateOrder | NestedCredentialOrder;
 }
 
 export interface CourseListItem extends Resource {
   id: string;
   title: string;
   code: string;
-  course_runs: CourseRun[];
+  course_run_ids: string[];
   organizations: Organization[];
   selling_organizations: Organization[];
-  cover: Nullable<{
-    filename: string;
-    url: string;
-    height: number;
-    width: number;
-  }>;
-  products: Product[];
+  cover: Nullable<JoanieFile>;
+  product_ids: string[];
   state: CourseState;
   created_on: string;
 }
@@ -59,7 +70,7 @@ export interface CourseRun {
   start: string;
   state: CourseState;
   title: string;
-  course?: CourseLight;
+  course: CourseLight;
   languages: string[];
 }
 
@@ -74,7 +85,7 @@ export interface Certificate {
   id: string;
   issued_on: string;
   certificate_definition: CertificateDefinition;
-  order: Order;
+  order: NestedCertificateOrder | NestedCredentialOrder;
 }
 
 // - Organization
@@ -87,7 +98,6 @@ export interface OrganizationLight {
 export enum ProductType {
   CERTIFICATE = 'certificate',
   CREDENTIAL = 'credential',
-  ENROLLMENT = 'enrollment',
 }
 
 export interface Product {
@@ -101,20 +111,36 @@ export interface Product {
   certificate_definition: CertificateDefinition;
   target_courses: TargetCourse[];
   created_on: string;
-  orders: Order['id'][];
   remaining_order_count?: number | null;
+  state: CourseState;
+  instructions: Nullable<string>;
+  contract_definition?: ContractDefinition;
+}
+
+export interface CredentialProduct extends Product {
+  type: ProductType.CREDENTIAL;
+}
+
+export interface CertificateProduct extends Product {
+  type: ProductType.CERTIFICATE;
 }
+export const isCertificateProduct = (
+  entity: Product | CertificateProduct | CredentialProduct,
+): entity is CertificateProduct => {
+  return entity.type === ProductType.CERTIFICATE;
+};
 
 export interface CourseProduct extends Product {
   order: Nullable<OrderLite>;
-  target_courses: TargetCourse[];
 }
 
 export interface CourseProductRelation {
   id: string;
-  course: CourseListItem;
+  course: CourseLight;
+  organizations: Organization[];
   product: Product;
   created_on: string;
+  order_groups: OrderGroup[];
 }
 export function isCourseProductRelation(
   entity: CourseListItem | CourseProductRelation | RichieCourse,
@@ -122,6 +148,15 @@ export function isCourseProductRelation(
   return 'course' in entity && 'product' in entity;
 }
 
+export interface JoanieFile {
+  filename: string;
+  height: number;
+  size: number;
+  src: string;
+  srcset: string;
+  width: number;
+}
+
 // - Course
 export interface AbstractCourse {
   id: string;
@@ -129,40 +164,17 @@ export interface AbstractCourse {
   organizations: OrganizationLight[];
   title: string;
   course_runs: CourseRun[];
-  cover?: JoanieFile;
 }
 
-export interface JoanieFile {
-  filename: string;
-  height: number;
-  size: number;
-  src: string;
-  srcset: string;
-  width: number;
-}
+export type CourseLight = Pick<AbstractCourse, 'id' | 'code' | 'title'> & {
+  cover: Nullable<JoanieFile>;
+};
 
 export interface TargetCourse extends AbstractCourse {
   is_graded: boolean;
   position: number;
 }
 
-export type OrderLite = Pick<
-  Order,
-  | 'id'
-  | 'created_on'
-  | 'state'
-  | 'total'
-  | 'enrollments'
-  | 'product'
-  | 'main_proforma_invoice'
-  | 'certificate'
->;
-
-export interface CourseLight extends AbstractCourse {
-  products: CourseProduct[];
-  orders?: OrderLite[];
-}
-
 // Enrollment
 export enum EnrollmentState {
   FAILED = 'failed',
@@ -176,29 +188,124 @@ export interface Enrollment {
   course_run: CourseRun;
   was_created_by_order: boolean;
   created_on: string;
+  orders: OrderEnrollment[];
+  product_relations: CourseProductRelation[];
+  certificate_id: Nullable<string>;
+}
+export const isEnrollment = (obj: unknown | Enrollment | OpenEdXEnrollment): obj is Enrollment => {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+  return (
+    'is_active' in obj &&
+    'state' in obj &&
+    'course_run' in obj &&
+    'was_created_by_order' in obj &&
+    'created_on' in obj &&
+    'orders' in obj &&
+    'product_relations' in obj &&
+    'certificate_id' in obj
+  );
+};
+
+export interface EnrollmentLight {
+  id: string;
+  is_active: boolean;
+  state: EnrollmentState;
+  course_run: CourseRun;
+  was_created_by_order: boolean;
+  created_on: string;
 }
 
 // Order
 export enum OrderState {
+  DRAFT = 'draft',
+  SUBMITTED = 'submitted',
   CANCELED = 'canceled',
-  FAILED = 'failed',
   PENDING = 'pending',
   VALIDATED = 'validated',
 }
 
+export const ACTIVE_ORDER_STATES = [OrderState.PENDING, OrderState.VALIDATED, OrderState.SUBMITTED];
+
 export interface Order {
   id: string;
-  course?: CourseLight['code'] | CourseLight;
   created_on: string;
-  enrollments: Enrollment[];
-  main_proforma_invoice: string;
-  certificate?: string;
+  target_enrollments: Enrollment[];
+  main_invoice_reference: string;
+  certificate_id?: Certificate['id'];
+  contract?: Contract;
   owner: string;
   total: number;
   total_currency: string;
   state: OrderState;
-  product: Product['id'];
+  product_id: Product['id'];
   target_courses: TargetCourse[];
+  course: Maybe<CourseLight>;
+  enrollment: Maybe<EnrollmentLight>;
+  organization_id: Organization['id'];
+  order_group_id?: OrderGroup['id'];
+}
+
+export interface CredentialOrder extends Order {
+  course: CourseLight;
+  enrollment: undefined;
+}
+
+export interface CredentialOrderWithPaymentInfo extends CredentialOrder {
+  payment_info: Payment | PaymentOneClick;
+}
+
+export interface CertificateOrder extends Order {
+  course: undefined;
+  enrollment: EnrollmentLight;
+  target_courses: [];
+}
+
+export interface CertificateOrderWithPaymentInfo extends CertificateOrder {
+  payment_info: Payment | PaymentOneClick;
+}
+
+export type OrderLite = Pick<
+  Order,
+  | 'id'
+  | 'created_on'
+  | 'state'
+  | 'total'
+  | 'target_enrollments'
+  | 'product_id'
+  | 'main_invoice_reference'
+  | 'certificate_id'
+>;
+
+export interface AbstractNestedOrder {
+  id: string;
+  organization: Organization;
+  product_title: string;
+  owner_name: string;
+}
+export interface NestedCertificateOrder extends AbstractNestedOrder {
+  course: undefined;
+  enrollment: EnrollmentLight;
+}
+export const isNestedCredentialOrder = (
+  obj: NestedCertificateOrder | NestedCredentialOrder,
+): obj is NestedCredentialOrder => {
+  return !obj.enrollment && !!obj.course;
+};
+
+export interface NestedCredentialOrder extends AbstractNestedOrder {
+  course: CourseLight;
+  enrollment: undefined;
+}
+
+export type OrderEnrollment = Pick<Order, 'id' | 'state' | 'product_id' | 'certificate_id'>;
+
+export interface OrderGroup {
+  id: string;
+  is_active: boolean;
+  nb_seats: number;
+  nb_available_seats: number;
 }
 
 export enum CreditCardBrand {
@@ -249,7 +356,7 @@ export enum PaymentProviders {
 
 export interface Payment {
   payment_id: string;
-  provider: string;
+  provider_name: string;
   url: string;
 }
 
@@ -257,7 +364,7 @@ export interface PaymentOneClick extends Payment {
   is_paid: boolean;
 }
 
-export interface OrderWithPaymentInfo extends Order {
+export interface OrderPaymentInfo {
   payment_info: Payment | PaymentOneClick;
 }
 
@@ -266,29 +373,44 @@ export interface AddressCreationPayload extends Omit<Address, 'id' | 'is_main'>
   is_main?: boolean;
 }
 
-interface OrderCreationPayload {
-  product: Product['id'];
-  course: CourseLight['code'];
-  billing_address?: Omit<Address, 'id' | 'is_main'>;
-  credit_card_id?: CreditCard['id'];
+interface AbstractOrderProductCreationPayload {
+  product_id: Product['id'];
+  order_group_id?: OrderGroup['id'];
+  has_consent_to_terms: boolean;
 }
 
+interface OrderCertificateCreationPayload extends AbstractOrderProductCreationPayload {
+  enrollment_id: Enrollment['id'];
+}
+export interface OrderCredentialCreationPayload extends AbstractOrderProductCreationPayload {
+  course_code: CourseLight['code'];
+}
+
+export type OrderCreationPayload = OrderCertificateCreationPayload | OrderCredentialCreationPayload;
+
 interface OrderAbortPayload {
   id: Order['id'];
   payment_id?: Payment['payment_id'];
 }
 
+interface OrderSubmitPayload {
+  id: Order['id'];
+  billing_address: Omit<Address, 'id' | 'is_main'>;
+  credit_card_id?: CreditCard['id'];
+}
+
 export interface PaginatedResourceQuery extends ResourcesQuery {
   page?: number;
   page_size?: number;
 }
 
 export interface EnrollmentsQuery extends PaginatedResourceQuery {
+  course_run_id?: CourseRun['id'];
   was_created_by_order?: boolean;
 }
 
 interface EnrollmentCreationPayload {
-  course_run: CourseRun['id'];
+  course_run_id: CourseRun['id'];
   is_active: boolean;
   order?: Order['id'];
   was_created_by_order: boolean;
@@ -303,10 +425,44 @@ export interface CourseRunFilters extends ResourcesQuery {
 }
 
 export interface CourseQueryFilters extends ResourcesQuery {
+  id?: CourseListItem['id'];
+  organization_id?: Organization['id'];
+  has_listed_course_runs?: Boolean;
+}
+export interface CourseProductQueryFilters extends ResourcesQuery {
+  id?: Product['id'];
+  course_id?: CourseListItem['id'];
+}
+export interface CourseProductRelationQueryFilters extends PaginatedResourceQuery {
+  id?: CourseProductRelation['id'];
   organization_id?: Organization['id'];
+  product_type?: ProductType;
+}
+
+export enum ContractState {
+  UNSIGNED = 'unsigned',
+  LEARNER_SIGNED = 'half_signed',
+  SIGNED = 'signed',
 }
-export interface CourseProductRelationQueryFilters extends ResourcesQuery {
+export interface ContractResourceQuery extends PaginatedResourceQuery {
   organization_id?: Organization['id'];
+  course_product_relation_id?: CourseProductRelation['id'];
+  contract_ids?: Contract['id'][];
+  signature_state?: ContractState;
+}
+
+export interface OrganizationContractSignatureLinksFilters {
+  contracts_ids?: string[];
+  organization_id: Organization['id'];
+  course_product_relation_ids?: CourseProductRelation['id'][];
+}
+
+export interface ContractInvitationLinkResponse {
+  invitation_link: string;
+}
+
+export interface OrganizationContractInvitationLinkResponse extends ContractInvitationLinkResponse {
+  contract_ids: Contract['id'][];
 }
 
 export interface ApiResourceInterface<
@@ -320,6 +476,9 @@ export interface ApiResourceInterface<
 }
 
 interface APIUser {
+  me: {
+    get(): Promise<JoanieUserProfile>;
+  };
   addresses: {
     create(payload: AddressCreationPayload): Promise<Address>;
     delete(id: Address['id']): Promise<void>;
@@ -336,15 +495,17 @@ interface APIUser {
   };
   orders: {
     abort(payload: OrderAbortPayload): Promise<void>;
-    create(payload: OrderCreationPayload): Promise<OrderWithPaymentInfo>;
+    create(payload: OrderCreationPayload): Promise<CredentialOrder | CertificateOrder>;
     get<Filters extends OrderResourcesQuery = OrderResourcesQuery>(
       filters?: Filters,
     ): Filters extends { id: string }
-      ? Promise<Nullable<Order>>
-      : Promise<PaginatedResponse<Order>>;
+      ? Promise<Nullable<CredentialOrder | CertificateOrder>>
+      : Promise<PaginatedResponse<CredentialOrder | CertificateOrder>>;
     invoice: {
       download(payload: { order_id: Order['id']; invoice_reference: string }): Promise<File>;
     };
+    submit(payload: OrderSubmitPayload): Promise<OrderPaymentInfo>;
+    submit_for_signature(id: string): Promise<ContractInvitationLinkResponse>;
   };
   certificates: {
     download(id: string): Promise<File>;
@@ -370,28 +531,47 @@ interface APIUser {
     create(id: string): Promise<CourseWish>;
     delete(id: string): Promise<void>;
   };
-  organizations: {
-    get<Filters extends ResourcesQuery = ResourcesQuery>(
-      filters?: Filters,
-    ): Filters extends { id: string } ? Promise<Nullable<Organization>> : Promise<Organization[]>;
+  contracts: {
+    get(
+      filters?: ContractResourceQuery,
+    ): ContractResourceQuery extends { id: string }
+      ? Promise<Nullable<Contract>>
+      : Promise<PaginatedResponse<Contract>>;
+    download(id: string): Promise<File>;
+    zip_archive: {
+      check: (id: string) => Promise<Response>;
+      create: ({ organization_id }: { organization_id: string }) => Promise<{ url: string }>;
+      get: (id: string) => Promise<File>;
+    };
   };
 }
 
 export interface API {
   user: APIUser;
-  products: {
-    get<Filters extends ResourcesQuery = ResourcesQuery>(
-      filters?: Filters,
-    ): Filters extends { id: string }
-      ? Promise<Nullable<Product>>
-      : Promise<PaginatedResponse<Product>>;
-  };
   courses: {
     get<Filters extends PaginatedResourceQuery = PaginatedResourceQuery>(
       filters?: Filters,
     ): Filters extends { id: string }
       ? Promise<Nullable<CourseListItem>>
       : Promise<PaginatedResponse<CourseListItem>>;
+    products: {
+      get(filters?: CourseProductQueryFilters): Promise<Nullable<CourseProductRelation>>;
+    };
+  };
+  organizations: {
+    get<Filters extends ResourcesQuery = ResourcesQuery>(
+      filters?: Filters,
+    ): Filters extends { id: string } ? Promise<Nullable<Organization>> : Promise<Organization[]>;
+    contracts: {
+      get(
+        filters?: ContractResourceQuery,
+      ): ContractResourceQuery extends { id: string }
+        ? Promise<Nullable<Contract>>
+        : Promise<PaginatedResponse<Contract>>;
+      getSignatureLinks(
+        filters?: OrganizationContractSignatureLinksFilters,
+      ): Promise<OrganizationContractInvitationLinkResponse>;
+    };
   };
   courseRuns: {
     get(
@@ -405,6 +585,9 @@ export interface API {
       ? Promise<Nullable<CourseProductRelation>>
       : Promise<PaginatedResponse<CourseProductRelation>>;
   };
+  contractDefinitions: {
+    previewTemplate(id: string): Promise<File>;
+  };
 }
 
 export interface Backend {

package/js/types/Suggestion.ts

@@ -39,8 +39,8 @@ export function isCourseSuggestion(suggestion: Suggestion<string>): suggestion i
 export type Suggestion<Kind extends string> = Kind extends 'default'
   ? DefaultSuggestion
   : Kind extends 'courses'
-  ? CourseSuggestion
-  : GenericSuggestion;
+    ? CourseSuggestion
+    : GenericSuggestion;
 
 /**
  * The base shape of a resource suggestion section. Contains a bunch of suggestions and a title.

package/js/types/User.ts

@@ -1,6 +1,24 @@
 export interface User {
   access_token?: string;
-  fullname?: string;
+  full_name?: string;
   email?: string;
   username: string;
 }
+
+export enum JoanieUserApiAbilityActions {
+  DELETE = 'delete',
+  GET = 'get',
+  PATCH = 'patch',
+  PUT = 'put',
+  HAS_COURSE_ACCESS = 'has_course_access',
+  HAS_ORGANIZATION_ACCESS = 'has_organization_access',
+}
+
+export interface JoanieUserProfile {
+  id: string;
+  username: string;
+  full_name: string;
+  is_superuser: boolean;
+  is_staff: boolean;
+  abilities: { [key in JoanieUserApiAbilityActions]?: boolean };
+}

package/js/types/commonDataProps.ts

@@ -31,6 +31,9 @@ export interface RichieContext {
   release: string;
   sentry_dsn: Nullable<string>;
   web_analytics_providers?: Nullable<string[]>;
+  site_urls: {
+    terms_and_conditions: Nullable<string>;
+  };
 }
 
 export interface CommonDataProps {

package/js/types/index.ts

@@ -25,7 +25,6 @@ export interface CourseRun {
   enrollment_end: string;
   languages: string[];
   state: CourseState;
-  starts_in_message: Nullable<string>;
   dashboard_link: Nullable<string>;
   title?: string;
   snapshot?: string;
@@ -70,4 +69,5 @@ export interface OpenEdXEnrollment {
  * Use an unknown type to make sure we do not depend on any LMS-specific fields
  * on enrollment objects, just use HTTP response codes.
  */
+// TODO(rlecellier): rename into UnknownEnrollment
 export type Enrollment = unknown;

package/js/utils/AbilitiesHelper/contractAbilities.spec.ts

@@ -0,0 +1,35 @@
+import { faker } from '@faker-js/faker';
+import { ContractFactory } from 'utils/test/factories/joanie';
+import { ContractActions } from 'utils/AbilitiesHelper/types';
+import AbilitiesHelper from '.';
+
+describe('Abilities.contractAbilities', () => {
+  it('should allow or not user to sign contract according to contract abilities', () => {
+    const contract = ContractFactory({
+      abilities: {
+        sign: faker.datatype.boolean(),
+      },
+    }).one();
+
+    expect(AbilitiesHelper.can(contract, ContractActions.SIGN)).toBe(contract.abilities?.sign);
+    expect(AbilitiesHelper.cannot(contract, ContractActions.SIGN)).toBe(!contract.abilities?.sign);
+  });
+
+  it('should allow or not user to sign contracts list according to contract abilities', () => {
+    const signableContracts = ContractFactory({
+      abilities: { sign: true },
+    }).many(3);
+    const unsignableContract = ContractFactory({
+      abilities: { sign: false },
+    }).one();
+
+    // We should be able to pass an array of contracts and process ability according to all
+    // contracts abilities provided
+    expect(AbilitiesHelper.can(signableContracts, ContractActions.SIGN)).toBe(true);
+
+    // If at least one contract is not allowed, user not be able to sign
+    expect(
+      AbilitiesHelper.can([...signableContracts, unsignableContract], ContractActions.SIGN),
+    ).toBe(false);
+  });
+});

package/js/utils/AbilitiesHelper/contractAbilities.ts

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