---
# System prepended metadata

title: Projet Nooky

---

# Projet Nooky

Hack-md Hugo : https://hackmd.io/gGTMrRf0RNa2HRShQXc-zQ?both

Hack-md : https://hackmd.io/-kQmEeB5RIy5lJAObPeIEg

Mermaid : https://mermaid.js.org/syntax/entityRelationshipDiagram.html

Nooky application allows exchange second-hand clothes, shoes and accessories.

---
Doc - spring security

https://hackmd.io/-kQmEeB5RIy5lJAObPeIEg

Github - auth0 - Java JWT

https://github.com/auth0/java-jwt
___

## Entités vers 2

### Users

<u>Email</u>
Password
Username
Firstname
Lastname
Picture
Created at

### Addresses

<u>Road</u>
<u>Zip code</u>
<u>City</u>

### Products

<u>Product Reference</u>
Name
Description
Picture
Added at

### Types

<u>Type Reference</u>
Type (skirt, shirt, shoes, etc.)

### Sizes

<u>Size Reference</u>
Size for clothes
Size for shoes

### Categories

<u>Category Reference</u> 
Category (women or men or kids or intersex)
Description

___

Users -> add --> Products (1:N)
Users -> live at --> Adresses (1:1)
Products -> are wished to be exchanged with --> Products (1:N)
Products -> are grouped by --> Categories (N:1)
Products -> are classified by --> Types (N:1)
Products -> are defined by --> Sizes (N:1)

---

## Entities representation vers 2

```mermaid
erDiagram
Users ||--o{ Products : "add"
Users ||--|| Addresses : "live at"
Products ||--o{ Products : "are wished to be exchanged with"
Categories ||--o{ Products : "contains"
Types ||--o{ Products : "classified"
Sizes ||--o{ Products : "defined"


Users {
    string Email
    string Password
    string Username
    string Firstname
    string Lastname
    string Picture
    date CreatedAt
}

Addresses {
    string Road
    int ZipCode
    string City
}

Products {
    string ProductReference
    string Name
    string Description
    string Picture
    date AddedAt
}

Categories {
    string CategoryReference
    string Category
    string Description
}

Sizes {
    string SizeReference
    string Size for clothes
    int Size for shoes
}

Types {
    string TypeReference
    string Type
}

```
___

Entités à ajouter plus tard

### -> Colors

Reference (identifier)
Name
Hexadécimal

### -> Transaction

Reference (identifier)
Transaction_type (Donate or Exchange or Sale)

### -> Communities

Name (identifier)
Description
Picture
Created_At

### -> Membership

Reference (identifier)
Role (Community_Admin || Community_User)
Since

___

Users -> add --> Products (1:N)
Products -> are associated with --> Wished_Products (1:N)
Products -> are grouped by --> Categories (N:1)
Products -> are classified by --> Types (N:1)
Products -> are defined by --> Sizes (N:1)

---

## Entities

### --> User

User_Id: UUID
User_Username: string
User_Picture: string (url)
User_FirstName: string
User_LastName: string
User_Email: string
User_Password: string
User_CreatedAt: date / Timestamp

### --> Product

Product_Id: UUID
Product_Name: string
Product_Picture: string (url)
Product_Description: string (text)
Product_CreatedAt: date / Timestamp
Product_Transaction: string (Donate || Exchange)
User_Id: UUID

### --> Community

Community_Id: UUID
Community_Name: string
Community_Picture: string (url)
Community_Description: string (text)
Community_CreatedAt: date / Timestamp

### --> Membership

Membership_Id: UUID
Membership_Role: string (Community_admin || Community_User)
Membership_Since: date / Timestamp
Community_Id: UUID
User_Id: UUID

### --> Category (for products)

Category_Id: UUID
Category_Name: string
Category_Description: string
Category_CreatedAt: date / Timestamp

### --> Category_Products (join)

Product_Id: UUID (Community_Id. Foreign key from Entity Product.)
Category_Id: UUID (Category_Id. Foreign key from Entity Category.)

___

## Entities relationships

### User-Product (1:N)
- **Relation:** "adds"
- **Description:**
A user can add zero, one or many products information cards. Each product is added by only one user.
- **Implementation:**
Table `Product` includes a foreign key `User_Id` which refers to primary key `User_Id` from table `User`.

