Api reference

components.onboarding.public.actions ¶

cancel_onboarding_invitation ¶

cancel_onboarding_invitation(
    onboarding_invitation_id, commit=True
)

Cancels the onboarding invitation. You can only cancel a non-completed onboarding

Source code in components/onboarding/internal/actions/cancel_onboarding_invitation.py

def cancel_onboarding_invitation(
    onboarding_invitation_id: UUID, commit: bool = True
) -> None:
    """
    Cancels the onboarding invitation. You can only cancel a
    non-completed onboarding
    """
    if (
        onboarding_invitation := OnboardingInvitationModelBroker.find_by_id(
            onboarding_invitation_id,
        ).one_or_none()
    ) is None:
        raise ValueError(
            f"Onboarding invitation with ID {onboarding_invitation_id} does not exist.",
        )

    if (
        onboarding_invitation.onboarding_status == OnboardingInvitationStatus.completed
        or onboarding_invitation.is_cancelled
    ):
        raise ValueError(
            f"Cannot cancel an onboarding invitation that is already completed or "
            f"cancelled. Onboarding: {onboarding_invitation_id}",
        )

    onboarding_invitation.is_cancelled = True
    if commit:
        current_session.commit()
    else:
        current_session.flush()

    current_logger.info(
        f"Cancelled onboarding invitation {onboarding_invitation_id}",
    )

create_or_update_retiree_onboarding ¶

create_or_update_retiree_onboarding `module-attribute` ¶

create_or_update_retiree_onboarding = (
    create_or_update_retiree_onboarding
)

customer_admin ¶

cancel_customer_admin_invitation ¶

cancel_customer_admin_invitation(invitation_id)

Remove a customer admin invitation by its ID.

todo @alexandre.dubreuil - Duplicates cancel_onboarding_invitation

Source code in components/onboarding/internal/actions/customer_admin.py

def cancel_customer_admin_invitation(invitation_id: UUID) -> None:
    """
    Remove a customer admin invitation by its ID.

    todo @alexandre.dubreuil - Duplicates cancel_onboarding_invitation
    """

    customer_admin_onboarding = CustomerAdminOnboardingModelBroker.find_by_id(
        invitation_id, with_cancelled=True
    ).one()

    if (
        customer_admin_onboarding.onboarding_status
        == OnboardingInvitationStatus.completed
        or customer_admin_onboarding.is_cancelled
    ):
        raise ValueError(
            f"Cannot cancel a customer admin invitation that is already completed or cancelled. Onboarding: {invitation_id}",
        )

    # Remove the customer admin invitation
    customer_admin_onboarding.is_cancelled = True
    current_session.commit()

    current_logger.info(
        "Cancelled customer admin invitation",
        onboarding_component={"invitation_id": invitation_id},
    )

invite_customer_admin ¶

invite_customer_admin(
    invitation_email,
    entities,
    *,
    first_name=None,
    last_name=None,
    external_employee_id=None,
    lang=None,
    send_email=True,
    save=True,
    **email_kwargs
)

Source code in components/onboarding/internal/actions/customer_admin.py

