Summary

Initialize project structure for the frontend inside the frontend folder at the root of the project.

It must be a React application with the followings with the following requirements:

• Typescript support
• Sass support
• Code style and formatting
• Router
• Form library
• HTTP Client
• Data fetching library

• API Endpoint to list organization
• Consume the Endpoint on the client

Setup frontend test framework and a Github Action workflow that runs these tests

• Github authentication (/auth)
• View account informations (/user/{userId})
• Deactivate an account (/user/{userId}/deactivate
• Create an organisation (POST
  /organisations)
• List organisations (GET /organisations)
• View an organisation shop (GET /articles)
• List articles (GET /articles)
• View details of an article (GET /articles/{articleId})
• #54
• #55
• Create/Update an article (Admin) (/articles && /articles/{articleId})
• #56
• #57

What

When trying to run the linter : make lint

Screenshot

Add integration tests for the api and Github Action workflow that will run this integration tests on commit push.

The integration tests should spin up using docker-compose an api and a postgres container that will be populated with some fixtures data, then used to run the integration tests. To run integration tests we can use postman collection with the newman cli, or use a different option that propose a more readable and reviewable test description config format.

After creating migrations, we will set up models directly in the project that will map to the login in the database !

Just a whole picture of the database !

Users want to create an Organization on Yotas

After authentication, any user can create an organization on Yotas.

Here is the flow of that process:
Flow

Here are fields required for creation:

• Organization name
• Public description of the org

After the organization creation, the system sends an email to the owner

Notices:

• During the process, if the user does not link Yotas app to any account the system must not save anything
• If an account is already linked to a Yotas organization, it will stop the process and notify the user on a screen

We need to set up a bunch of SQL queries for migrations to create and set the database of yotas !

Setup a frontend linter config and GH action

To be completed this issue must have implemented the following features:

• Setup frontend linter
• Setup frontend linter GitHub Action

• Update auth on JWT backend
• Add a salt while generating redirection URL
• Get github redirection URL and redirect the user
• Get the secret returned by Github and perform authentication with the backend

• Setup Docusaurus Project
• Setup Redoc inside Docusaurus
• Define Models
• API Spec for User management and authentication
• API Specs for organisation Creation
• API Specs for shop management, and orders
• API Specs for Operations and Wallet
• API Specs for Organisation Management
• API Specs for File Upload

After setting up the yotas-webhook module in the project, we're going to establish communication with the api in the project !

Actually a project is allready working for this task !
The main goal is to connect the source code of in this project, then transform it to a module !

CI

• Linter frontend/backend
• Setup and Run integration test

CD

• Backend: Run serverless container (Explore deployment on cloud run)
• Frontend: Container deployment
• Set up staging and prod environment for the backend and frontend

Setup local env

We would like to enforce certain rules around how we generally write go code.

To completed this issue should implements the following features :

• Setup golangci linter
• Setup yotas api linting GH Action workflow

Add a frontend dockerfile and a Github Action workflow to build and push the image to the dockerhub container registry

What

• Error building a documentation

Screenshot

Add pre-push githook for developers to test their code and api before it is pushed to a remote branch.

Summary

We need to figure out how GitHub App and Oauth work, explore solutions for DB migration, ORM and Golang frameworks.

Oauth Exploration

Github App Exploration

CI

• Check conventional commit
• Linter frontend/backend
• Run unit tests

New users need to create an account, and existing users want to log in.

Given the fact that all users of Yotas should come from GitHub, it is easier for them to use their Github account to log in.

Here Is the flow of the Login:
sketch

If It is the first time the user clicks on the Sign In button and does not Have a Yotas account we should save his Token and personal data.

Here is the list of information about the user that is important for Yotas:

• Github Id
• Email
• Github username
• Name

After the first Sign In and account creation, Yotas send a welcome email to the user.

• Endpoint to list articles from a random organisations
• Fetch the list of articles on the client

For our commit message to be consistent on how they are formatted, we would like to add a Conventional commit github action or simply enable the semantic pull request app to our repository

• Project Description

• https://www.notion.so/Pre-Planning-f8524ebf23394bb28abc6c2851111643

• Basic Mockups
  https://www.figma.com/file/qKOBVoxmc6izVIuQDqT9iw/Style-guide?node-id=66%3A241

• User workflow
  https://miro.com/welcomeonboard/i3dY79Ceh6NtHetanrzgl3azda0k7FkpZwx23u0Nipwcxf8K63gIvvjMNIAWK20v

• Entity diagrams:
  https://drive.google.com/file/d/1LMQ2mvoIKh75dAhDUjYqaFHWtZgPqHqw/view?usp=sharing

Define the base structure of the project, it is a mono repo.

It should contain:

• React app for the frontend
• Golang app for the backend
• Automations files

Add a dockerfile for the api and add a Github Action workflow that build and push images to the dockerhub container registry

• Home Page Online
• Home Page Offline
• My Account page
• Organisation creation Page
• Organisation List page