### User-Community (1:N)
- **Relation:** "creates"
- **Description:**
A user can create zero, one or many communities. Each community is added by only one user.
*Note:*
When a user creates a community, he automatically has a membership from this community with an admin role.
- **Implementation:**
Table `Community` include a foreign key `User_Id` which refers to primary key `User_Id` from table `User`.

### User-Membership (1:N)
- **Relation:** "has"
- **Description:**
A user has zero, one or many memberships.
*Note:*
A membership has a role assigned. As an admin or member.
- **Implementation:**
Table `Membership` include a foreign key `User_Id` which refers to primary key `User_Id` from table `User`.

### Community-Membership (1:N)
- **Relation:** "has"
- **Description for member:**
A community has one or many membership.
- **Implementation:**
Table `Membership` include a foreign key `Community` which refers to primary key `Community_Id` from table `Community`.


### Product-Category (N:M)
- **Relation:** "categorized in"
- **Description:**
A`Product` must be categorized. It must be at least associated with one `Category`. It can also be associated with many `Category`.
- **Implementation:**
Table `Category_Products` make the junction to deal with the relation many to many. It contains two foreign keys : `Category_Id` from `Category` and `Product_Id` from `Product`.

### Category-Category_Products (1:N)
- **Relation:** "groups"
- **Description:**
A category can gathered /* compléter */
- **Implementation:**
/* compléter */

---

## Entities representation

```mermaid
erDiagram
User ||--o{ Product : "adds"
User ||--o{ Membership : "has"
User ||--o{ Community : "creates"
Community ||--|{ Membership : "has"
Product ||--|{ Category_Products : "categorized in"
Category ||--|{ Category_Products : "groups"


User {
    UUID User_Id
    string User_Username
    string User_Picture
    string User_FirstName
    string User_LastName
    string User_Email
    string User_Password
    date User_CreatedAt
}

Product {
    UUID Product_Id
    string Product_Name
    string Product_Picture
    string Product_Description
    string Product_Transaction
    date Product_CreatedAt
    UUID User_Id
}

Community {
    UUID Community_Id
    string Community_Name
    string Community_Picture
    string Community_Description
    date Community_CreatedAt
}

Membership {
    UUID Membership_Id
    string Membership_Role
    date Membership_Since
    UUID User_Id
    UUID Community_Id
}

Category {
    UUID Category_Id
    string Category_Name
    string Category_Description
    date Category_CreatedAt
}

Category_Products {
    UUID Product_Id
    UUID Category_Id
}

```