def invite_customer_admin(
    invitation_email: str,
    entities: list[CustomerAdminInvitationToEntity],
    *,
    first_name: str | None = None,
    last_name: str | None = None,
    external_employee_id: str | None = None,
    lang: Lang | None = None,
    send_email: bool = True,
    save: bool = True,
    **email_kwargs: str | bool | None,
) -> CustomerAdminOnboarding:
    # Create an invitation/onboarding for a customer admin, and sends an email

    # delay import to ensure app dependency has been defined for mailer
    from components.onboarding.internal.mailers.customer_admin_invitation_emails import (
        send_customer_admin_invitation_email,
    )

    # Only invite the customer admin for entities that are not already covered by an existing pending onboarding
    entities_to_invite_on = filter_entities_covered_by_existing_pending_onboardings(
        email=invitation_email,
        entities=entities,
    )

    # Ensure the admin is not already admin for the entities
    user_from_invite_email = get_app_dependency().get_user_by_email(invitation_email)
    if (
        user_from_invite_email is not None
        # TODO can be replaced by customer_admin public API once all countries are setup
        and get_app_dependency().user_can_admin_admined_entities(
            user_from_invite_email.id,
            admined_entities=[
                AdminedEntity(
                    type=(
                        AdminedEntityType.account
                        if entity.entity_type == EntityType.account
                        else (
                            AdminedEntityType.single_company
                            if entity.entity_type == EntityType.company
                            else AdminedEntityType.operational_scope
                        )
                    ),
                    id=entity.entity_id,
                )
                for entity in entities_to_invite_on
            ],
        )
    ):
        raise BaseErrorCode.company_admin_invitation_already_accepted(
            user_id=user_from_invite_email.id
        )

    account_org_tree_api = get_app_dependency().get_account_org_tree_query_api()
    # Invitations are for a given account, in the admin dashboard at least,
    # so we can safely use one.
    account = one(
        account_org_tree_api.get_account_for_entities(
            [(entity.entity_id, entity.entity_type) for entity in entities_to_invite_on]
        )
    )
    enterprise_sso_account_setting = get_account_setting(
        account_id=UUID(account.id), feature_name=AccountFeature.enterprise_sso
    )
    if (
        enterprise_sso_account_setting
        and (metadata := enterprise_sso_account_setting.feature_metadata)
        and (email_domains := metadata["email_domains"])
    ):
        invitation_email_domain = invitation_email.strip().lower().rsplit("@", 1)[1]
        if invitation_email_domain not in email_domains:
            raise BaseErrorCode.enterprise_sso_incompatible_email_address(
                message=f"The invitation email domain should be one of the following domains: {','.join(email_domains)}"
            )

    customer_admin_onboarding = _create_customer_admin_onboarding(
        invitation_email,
        entities_to_invite_on,
        first_name=first_name,
        last_name=last_name,
        external_employee_id=external_employee_id,
        lang=lang,
        save=save,
    )

    if send_email:
        send_customer_admin_invitation_email(
            person_onboarding_id=str(customer_admin_onboarding.id),
            **email_kwargs,
        )

    current_logger.info(
        "Invited customer admin",
        onboarding_component={
            "person_onboarding_id": customer_admin_onboarding.id,
        },
    )

    return customer_admin_onboarding

resend_customer_admin_invitation_email ¶

resend_customer_admin_invitation_email(invitation_id)

Resend the invitation email for a customer admin onboarding.

Source code in components/onboarding/internal/actions/customer_admin.py

def resend_customer_admin_invitation_email(invitation_id: UUID) -> None:
    """
    Resend the invitation email for a customer admin onboarding.
    """
    # delay import to ensure app dependency has been defined for mailer
    from components.onboarding.internal.mailers.customer_admin_invitation_emails import (
        send_customer_admin_invitation_email,
    )

    customer_admin_onboarding = CustomerAdminOnboardingModelBroker.find_by_id(
        invitation_id, with_cancelled=True
    ).one()

    if (
        customer_admin_onboarding.onboarding_status
        == OnboardingInvitationStatus.completed
        or customer_admin_onboarding.is_cancelled
    ):
        raise ValueError(
            f"Cannot resend a customer admin invitation email, when it's already completed, or cancelled. Onboarding: {invitation_id}",
        )

    # Resend the customer admin invitation
    send_customer_admin_invitation_email(
        person_onboarding_id=str(customer_admin_onboarding.id),
    )

    current_logger.info(
        "Resend customer admin invitation",
        onboarding_component={"invitation_id": invitation_id},
    )

merge_users ¶

merge_users_in_onboarding_component ¶

merge_users_in_onboarding_component(
    source_user_id, target_user_id, commit=True
)

Support function for the "merge user" procedure: change all onboardings that target user source_user_id so that they target user target_user_id instead.

This will change ALL onboardings for the user, including cancelled ones.

Source code in components/onboarding/internal/actions/merge_users.py

def merge_users_in_onboarding_component(
    source_user_id: str,
    target_user_id: str,
    commit: bool = True,
) -> None:
    """
    Support function for the "merge user" procedure: change all onboardings that target
    user `source_user_id` so that they target user `target_user_id` instead.

    This will change ALL onboardings for the user, including cancelled ones.
    """
    onboardings = OnboardingInvitationModelBroker.find_by_user_id_order_latest(
        source_user_id, with_cancelled=True
    )

    for onboarding in onboardings:
        current_logger.info(
            f"Moving employee onboarding {onboarding.id} to target user"
        )
        onboarding.user_id = target_user_id

    current_session.flush()

    if commit:
        current_session.commit()

onboarding ¶

update_onboarding ¶

