yterraillon / clipify Goto Github PK

• install Visual Studio Community 2019
• grab a Resharper licence (student)
• install Postman
• install Docker
• Create an account on Docker hub
• intall Linqpad

Use Mediatr to have a clear separation between Webapp and Application.
Setup Projects dependencies

Move the "WeatherForecast" data provider to the infrastructure

• on the webapp, add a "Login" page with 2 fields for login and password
• on application and infrastructure, implements Spotify's Authorization Code Flow with Proof Key for Code Exchange
  https://developer.spotify.com/documentation/general/guides/authorization-guide/#authorization-code-flow-with-proof-key-for-code-exchange-pkce
  It's a 6 steps authorization fow, that will provide tokens when completed.

For now we will display tokens on the login page

Learn about docker-compose and see if it is relevant to the project.

• Create an empty solution "clipify.sln"
• Add solutions folders : "\source" "\tests" "\docs" "\samples" "\solution items"
• Add a Blazor Server Application named "Clipify.Web" to the source folder
• Add the CodeOwners file

The default site should be running fine on execution

Create new playlist with the same name as the original + something to distinguish it like " - fork" or "- copy"
If possible : move the original playlist into a folder named "originals"

Save in DB the link between original and fork

Business Rule :
A playlist cannot be subscribed to more than one playlist

• Note : maybe a paying feature?

https://code-maze.com/using-the-problemdetails-class-in-asp-net-core-web-api/

A good project has a good readme!

Add the readme file to the repository root, and complete it with the following informations :

Description

CI/CD
Deployed url (docker hub)

Architecture
Used technologies

How to run locally

How to open an issue

Release process

Create a new page that displays all the users playlist, with their Ids, and the version

• Update the authentication scope to display user's playlists

Parts of this app will use Reactive programming

http://reactivex.io/
https://github.com/dotnet/reactive
https://docs.microsoft.com/en-us/previous-versions/dotnet/reactive-extensions/hh242985(v=vs.103)?redirectedfrom=MSDN

Add a button on the playlist page to compare user's playlist version with the ones in DB. Playlists should marked as outdated on the page.

Updated playlists should be available in an Observable List

We will use signalr to send a command from the callback controller to the page

https://docs.microsoft.com/en-us/aspnet/core/tutorials/signalr-blazor?view=aspnetcore-5.0&tabs=visual-studio&pivots=webassembly

Add the following projects to the solution (as library)

• Clipify.Domain
• Clipify.Application
• Clipify.Infrastructure

Update the DockerFile accordingly

Add the following projects to the solution as unittests with xUnit

• Clipify.Domain.UnitTests
• Clipify.Application.UnitTests

All csproj should be :

• Targeting .netCore 3.1 or 5.0
• Handlinging Nullable
• Using C# 8.0 or C#9.0

Running the solution should rise multiple warnings. This should be fixed, we want 0 warning for now

https://www.youtube.com/watch?v=dK4Yb6-LxAk
https://jimmybogard.com/vertical-slice-architecture/

Create a button on the login page that will refresh the authentication token on click

• get the refresh Token
• sends it to spotify api
• gets updated token
• stores it in DB

And add logging : on errors, and everytime a quartz task runs

• Console dans VS
• Console qui s'ouvre au run de l'app
• sauvegarde dans un fichier de log journalisé
• réglage du niveau de log à Info dans les consoles
• Error dans le fichier

In the solution, create a Docs folder (within the sln too), and add a new md file called ArchitectureDecisionRecord
Add a link to it in the readme file

ADR will describe our architectural choices : CQRS, DDD etc

See :

• https://engineering.atspotify.com/2020/04/14/when-should-i-write-an-architecture-decision-record/
• https://adr.github.io/

On the login page, when signed in, display basic user information

• update the auth request and add a scope to it (token will then allow to access user info)
• call spotify api to get user info
• display user info in the page

Palette de couleurs : https://coolors.co/e2edb0-84dc9e-49cf6b-31ba6e-2f4b98

Pack d'icones :

https://www.flaticon.com/packs/music-226

https://www.flaticon.com/packs/music-224

https://www.flaticon.com/authors/pixel-perfect/lineal/3

Loading gifs :

https://cutewallpaper.org/21/loading-gif-transparent-background/view-page-21.html

• Create a github action workflow that build and test the app on each push, on the main branch and on feature/**

Add a button on the playlist page, to save playlists in DB (new table, index : playlistId, content : playlist version, LastCheckedDate, LastModifiedDate)

A user shouldn't have access to a page if he's not logged into spotify.

• Move User Information to a new page
• This page should be visible only if the user is logged in.
• Otherwise reroute to login page.

Note : we need a way to handle user login status. Could just be Auth Token in local storage

• on Github, define 2 secrets and fill them with the Docker Hub Credentials
  DOCKERHUB_PASSWORD
DOCKERHUB_USERNAME

Password is a new PAT from DockerHub (ask for it)
Username is clipify

• Create a new github workflow named docker-publish
• test the workflow : the docker image should be published on docker hub and public

Tokens should not be stored in memory, as this would require to login each the app restarts.
Instead we will store them in a liteDb

https://www.litedb.org/

• Using Visual Studio, add a Dockerfile to the Blazor application
• Add the volumes to DockerFile :
  VOLUME /config /data
• in the csproj, add the following :

<PropertyGroup> <DockerfileRunArguments>-v "C:\Docker\Clipify\data:/data" -v "C:\Docker\Clipify\config:/config"</DockerfileRunArguments> </PropertyGroup>

Add a logout button to the login page

• delete tokens from DB
• delete tokens from local storage

Create a page, that will receive a playlist id and display all the songs in it, with their ids and Added Date

• Update auth scopes if needed