---
# System prepended metadata

title: "Résumé des pages et requêtes pour WebApp\_:"

---

# Résumé des pages et requêtes pour WebApp :

![](https://i.imgur.com/xVeFXyj.png)

Template:
```json=
{
    type:,
    status: 'ok',
    token: theToken,
    data: {
        //ton data
    },
}
```
# Todo list (ordre de priorité): 
- [x] 1. - CreateGame (back ok)
- [x] 2. - Setup (back ok)
- [ ] 3. - overview (back ok)
- [x] 4. - StopGame (back ok)
- [x] 5. - reconnection (à modifier) (back ok)
- [x] 6. - UpdatePlayers (back ok)
- [x] 7. - save (back ok)
- [x] 8. - SetPlayerRole (back ok)
- [x] 9. - pause (back ok)
- [x] 10. - resume (back ok)
- [x] 11. - annonce (back ok)
- [x] 12. - getTemplatePage (back ok)
- [x] 13. - players (back ok)
- [x] 14. - StartGame (back ok)
- [ ] 15. - Notification 
- [ ] 16. - Setup(send Roles and not Prefered after startGame)


## Initialisation du site

Requete de la webapp
```json
{
    type: 'getHomePage',
    status: 'ok',
    token: null,
    data: {
    },
}
```

Reponse du serveur

```json
{
    "type": "getTemplatesPage",
    "status": 'ok',
    "token": null,
    "data": {
        "templates": [
            {
                "name": string,
                "description" : string,
                "summary": string
            }
        ],
    },
}
```
## Creation de partie

Requete de la webapp
@wo0lien 
```json
{
    "type": 'createGame',
    "status": 'ok',
    "token": null,
    "data": {
        "templateName": 'basicMurder'
        "duration" : int,
        "name" : string,
    },
}
```

Reponse du serveur

```json
{
    type: 'createGame',
    status: 'ok',
    token: null,
    data: {
        gameId: 'newId',
        token: 'theToken',
    },
}
```
## Save

Requete de la webapp

```json
{
    type: 'save',
    status: 'ok',
    token: Thetoken,
    data: {
    },
}
```

Reponse du serveur (si tout marche)

```json
{
    type: 'save',
    status: 'ok',
    token: null,
    data: {
    },
}
```

Si il y a une erreur

```json
{
    type: 'save',
    status: 'error',
    token: null,
    data: {
        message: '',
    },
}
```

## Reconnection

Requete de la webapp

```json
{
    type: 'gmReconnectGame',
    status: 'ok',
    token: null,
    data: {
        gameId: Number,
        playerName: String,
    },
}
```

Reponse du serveur (si tout marche)

```json
{
    type: 'gmReconnectGame',
    status: 'ok',
    token: null,
    data: {
        token: 'theToken',
        status: 
    },
}
```

Si il y a une erreur

```json
{
    type: 'gmReconnectGame',
    status: 'error',
    token: null,
    data: {
        message: 'Authentification failed',
    },
}
```


## SETUP :

Requêtes à l’api pour récupérer :

 • La liste des joueurs connectés
 • Leur préférence (choisie d’office dans la liste déroulante du rôle assigné au joueur mais reste changeble par l’admin depuis le site)
 • Un résumé non-spoilant de l’intrigue
 • game ID et nom du scénario
 • liste des images de chaque personnage et leur nom


      
Renverra ‘a l’API quand clique sur Start :
      
 •  Temps de game attendu (indiqué par l’admin)
 • Temps de début de la game (pour calculer le pourcentage de la partie)
 • Role définitif de chaque joueurs 
 
 Necessité : 
 Description du type de partie - Numéro - Rôles disponibles
 
 Joueurs en ligne (rôle préféré)
 


## GetSetup

```json
{
    type: 'getSetup',
    status: 'ok',
    token: 'theToken',
    data: {
    },
}
```

Réponse du backend
```json
{
    "type": getSetup,
    "status": 'ok',
    "token": null,
    "data": {
        "gameDescription": String,
        "gameId": Integer,
        "rolesNames": String[],
        "players": [
            {
            name: String,
            connected: Boolean,
            prefered: String,
            }, ...
        ]
    },
}
```

Quand un joueur se connecte / se déconnecte pendant le setup le serveur envoie

```json
{
    type: 'updatePlayers',
    status: 'ok',
    token: null,
    data: {
        players: [
            {
            name: String,
            connected: Boolean,
            prefered: String,
            }, ...
        ]
    },
}
```

Quand un joueur se connecte / se déconnecte pendant la partie le serveur envoie

```json
{
    type: 'updatePlayersOverview',
    status: 'ok',
    token: null,
    data: {
        players: [
            {
            name: String,
            connected: Boolean,
            role: String,
            }, ...
        ]
    },
}
```

```javascript
ws.on('message', (event) => {
    const data = JSON.parse(event);
    switch(data.type) {
        case 'updatePlayers':
        // ton update de variable
        break;
    }
});
```

quand un role est Set pour un player la webapp envoie

```json
{
    "type": "setPlayerRole",
    "status": "ok",
    "token": theToken,
    "data": {
        "playerName": String,
        "newRole": String,
    }
}
```

réponse du backend

```json
{
    "type": "setPlayerRole",
    "status": "ok",
    "token": "null",
    "data": {},
}
```

si il y a une erreur

```json
{
    "type": "setPlayerRole",
    "status": "error",
    "token": null,
    "data": {
        "message": String,
    },
}
```
## Demarrage Partie

```json
{
    "type": "startGame",
    "status": "ok",
    "token": TheToken,
    "data": {
    }
}
```
réponse du backend

```json
{
    "type": "startGame",
    "status": "ok",
    "token": null,
    "data": {
    }
}
```
## Annonce

```json
{
    "type": "announce",
    "status": "ok",
    "token": TheToken,
    "data": {
        "message": String,
    }
}
```

réponse du backend

```json
{
    "type": "announce",
    "status": "ok",
    "token": null,
    "data": {},
}
```     
## Pause

```json
{
    "type": "pause",
    "status": "ok",
    "token": TheToken,
    "data": {
        "currentTime": Int,
    }"
}
```

réponse du backend

```json
{
    "type": "pause",
    "status": "ok",
    "token": null,
    "data": {},
}
```  

## Pause

```json
{
    "type": "resume",
    "status": "ok",
    "token": TheToken,
    "data": {
    }
}
```

réponse du backend

```json
{
    "type": "resume",
    "status": "ok",
    "token": null,
    "data": {
        "currentTime": Int,
    },
}
```   
## Arret Partie : 
```json
{
    "type": "stopGame",
    "status": "ok",
    "token": TheToken,
    "data": {
        finalDuration : int,
    }
}
```

```json
{
    "type": "stopGame",
    "status": "ok",
    "token": null,
    "data": {
        DurationObjective: int,
        FinalDuration :int,
        Players[name: string, role : string],
        
        
    }
}
```

## OVERVIEW :

Requêtes à l’api pour récupérer :

 • Quand on appuie sur play, on regarde si l’api à isPaused == True pour la faire passer à false et relancer la clock
 • gameID, nom de game, synopsis (déjà récup au setup)
      
Renverra ‘a l’API :
      
 • Si pause est cliqué, renvoie à l’API le temps de la pause.
 
 Nécessité 
 Description de partie 
 Durée restante
 Joueurs en ligne et rôle
 
 ```json
 {
    "type":'getOverview',
    "status": 'ok',
    "token": theToken,
    "data": {
        "gameDescription": String,
        "gameId": Integer,
        "globalDuration" : Integer,
        "remainingDuration" : Integer,
        "players": [
            {
            "name": string,
            "connected" : boolean, 
            "role" :String };
        ]
    },
}
```

## PARTIE MJ :

Requêtes à l’api pour récupérer :

 • les joueurs connectés
 • leur rôle définitif et description + inventaire
 • photo du rolede chaqu’un
 • État présent du personnage (actif, mort, empoisonné...)
 
 ```json
{
    "type": 'getGM',
    "status": "ok",
    "token": TheToken,
    "data": {},
}
 ```
 
 ```json
 {
    "type": 'getGM',
    "status": 'ok',
    "token": null,
    "data": {
        "events": [
            {
            "name": String,
            "text": String,
            "triggered": boolean,
            "timer": Int,
            },
        ]
        "players": [
            "Toto" :{
                "connected" : boolean, 
                "role": String, 
                "description": String, 
                "state": String, 
                "lastAction": String, 
                "inventory" : [
                    { 
                        "name": String,
                        "description": String,
                        "clue": Boolean
                    },...
                ] 
                "relations" : { 
                        "character": String, //ce qu'il pense du character
                    }
            };
        ]
    },
}
```