update_onboarding(
    onboarding_invitation_id,
    first_name=None,
    last_name=None,
    birthdate=None,
    street=None,
    gender=None,
    city=None,
    province=None,
    postal_code=None,
    country=None,
    billing_account_number=None,
    viewed_terms_at=None,
    lang=None,
    email=None,
    identification_type=None,
    identification_value=None,
    commit=True,
)

Source code in components/onboarding/internal/actions/update_onboarding.py

def update_onboarding(
    onboarding_invitation_id: UUID,
    first_name: Optional[str] = None,
    last_name: Optional[str] = None,
    birthdate: Optional[date] = None,
    street: Optional[str] = None,
    gender: Optional[Gender] = None,
    city: Optional[str] = None,
    province: Optional[str] = None,
    postal_code: Optional[str] = None,
    country: Optional[str] = None,
    billing_account_number: Optional[str] = None,
    viewed_terms_at: Optional[datetime] = None,
    lang: Optional[Lang] = None,
    email: Optional[str] = None,
    identification_type: Optional[IdentificationType] = None,
    identification_value: Optional[str] = None,
    commit: bool = True,
) -> None:
    onboarding_progress = (
        OnboardingProgressBroker.find_by_onboarding_invitation_id(
            onboarding_invitation_id
        )
    ).one()

    onboarding_invitation = onboarding_progress.onboarding_invitation

    if onboarding_invitation.onboarding_status == OnboardingInvitationStatus.completed:
        raise BaseErrorCode.invalid_arguments(
            message="Updating a 'completed' onboarding is forbidden",
        )

    if first_name:
        onboarding_invitation.first_name = first_name.strip()

    if last_name:
        onboarding_invitation.last_name = last_name.strip()

    if birthdate:
        onboarding_progress.birthdate = birthdate

    if gender:
        onboarding_progress.gender = gender

    if street and city and postal_code and province and country:
        # Raises AddressInvalidException if the address doesn't have the right format, caught in the controller
        address = Address(
            street=street,
            unit=None,
            locality=city,
            administrative_area=province,
            postal_code=postal_code,
            country=country,
            sublocality=None,
            postal_town=None,
        )
        onboarding_progress.street = address.street
        onboarding_progress.postal_code = address.postal_code
        onboarding_progress.province = address.administrative_area
        onboarding_progress.city = address.locality
        onboarding_progress.address_country = address.country

    if lang:
        onboarding_invitation.lang = lang

    if viewed_terms_at:
        onboarding_progress.viewed_terms_at = viewed_terms_at

    if billing_account_number:
        validated_billing_account = (
            get_app_dependency().validates_billing_account_number(
                billing_account_number.strip()
            )
        )
        onboarding_progress.billing_account_number = (
            validated_billing_account.account_number
        )
        onboarding_progress.billing_account_type = (
            validated_billing_account.account_type
        )
    if email:
        onboarding_progress.email = email

    if (identification_type and identification_value is None) or (
        identification_value and identification_type is None
    ):
        raise BaseErrorCode.invalid_arguments(
            message="One of the identification information is missing",
        )
    if identification_type:
        onboarding_progress.identification_type = identification_type
    if identification_value:
        onboarding_progress.identification_value = identification_value

    onboarding_entity = get_onboarding_entity(onboarding_progress)
    if get_app_dependency().is_employee_onboarding_completed(onboarding_entity):
        onboarding_invitation.onboarding_status = OnboardingInvitationStatus.completed
        # Call dependency so that they can updated themselves on completed (e.g. user.name, etc.)
        get_app_dependency().on_completed_onboarding(onboarding_entity)
    else:
        onboarding_invitation.onboarding_status = OnboardingInvitationStatus.in_progress

    if commit:
        current_session.commit()
    else:
        current_session.flush()

    current_logger.info(
        "Updated onboarding invitation",
        onboarding_invitation_id=onboarding_invitation.id,
        onboarding_progress_id=onboarding_progress.id,
    )

onboarding_invitation_emails ¶

resend_onboarding_invitation_email ¶

resend_onboarding_invitation_email(
    onboarding_invitation_id,
)

Resend an onboarding invitation email if the onboarding is pending. Do nothing otherwise.

Source code in components/onboarding/internal/actions/resend_onboarding_invitation.py