| Value (left) | Value (right) | Meaning                      |
|--------------|---------------|------------------------------|
| \|o          | o\|           | Zero or one                  |
| \| \|        | \| \|         | Exactly one                  |
| }o           | o\{           | Zero or more (no upper limit)|
| }\|          | \|\{          | One or more (no upper limit) |

---

Création d'un compte utilisateur

```mermaid
sequenceDiagram
    actor U as Utilisateur
    participant UI as Interface Utilisateur
    participant S as Serveur
    participant DB as Base de Données

    U->>UI: Choix de créer un compte
    UI->>S: Demande de création de compte avec email et mot de passe
    S->>DB: Vérifie si l'email existe déjà
    alt L'email existe déjà
        DB->>S: Email déjà utilisé
        S->>UI: Affiche erreur d'email déjà utilisé
        UI->>U: Affiche erreur d'email déjà utilisé
    else L'email est unique
        DB->>S: Email unique confirmé
        S->>S: Hache le mot de passe
        S->>DB: Crée le nouvel utilisateur
        DB->>S: Confirmation de création de l'utilisateur
        S->>UI: Utilisateur créé avec succès
        UI->>U: Affiche succès de création de compte
    end

```

Connexion au compte utilisateur

```mermaid
sequenceDiagram
    actor U as Utilisateur
    participant UI as Interface Utilisateur
    participant S as Serveur
    participant DB as Base de Données

    U->>UI: Choix de se connecter
    UI->>S: Entre mail et mot de passe de connexion
    S->>DB: Vérifie si l'email existe déjà
    alt L'email existe déjà
        DB->>S: Email déjà utilisé
        S->>UI: Affiche erreur d'email déjà utilisé
        UI->>U: Affiche erreur d'email déjà utilisé
    else L'email est unique
        DB->>S: Email unique confirmé
        S->>S: Hache le mot de passe
        S->>DB: Crée le nouvel utilisateur
        DB->>S: Confirmation de création de l'utilisateur
        S->>UI: Utilisateur créé avec succès
        UI->>U: Affiche succès de création de compte
    end

```
Création de produit --> pres

```mermaid
sequenceDiagram
    actor U as Utilisateur
    participant A as Application
    participant DB as Base de Données
    
    U->>A: Crée une fiche produit (brouillon)
    A->>DB: Sauvegarde le brouillon
    DB-->>A: Confirme la sauvegarde
    A-->>U: Affiche le produit sauvegardé
    
    U->>A: Publie le produit
    A->>DB: Vérifie la catégorie du produit
    DB-->>A: Catégorie confirmée
    A->>DB: Change le statut en 'Publié'
    DB-->>A: Confirme la publication
    A-->>U: Affiche le produit publié
```

A affiner
```mermaid
sequenceDiagram
    actor U as Utilisateur
    participant A as Application
    participant DB as Base de Données
    
    U->>A: Sélectionne un produit
    
    
    A->>DB: Sauvegarde le brouillon
    DB-->>A: Confirme la sauvegarde
    A-->>U: Affiche le produit sauvegardé
    
    U->>A: Publie le produit
    A->>DB: Vérifie la catégorie du produit
    DB-->>A: Catégorie confirmée
    A->>DB: Change le statut en 'Publié'
    DB-->>A: Confirme la publication
    A-->>U: Affiche le produit publié
```
---

## User stories

-> Je m'inscris *
-> Je me connecte
-> Je me déconnecte

-> Je mets à jour mon profil

-> J'ajoute un article *
-> Je supprime un article
-> J'échange ou récupère (don) un article
-> J'échange ou donne un article

-> Je cherche un article dans toute la base
-> Je cherche un article parmi mes communautés

-> Je créé une communauté
-> J'administre une communauté
-> Je rejoins une communauté
-> Je consulte une fiche communauté
-> Je consulte une fiche membre

___


### oral en anglais :

10 minutes pas plus

- faire une introduction de son parcours
- synthèse de l'application : le pitch de l'appli

Nooky application allows you to create or join virtual communities in order to get, give or exchange products from members of your communities.

- ce que l'on a fait jusqu'à présent
> wireframe (à faire)
> entities (fait)
> entities relationships (fait)
> MCD (fait)
> UML (à faire)
> choix de la stack (fait)

- wireframe

> à faire

- une présentation de ce que l'on a fait sur les entités

> entities (fait)
> entities relationships (fait)
> MCD (fait)

- présentation des règles métiers

> UML

- présentation et argumentation stack technique

> front: ReactJS
> back: Java + spring ?
> BDD: PostgresSQL

___

Points à travailler

- comment gérer la transmission des infos membre pour les envois de colis ?
- comment gérer les paiements pour l'envoi des colis ? (paypal seulement ?)

--

La Stack : 

SvelteKit (TypeScript) :

SvelteKit est un framework moderne pour la construction d'applications web, offrant des performances optimisées et une syntaxe déclarative.
L'utilisation de TypeScript avec SvelteKit ajoute des avantages en termes de sécurité et de maintenabilité grâce à la vérification statique des types.
Java avec Spring Boot :

Java avec Spring Boot est un choix populaire pour le développement back-end, offrant une grande robustesse, une bonne gestion de la concurrence et une large communauté de support.
Spring Boot simplifie le développement en fournissant des fonctionnalités prêtes à l'emploi et en favorisant les bonnes pratiques de développement.
PostgreSQL :

PostgreSQL est l'un des systèmes de gestion de base de données relationnelle les plus avancés et les plus performants disponibles. Il offre des fonctionnalités avancées telles que la prise en charge des transactions ACID, les index avancés, etc.
PostgreSQL est bien adapté aux applications nécessitant des fonctionnalités avancées de gestion des données et une évolutivité robuste.