---
title: Gestion du process
slug: oip-next/iauk6twpzif8gtunvkns
description: Learn how to implement the initialization or recovery logic of an Object Action View (OAV) for the current process in oip-core. This document explains how the process object, connected to the user's session and project, is exposed by oip-core's controller
icon: {"lucideIcon":"📘"}
createdAt: 2023-07-07T12:03:58.000Z
---

*Cette page à pour objectif de décrire l'implémentation de la logique d'initialisation ou de  reprise d'un OAV relatif au&#x20;*`process`*&#x20;courant exposé par l'oip-core. Le contexte de l'application et le contexte graphql sont définis grâce au&#x20;*`process`*&#x20;et permettent d'accéder au&#x20;*`projectId`*&#x20;que ce soit côté front dans les composants des vues ou côté back dans les différents resolvers graphql.&#x20;*

## Process

L'objet `process` est exposé par l'oip-core via ses **contrôleurs**. Cet objet fait le lien entre la session courante de l'utilisateur et un projet. Il est stocké en base de données dans la collection `processes`.

Champs importants d'un `process` :

```json
{
  "sessionId": "xxxx",    // related session id
  "projectId": "yyyy",    // related project id
  "viewId": "CUSTOMER",   // current view id
  "actions": [      // available actions for transition
    "NEXT",
    "PREVIOUS"
  ]
}
```

## Logique d'initialisation d'un projet

Cette version de l'oip-starter exécute une logique d'initialisation d'un projet lors du lancement de l'application. Cette logique permet soit la création d'une nouvelle entité projet, soit la reprise d'un projet existant. Dans ce dernier cas, l'OAV reprendra à la dernière vue activée par une précédente session.

***Cette implémentation par défaut peut être adaptée selon les besoins du projet client.***

Dans `app/index.js`, le hook `useInitProject` prend en paramètre un identifiant de projet depuis le paramètre d'url `projectId`, s'il existe.

```none
http://localhost:8000/?projectId=my-project-id
```

`projectId` peut être :

- un identifiant de projet externe
- un identifiant interne d'une entité projet existante (`_id`)
- un identifiant externe d'une entité projet existante (`externalId`)&#x20;
- indéfini

Partie du code de `app/index.js` qui gère la logique d'initialisation du projet :

```javascript
...

const [projectId] = useQueryParam('projectId', StringParam);

// to init an initial project
const { isLoading, error, data } = useInitProject(projectId);

useEffect(() => {
  // set header 'fasst-oav-project-id' 
  // for all next graphql calls
  GQLEnvironment.projectId = data?.projectId;
}, [data?.projectId]);

if (isLoading || error) {
  return (
    <div />
  );
}

...
```

Le hook `useInitProject` effectue un appel au server `GET /project/:projectId`. Si `projectId` est indéfini, un UUID est généré.

Dans `server/app.mjs`, la ligne `app.use('/project/:id', initProjectMiddleware);` exécute la logique de création ou de récupération du projet lors de l'appel entrant sur la route `GET /project/:id` définie dans `server/routes.mjs`. Veuillez également consulter le fichier `server/initProjectMiddleware.mjs` et adapter la logique selon vos besoins.

Une fois le projet récupéré ou créé, son identifiant réel est renvoyé : `{ projectId: "xxxx" }`. Le header `fasst-oav-project-id` est alors défini pour toutes les prochaines requêtes graphql côté client et aura pour valeur l'identifiant interne du projet courant.

De ce fait, le middleware interne de l'oip-core sur l'endpoint `/graphql` résoudra le `process` pour la paire `{ sessionId, projectId }` avant chaque requête graphql. Le `process` courant sera alors accessible depuis le `context` graphql dans les resolvers et permettra de récupérer `projectId`.

## Exemple de récupération du projectId depuis un composant React

```javascript
import React from 'react';
import PropTypes from 'prop-types';
import withProcess, { viewIds, actionIds } from '@@app/withProcess';

const Home = ({ context, processHandlers }) => {
  // récupération de projectId depuis le context
  const projectId = context.projectId;

  const $onClick = (actionId) => () => {
    processHandlers.onAction(viewIds.HOME, actionId);
  };

  return (
    <div className="t-home">
      <h2>{viewIds.HOME}</h2>
      <p>Project ID: {projectId}</p>

      <div>
        <button 
          className="f-button" 
          onClick={$onClick(actionIds.HOME_NEXT)}>Next</button>
      </div>
    </div>
  );
};

Home.propTypes = {
  context: PropTypes.object,
  processHandlers: PropTypes.object
};

// withProcess injecte dans les props du composant context et processHandlers
export default withProcess(Home);
```

## Exemple de récupération du projectId dans un resolver GraphQL

```javascript
import { Entities } from '@fasstech/oip-core';
import { 
  getProjectId, 
  getProjectExternalId, 
  getProjectName 
} from '@fasstech/oip-core/entities';

export const getProject = async (args, context) => {
  // récupération de projectId depuis le context du resolver
  const { projectId } = context.process;
  
  const project = await Entities('Project').get({ id: projectId });

  return {
    id: getProjectId(project),
    externalId: getProjectExternalId(project),
    name: getProjectName(project)
  };
};

export default getProject;
```