def resend_onboarding_invitation_email(onboarding_invitation_id: UUID) -> None:
    """
    Resend an onboarding invitation email if the onboarding is pending.
    Do nothing otherwise.
    """

    from components.onboarding.internal.mailers.employee_onboarding_invitation_email import (
        send_employee_onboarding_email,
    )
    from components.onboarding.internal.mailers.retiree_onboarding_invitation_email import (
        send_retiree_onboarding_invitation_email,
    )

    onboarding_invitation = get_onboarding_invitation(
        onboarding_invitation_id=onboarding_invitation_id, with_cancelled=True
    )

    if onboarding_invitation.invitation_email is None:
        raise OnboardingMissingInvitationEmailError(
            onboarding_invitation_id=onboarding_invitation_id
        )

    if onboarding_invitation.onboarding_status == OnboardingInvitationStatus.completed:
        raise OnboardingAlreadyCompletedError(
            onboarding_invitation_id=onboarding_invitation_id
        )

    if onboarding_invitation.is_cancelled:
        raise OnboardingCancelledError(
            onboarding_invitation_id=onboarding_invitation_id
        )

    if onboarding_invitation.onboarding_type == OnboardingType.employee_onboarding:
        company_name = (
            get_app_dependency()
            .get_company_from_employed_user(
                user_id=mandatory(onboarding_invitation.user_id),
                on_date=mandatory(onboarding_invitation.start_date),
            )
            .name
        )
        send_employee_onboarding_email(
            company_name=company_name,
            employee_onboarding_id=str(onboarding_invitation_id),
        )
    elif onboarding_invitation.onboarding_type == OnboardingType.retiree_onboarding:
        send_retiree_onboarding_invitation_email(
            retiree_onboarding_id=str(onboarding_invitation_id)
        )
    else:
        raise NotImplementedError()

    current_logger.info(
        "Resend employee onboarding invitation",
        onboarding_component={"onboarding_invitation_id": onboarding_invitation_id},
    )

update_retiree_onboarding ¶

update_retiree_onboarding `module-attribute` ¶

update_retiree_onboarding = update_retiree_onboarding

update_retiree_onboarding_status `module-attribute` ¶

update_retiree_onboarding_status = (
    update_retiree_onboarding_status
)

components.onboarding.public.api ¶

complete_onboarding_invitation_as_exempted ¶

complete_onboarding_invitation_as_exempted(
    onboarding_invitation_id,
)

Complete an onboarding invitation with outcome 'exempted'.

Source code in components/onboarding/public/api.py

def complete_onboarding_invitation_as_exempted(onboarding_invitation_id: UUID) -> None:
    """Complete an onboarding invitation with outcome 'exempted'."""
    from components.onboarding.internal.actions.complete_onboarding_invitation_as_exempted import (
        complete_onboarding_invitation_as_exempted as complete_onboarding_invitation_as_exempted_,
    )

    return complete_onboarding_invitation_as_exempted_(
        onboarding_invitation_id=onboarding_invitation_id
    )

complete_retiree_onboarding ¶

complete_retiree_onboarding(
    onboarding_invitation_id, commit=False
)

Mark the retiree onboarding object as completed

Source code in components/onboarding/public/api.py

def complete_retiree_onboarding(
    onboarding_invitation_id: UUID, commit: bool = False
) -> None:
    """
    Mark the retiree onboarding object as completed
    """
    from components.onboarding.internal.actions.update_retiree_onboarding import (
        complete_retiree_onboarding as complete_retiree_onboarding_,
    )

    return complete_retiree_onboarding_(
        onboarding_invitation_id=onboarding_invitation_id, commit=commit
    )

get_first_onboarding_by_email ¶

get_first_onboarding_by_email(invitation_email)

Source code in components/onboarding/public/api.py

def get_first_onboarding_by_email(  # noqa: D103
    invitation_email: str,
) -> OnboardingEntity | None:
    from components.onboarding.internal.queries.onboarding import (
        get_onboarding_by_email as get_onboarding_by_email_,
    )

    return get_onboarding_by_email_(invitation_email)

get_pending_onboardings ¶

get_pending_onboardings(user_id)

Source code in components/onboarding/public/api.py

def get_pending_onboardings(user_id: str) -> PendingOnboardingsEntity:  # noqa: D103
    from components.onboarding.internal.queries.pending_onboardings import (
        get_pending_onboardings as get_pending_onboardings_,
    )

    return get_pending_onboardings_(user_id=user_id)

invite_employee ¶

invite_employee(
    invitation_email,
    coverage_start_date,
    company_name,
    user_id=None,
    defer_side_effects=True,
    commit=True,
    onboarding_type=None,
    health_contract_id=None,
    send_email=True,
)

Source code in components/onboarding/public/api.py

def invite_employee(  # noqa: D103
    invitation_email: str,
    coverage_start_date: date,
    company_name: str,
    user_id: str | None = None,
    defer_side_effects: bool = True,
    commit: bool = True,
    onboarding_type: OnboardingType | None = None,
    health_contract_id: str | None = None,
    send_email: bool = True,
) -> OnboardingEntity:
    from components.onboarding.internal.actions.invite_employee import (
        invite_employee as invite_employee_,
    )

    return invite_employee_(
        invitation_email=invitation_email,
        coverage_start_date=coverage_start_date,
        company_name=company_name,
        user_id=user_id,
        defer_side_effects=defer_side_effects,
        commit=commit,
        onboarding_type=onboarding_type,
        health_contract_id=health_contract_id,
        send_email=send_email,
    )

invite_partner ¶

invite_partner(
    inviter_user_id,
    invitation_email,
    partner_profile_id,
    partner_first_name,
    partner_last_name,
    partner_user_id,
    lang=None,
    send_invite_email=True,
    commit=True,
)

Invites a user to onboard as a company admin.

Source code in components/onboarding/public/api.py

def invite_partner(
    inviter_user_id: str,
    invitation_email: str,
    partner_profile_id: str,
    partner_first_name: str,
    partner_last_name: str,
    partner_user_id: UUID,
    lang: Lang | None = None,
    send_invite_email: bool = True,
    commit: bool = True,
) -> UUID:
    """Invites a user to onboard as a company admin."""
    from components.onboarding.internal.actions.invite_partner import (
        invite_partner as _invite_partner,
    )

    return _invite_partner(
        inviter_user_id=inviter_user_id,
        invitation_email=invitation_email,
        partner_profile_id=partner_profile_id,
        partner_first_name=partner_first_name,
        partner_last_name=partner_last_name,
        partner_user_id=partner_user_id,
        lang=lang,
        send_invite_email=send_invite_email,
        commit=commit,
    )

invite_retiree ¶

invite_retiree(
    inviter_user_id,
    invitation_email,
    coverage_start_date,
    contract_id,
    retiree_onboarding_type,
    retiree_user_id=None,
    first_name=None,
    last_name=None,
    identification_number=None,
    retirement_date=None,
    is_offline=False,
    alsace_moselle_eligibility_status=None,
    read_only_fields=None,
    lang=None,
    send_invite_email=True,
    on_duplicated_onboarding="Fail",
    defer_side_effects=False,
    commit=True,
)

Invites a user to onboard as retiree.

Source code in components/onboarding/public/api.py

def invite_retiree(
    inviter_user_id: str | None,
    invitation_email: str | None,
    coverage_start_date: date | None,
    contract_id: str,
    retiree_onboarding_type: RetireeOnboardingType,
    retiree_user_id: str | None = None,
    first_name: str | None = None,
    last_name: str | None = None,
    identification_number: str | None = None,
    retirement_date: date | None = None,
    is_offline: bool = False,
    alsace_moselle_eligibility_status: str | None = None,
    read_only_fields: list[str] | None = None,
    lang: Lang | None = None,
    send_invite_email: bool = True,
    on_duplicated_onboarding: Literal["Update", "Fail"] = "Fail",
    defer_side_effects: bool = False,
    commit: bool = True,
) -> UUID:
    """Invites a user to onboard as retiree."""
    from components.onboarding.internal.actions.invite_retiree import (
        invite_retiree as _invite_retiree,
    )

    return _invite_retiree(
        inviter_user_id=inviter_user_id,
        invitation_email=invitation_email,
        coverage_start_date=coverage_start_date,
        contract_id=contract_id,
        retiree_onboarding_type=retiree_onboarding_type,
        retiree_user_id=retiree_user_id,
        first_name=first_name,
        last_name=last_name,
        identification_number=identification_number,
        retirement_date=retirement_date,
        is_offline=is_offline,
        alsace_moselle_eligibility_status=alsace_moselle_eligibility_status,
        read_only_fields=read_only_fields,
        lang=lang,
        on_duplicated_onboarding=on_duplicated_onboarding,
        send_invite_email=send_invite_email,
        defer_side_effects=defer_side_effects,
        commit=commit,
    )

components.onboarding.public.commands ¶

onboarding ¶

generate_frontend_typescript_types_file ¶

generate_frontend_typescript_types_file(dry_run)

Use flask generate_frontend_typescript_types_file --execute to generate the frontend typescript types.

File: "frontend/features/onboarding/queries/types.ts"
Types: all enums and entities

Source code in components/onboarding/public/commands/onboarding.py

@onboarding_commands.command()
@command_with_dry_run
def generate_frontend_typescript_types_file(dry_run: bool) -> None:
    """
    Use `flask generate_frontend_typescript_types_file --execute` to generate the frontend typescript types.

    - File: "frontend/features/onboarding/queries/types.ts"
    - Types: all enums and entities
    """
    from components.onboarding.public.entities.onboarding import (
        OnboardingEntity,
    )
    from components.onboarding.public.entities.onboarding_invitation import (
        OnboardingInvitationEntity,
    )
    from components.onboarding.public.entities.retiree_onboarding import (
        RetireeOnboardingEntity,
    )
    from components.onboarding.public.entities.terms_document import (
        TermsDocumentEntity,
    )
    from components.onboarding.public.enums.account_type import AccountType
    from components.onboarding.public.enums.onboarding_invitation_status import (
        OnboardingInvitationStatus,
    )
    from components.onboarding.public.enums.onboarding_type import OnboardingType
    from components.onboarding.public.enums.retiree_onboarding_type import (
        RetireeOnboardingType,
    )
    from components.onboarding.public.enums.terms_document_type import TermsDocumentType
    from shared.codegen.typescript import (
        generate_typescript_enums_and_interfaces as generate_typescript_enums_and_interfaces_,
    )
    from shared.models.enums.user_gender import UserGender

    generate_typescript_enums_and_interfaces_(
        target_filename_path_from_git_root="frontend/features/onboarding/queries/types.ts",
        types_to_generate=[
            # Enums
            OnboardingType,
            OnboardingInvitationStatus,
            RetireeOnboardingType,
            AccountType,
            TermsDocumentType,
            UserGender,
            # Models
            OnboardingInvitationEntity,
            OnboardingEntity,
            RetireeOnboardingEntity,
            TermsDocumentEntity,
        ],
        dry_run=dry_run,
    )

invite_retiree ¶

invite_retiree(
    invitation_email,
    start_date,
    contract_ref,
    retiree_user_id,
    retiree_onboarding_type,
    dry_run,
)

Use flask onboarding invite_retiree --invitation_email --start_date --contract_ref --retiree_user_id --retiree_onboarding_type --execute to invite a retiree.

Source code in components/onboarding/public/commands/onboarding.py

@onboarding_commands.command()
@click.option(
    "--invitation_email",
    type=str,
    required=True,
)
@click.option(
    "--start_date",
    type=click.DateTime(formats=["%Y-%m-%d"]),
    required=True,
)
@click.option(
    "--contract_ref",
    type=str,
    required=True,
)
@click.option(
    "--retiree_user_id",
    type=str,
    required=False,
)
@click.option(
    "--retiree_onboarding_type",
    type=str,
    required=True,
)
@command_with_dry_run
def invite_retiree(
    invitation_email: str,
    start_date: date,
    contract_ref: str,
    retiree_user_id: str | None,
    retiree_onboarding_type: str,
    dry_run: bool,
) -> None:
    """
    Use
    flask onboarding invite_retiree --invitation_email <email> --start_date <date> --contract_ref <contract_ref> --retiree_user_id <retiree_user_id> --retiree_onboarding_type <retiree_onboarding_type> --execute
    to invite a retiree.
    """
    from components.onboarding.public.api import invite_retiree as _invite_retiree
    from components.onboarding.public.enums.retiree_onboarding_type import (
        RetireeOnboardingType,
    )

    _invite_retiree(
        inviter_user_id=None,
        invitation_email=invitation_email,
        coverage_start_date=start_date,
        contract_id=contract_ref,
        retiree_user_id=retiree_user_id,
        retiree_onboarding_type=RetireeOnboardingType(retiree_onboarding_type),
        commit=not dry_run,
    )

onboarding_commands `module-attribute` ¶

onboarding_commands = AppGroup(
    name="onboarding",
    help="Main command group for the onboarding component",
)

components.onboarding.public.constants ¶

ONBOARDING_SCHEMA_NAME `module-attribute` ¶

ONBOARDING_SCHEMA_NAME = 'onboarding'

components.onboarding.public.dependencies ¶

COMPONENT_NAME `module-attribute` ¶

COMPONENT_NAME = 'onboarding'

OnboardingDependency ¶

Bases: ABC