Initial commit

Angular/README.md

@@ -1,2 +1,2 @@
-# oussamaakallouch
+# ANGULAR
 

Angular/src/app/app-routing.module.ts

@@ -1,28 +1,30 @@
 import { NgModule } from '@angular/core';
 import { RouterModule, Routes } from '@angular/router';
 import { AppMainComponent } from './app.main.component';
+import { CandidatListComponent } from './pages/candidat/candidat-list/candidat-list.component';
+import { DashboardComponent } from './pages/dashboard/dashboard/dashboard.component';
 
 export const appRouteList: Routes = [
     {
         path: 'app', component: AppMainComponent,
         loadChildren: () => import('./pages/pages.routing.module').then(m => m.PagesRoutingModule)
-    },
-    {
-        path: '**',
-        redirectTo: 'app/dashboard/dashboard'
     }
 ];
 
 @NgModule({
-    exports: [
-        RouterModule
-    ],
     imports: [
-        RouterModule.forRoot(appRouteList, {
-            scrollPositionRestoration: 'enabled', // Add options right here
-            relativeLinkResolution: 'legacy'
-        })
-    ]
+        RouterModule.forRoot([
+            {
+                path: '', component: AppMainComponent,
+                children: [
+                    {path: 'candidat/candidat-list', component: CandidatListComponent},
+                    {path: 'dashboard', component: DashboardComponent},
+                ]
+            },
+            {path: '**', redirectTo: '/notfound'},
+        ], {scrollPositionRestoration: 'enabled'})
+    ],
+    exports: [RouterModule]
 })
 export class AppRoutingModule {
 }

Angular/src/app/app.menu.component.ts

@@ -20,7 +20,8 @@ export class AppMenuComponent implements OnInit {
             {
                 label: 'Natan', icon: 'pi pi-fw pi-home',
                 items: [
-                    {label: 'Dashboard', icon: 'pi pi-fw pi-home', routerLink: ['/']},
+                    {label: 'Dashboard', icon: 'pi pi-fw pi-home', routerLink: ['/dashboard']},
+                    {label: 'Candidates', icon: 'pi pi-fw pi-users', routerLink: ['/candidat/candidat-list']},
                 ]
             }
         ];

Angular/src/app/app.module.ts

@@ -106,6 +106,7 @@ import dayGridPlugin from '@fullcalendar/daygrid';
 import timeGridPlugin from '@fullcalendar/timegrid';
 import interactionPlugin from '@fullcalendar/interaction';
 
+
 FullCalendarModule.registerPlugins([
     dayGridPlugin,
     timeGridPlugin,

Angular/src/app/pages/candidat/candidat-detail/candidat-detail.component.html

@@ -0,0 +1,37 @@
+<div>
+    <div>
+        <div class="modal-header">
+          <h4 class="modal-title" id="modal-basic-title">Candidate Detail</h4>
+          <button type="button" class="close" aria-label="Close">
+            <span aria-hidden="true">×</span>
+          </button>
+        </div>
+        <div class="modal-body">
+            <form>
+                <div class="form-group">
+                    <label for="firstName">First Name</label>
+                    <input type="text" class="form-control" id="firstName" value="">
+                </div>
+                <div class="form-group">
+                    <label for="LastName">Last Name</label>
+                    <input type="text" class="form-control" id="lastName" value="">
+                </div>
+                <div class="form-group">
+                    <label for="type">Emails Type's</label>
+                    <select class="form-control" id="type">
+                      <option>Professional</option>
+                      <option>Personal</option>
+                    </select>
+                  </div>
+                <div class="form-group">
+                  <label for="emails">Emails address</label>
+                  <input type="emails" class="form-control" id="emails">
+                </div>
+                
+              </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-outline-dark">Ok</button>
+        </div>
+    </div>
+</div>>

Angular/src/app/pages/candidat/candidat-detail/candidat-detail.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { CandidatDetailComponent } from './candidat-detail.component';
+
+describe('CandidatDetailComponent', () => {
+  let component: CandidatDetailComponent;
+  let fixture: ComponentFixture<CandidatDetailComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ CandidatDetailComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(CandidatDetailComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

Angular/src/app/pages/candidat/candidat-detail/candidat-detail.component.ts

@@ -0,0 +1,35 @@
+import { HttpClient } from '@angular/common/http';
+import { Component, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { Observable } from 'rxjs';
+import { AppBreadcrumbService } from 'src/app/app.breadcrumb.service';
+import { Candidate } from 'src/app/shared/models/candidate';
+import { CandidateService } from 'src/app/shared/services/candidate.service';
+
+@Component({
+  selector: 'app-candidat-detail',
+  templateUrl: './candidat-detail.component.html',
+  styleUrls: ['./candidat-detail.component.scss']
+})
+export class CandidatDetailComponent implements OnInit {
+
+  private _candidat: Observable<Candidate> = new Observable<Candidate>() ;
+  paramId: string;
+  constructor(private breadcrumbService: AppBreadcrumbService,private http: HttpClient, private candidateService: CandidateService, private route: ActivatedRoute) {
+    this.breadcrumbService.setItems([
+      { label: 'Candidats' },
+      { label: 'Detail', routerLink: ['/candidat/:candidatId/candidat-list'] }
+    ]);
+  }
+
+  ngOnInit(): void {
+  //  this.route.data.subscribe((data: { candidat: Observable<Candidate> }) => this._candidat = data.candidat);
+    this.route.paramMap.subscribe(params => {
+      if (params.get('candidatId')) {
+        this.paramId = params.get('candidatId');
+      }
+    });
+    this._candidat = this.candidateService.candidatGetById(this.paramId);
+  }
+
+}

Angular/src/app/pages/candidat/candidat-list/candidat-list.component.html

@@ -0,0 +1,75 @@
+<div class="card">
+    <h5>Candidates List</h5>
+    <div><button [routerLink]="'/dasboard/dasboard'" type="button" class="primary">Add</button><br></div>
+    <table class="table table-bordered">
+        <thead>
+          <tr>
+            <th scope="col">#</th>
+            <th scope="col">First Name</th>
+            <th scope="col">Last Name</th>
+            <th scope="col">Emails</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr  *ngFor="let candidate of candidates | async">
+                <td>{{candidate.id}}</td>
+                <td>{{candidate.firstName}}</td>
+                <td>{{candidate.lastName}}</td>
+                <td>
+                    <tr *ngFor="let ml of candidate.emails">
+                      <span>{{ml.email}}</span>
+                      <span> - {{ml.type}}</span>
+                    </tr>
+                </td>
+                <td>
+                  <button  icon="pi pi-pencil" class="p-button-rounded p-button-success mr-2" (click)="show(candidate)">edit</button>
+                  <button  icon="pi pi-trash" class="p-button-rounded p-button-warning">delete</button>
+               </td>
+          </tr>
+        </tbody>
+      </table>
+      <div>
+        <form name="editForm" role="form">
+            <button>Search</button>
+        </form>
+      </div>
+
+      <div *ngIf="isEdit">
+        <app-candidat-detail></app-candidat-detail>
+    </div>
+   <!-- <button [routerLink]="'/candidate/candidate-sidebar'" pButton pRipple type="button" label="Add" class="mr-2 mb-2"></button> -->
+   <!--  <p-table #dt  [value]="theCandidates" [paginator]="true" [rows]="5" [showCurrentPageReport]="true" responsiveLayout="scroll"
+        currentPageReportTemplate="Showing {first} to {last} of {totalRecords} entries" [rowsPerPageOptions]="[5,10,25,50]">
+        <ng-template pTemplate="header">
+            <tr>
+                <th>Id</th>
+                <th>First Name</th>
+                <th>Last Name</th>
+                <th>Emails</th>
+            </tr>
+        </ng-template>
+        <ng-template pTemplate="body" let-candidate>
+            <tr>
+                <td>{{candidate.id}}</td>
+                <td>{{candidate.firstname}}</td>
+                <td>{{candidate.lastname}}</td>
+                <td>
+                    <tr *ngFor="let ml of candidate.emails">
+                      <span>{{ml.email}}</span>
+                      <span> - {{ml.type}}</span>
+                    </tr>
+                </td>
+                <td>
+                  <button pButton pRipple icon="pi pi-pencil" class="p-button-rounded p-button-success mr-2"></button>
+                  <button pButton pRipple icon="pi pi-trash" class="p-button-rounded p-button-warning"></button>
+               </td>
+            </tr>
+        </ng-template>
+        <ng-template pTemplate="paginatorleft">
+          <span class="p-float-label">
+            <input type="text" class="w-full" pInputText>
+            <label>Search</label>
+          </span>
+        </ng-template>
+    </p-table> -->
+</div>

Angular/src/app/pages/candidat/candidat-list/candidat-list.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { CandidatListComponent } from './candidat-list.component';
+
+describe('CandidatListComponent', () => {
+  let component: CandidatListComponent;
+  let fixture: ComponentFixture<CandidatListComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ CandidatListComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(CandidatListComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

Angular/src/app/pages/candidat/candidat-list/candidat-list.component.ts

@@ -0,0 +1,42 @@
+import { HttpClient } from '@angular/common/http';
+import { Component, OnInit, ViewChild } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { ActivatedRoute } from '@angular/router';
+import { Table } from 'primeng/table';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { AppBreadcrumbService } from 'src/app/app.breadcrumb.service';
+import { Candidate } from 'src/app/shared/models/candidate';
+import { candidatListService } from './candidat-list.service';
+
+@Component({
+  selector: 'app-candidat-list',
+  templateUrl: './candidat-list.component.html',
+  styleUrls: ['./candidat-list.component.scss']
+})
+export class CandidatListComponent implements OnInit {
+    isEdit: boolean = false;
+    candidates: Observable<Candidate[]>;
+    candidate: Candidate;
+    constructor(private breadcrumbService: AppBreadcrumbService,private http: HttpClient, private candidatListService: candidatListService, private route: ActivatedRoute) {
+      this.breadcrumbService.setItems([
+        { label: 'Candidats' },
+        { label: 'List', routerLink: ['/candidat/candidat-list'] }
+      ]);
+  }
+
+  ngOnInit() {
+    this.route.data.subscribe((data: { candidats: Observable<Candidate[]> }) => this.candidates = data.candidats);
+    this.candidates = this.candidatListService.getCandidats();
+  }
+  show(candidateUI: Candidate){
+   // this.route.navigate(); // navigate to other page
+    this.isEdit = true;
+    this.candidate = new Candidate()
+    this.candidate.id = candidateUI.id;
+    this.candidate.firstName = candidateUI.firstName;
+    this.candidate.lastName = candidateUI.lastName;
+    this.candidate.emails = candidateUI.emails;
+    
+  }
+}

Angular/src/app/pages/candidat/candidat-list/candidat-list.service.ts

@@ -0,0 +1,32 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { switchMap, tap } from 'rxjs/operators';
+import { TreeNode } from 'primeng/api';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Candidate } from 'src/app/shared/models/candidate';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class candidatListService {
+
+    private _candidats = new BehaviorSubject<Candidate[]>([]);
+    private dataStore: { candidats: Candidate[] } = { candidats: [] };
+    readonly candidats = this._candidats.asObservable();
+
+    constructor(private http: HttpClient) {}
+
+    loadAll() {
+        this.http.get<Candidate[]>('assets/demo/data/candidates.json').subscribe(
+          data => {
+            this.dataStore.candidats = data;
+            this._candidats.next(Object.assign({}, this.dataStore).candidats);
+          },
+          error => console.log('Could not load Candidats.')
+        );
+      }
+    getCandidats(): Observable<Candidate[]>{
+     this.loadAll();
+     return this.candidats
+    }
+}

Angular/src/app/pages/candidat/candidat-search/candidat-search.component.html

@@ -0,0 +1 @@
+<p>candidat-search works!</p>

Angular/src/app/pages/candidat/candidat-search/candidat-search.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { CandidatSearchComponent } from './candidat-search.component';
+
+describe('CandidatSearchComponent', () => {
+  let component: CandidatSearchComponent;
+  let fixture: ComponentFixture<CandidatSearchComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ CandidatSearchComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(CandidatSearchComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

Angular/src/app/pages/candidat/candidat-search/candidat-search.component.ts

@@ -0,0 +1,15 @@
+import { Component, OnInit } from '@angular/core';
+
+@Component({
+  selector: 'app-candidat-search',
+  templateUrl: './candidat-search.component.html',
+  styleUrls: ['./candidat-search.component.scss']
+})
+export class CandidatSearchComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit(): void {
+  }
+
+}

Angular/src/app/pages/candidat/candidat.module.ts

@@ -0,0 +1,39 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CandidatListComponent } from './candidat-list/candidat-list.component';
+import { RouterModule, Routes } from '@angular/router';
+import { CandidatSearchComponent } from './candidat-search/candidat-search.component';
+import { CandidatsResolver } from 'src/app/shared/resolver/candidats.resolver';
+import { CandidatDetailComponent } from './candidat-detail/candidat-detail.component';
+import { CandidatDetailResolver } from 'src/app/shared/resolver/candidat-detail.resolver';
+
+
+export const routes: Routes = [
+  {
+      path: 'candidat/candidat-list',
+      component: CandidatListComponent,
+      resolve: {
+        Candidats: CandidatsResolver 
+      },
+  },
+  {
+    path: 'candidat/:candidatId/candidat-detail',
+    component: CandidatDetailComponent,
+    resolve: {
+      Candidat: CandidatDetailResolver 
+    },
+}
+];
+
+@NgModule({
+  declarations: [
+    CandidatListComponent,
+    CandidatSearchComponent,
+    CandidatDetailComponent
+  ],
+  imports: [
+    CommonModule,
+    RouterModule.forChild(routes)
+  ]
+})
+export class CandidatModule { }

Angular/src/app/pages/pages.routing.module.ts

@@ -5,6 +5,10 @@ export const pagesRouteList: Routes = [
     {
         path: 'dashboard',
         loadChildren: () => import('./dashboard/dashboard.module').then(m => m.DashboardModule)
+    },
+    {
+        path: 'candidat/candidat-list',
+        loadChildren: () => import('./candidat/candidat.module').then(m => m.CandidatModule)
     }
     
 ];

Angular/src/app/shared/models/candidate.ts

@@ -1,7 +1,7 @@
 export class Candidate {
     id: string;
-    firstname: string;
-    lastname: string;
+    firstName: string;
+    lastName: string;
     emails: [];
 }
 

Angular/src/app/shared/resolver/candidat-detail.resolver.ts

@@ -0,0 +1,18 @@
+import { Injectable } from "@angular/core";
+import { ActivatedRoute, ActivatedRouteSnapshot, ParamMap, Resolve } from "@angular/router";
+import { HttpClient, HttpHeaders } from "@angular/common/http";
+import { Candidate } from "../models/candidate";
+import { Observable } from "rxjs";
+import { CandidateService } from "../services/candidate.service";
+import { filter, map, switchMap, tap } from "rxjs/operators";
+
+@Injectable()
+export class CandidatDetailResolver implements Resolve<Candidate> {
+  constructor(public service: CandidateService, private route: ActivatedRoute) {}
+  resolve(): Observable<Candidate> {
+      return this.route.queryParams.pipe(
+        map(params => params['candidatId']),
+        switchMap(candidatId => this.service.candidatGetById(candidatId)),
+      );
+    }
+}

Angular/src/app/shared/resolver/candidats.resolver.ts

@@ -0,0 +1,14 @@
+import { Injectable } from "@angular/core";
+import { Resolve } from "@angular/router";
+import { HttpClient, HttpHeaders } from "@angular/common/http";
+import { Candidate } from "../models/candidate";
+import { candidatListService } from "src/app/pages/candidat/candidat-list/candidat-list.service";
+import { Observable } from "rxjs";
+
+@Injectable()
+export class CandidatsResolver implements Resolve<Candidate[]> {
+  constructor(public service: candidatListService) {}
+  resolve(): Observable<Candidate[]> {
+    return this.service.getCandidats();
+  }
+}

Angular/src/app/shared/services/candidate.service.ts

@@ -1,9 +1,35 @@
+import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Candidate } from '../models/candidate';
 
 @Injectable({
   providedIn: 'root'
 })
 export class CandidateService {
 
-  constructor() { }
+  constructor(private http: HttpClient) { }
+
+  listOfCandidates() {
+    return this.http.get<any>('assets/demo/data/candidates.json')
+            .toPromise()
+            .then(res => res.data as Candidate[])
+            .then(data => data);
+  }
+  
+  candidatGetById(id: string): Observable<Candidate> {
+     return null;
+  }
+  async Search(query: string): Promise<Candidate[]> {
+    let candidates = this.listOfCandidates();
+    let candidatesFilter: Candidate[] ;
+    for (let item of await candidates) 
+    {
+      if (item.firstName == query || item.lastName == query) 
+      {
+        candidatesFilter.push(item);
+      }
+    }  
+    return candidatesFilter
+  }
 }

Angular/src/assets/demo/data/candidates.json

@@ -1,5 +1,4 @@
-{
-	"data": [
+ [
 		{
 			"id": "1",
 			"firstName": "Tom",
@@ -24,5 +23,4 @@
 			"lastName": "Jackson",
 			"emails": []
 		}
-	]
-}
+]

Angular/src/index.html

@@ -13,6 +13,7 @@
 
     <link id="theme-css" rel="stylesheet" type="text/css" href="assets/theme/indigo/theme-light.css">
     <link id="layout-css" rel="stylesheet" type="text/css" href="assets/layout/css/layout-light.css">
+    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
 </head>
 <body>
     <app-root>

CQRS/.dockerignore

@@ -0,0 +1,25 @@
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

CQRS/Backend.API/Backend.API.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <DockerDefaultTargetOS>Windows</DockerDefaultTargetOS>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.11.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Swagger" Version="6.2.3" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="6.2.3" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="6.2.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Backend.ApplicationCore\Backend.ApplicationCore.csproj" />
+    <ProjectReference Include="..\Backend.Domain\Backend.Domain.csproj" />
+    <ProjectReference Include="..\Backend.Infrastructure\Backend.Infrastructure.csproj" />
+    <ProjectReference Include="..\Backend.Persistence\Backend.Persistence.csproj" />
+  </ItemGroup>
+
+
+</Project>

CQRS/Backend.API/Backend.API.csproj.user

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Controller_SelectedScaffolderID>MvcControllerEmptyScaffolder</Controller_SelectedScaffolderID>
+    <Controller_SelectedScaffolderCategoryPath>root/Common/MVC/Controller</Controller_SelectedScaffolderCategoryPath>
+    <ActiveDebugProfile>IIS Express</ActiveDebugProfile>
+    <ShowAllFiles>false</ShowAllFiles>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebuggerFlavor>ProjectDebugger</DebuggerFlavor>
+  </PropertyGroup>
+</Project>

CQRS/Backend.API/Config/DependencyInjectionHandler.cs

@@ -0,0 +1,43 @@
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Config
+{
+    internal static class DependencyInjectionHandler
+    {
+        internal static IServiceCollection AddMediaRHandlerDependency(this IServiceCollection services)
+        {
+            services.AddMediatR(Assembly.GetExecutingAssembly());
+            services.AddMediatR(typeof(GetTypeProprieteListHandler).Assembly);
+            services.AddMediatR(typeof(AddTypeProprieteHandler).Assembly);
+            services.AddMediatR(typeof(RemoveTypeProprieteHandler).Assembly);
+
+            services.AddMediatR(typeof(GetProprieteListHandler).Assembly);
+            services.AddMediatR(typeof(AddProprieteHandler).Assembly);
+            services.AddMediatR(typeof(RemoveProprieteHandler).Assembly);
+
+            services.AddMediatR(typeof(GetProduitListHandler).Assembly);
+            services.AddMediatR(typeof(AddProduitHandler).Assembly);
+            services.AddMediatR(typeof(RemoveProduitHandler).Assembly);
+
+            services.AddMediatR(typeof(GetCommandeListHandler).Assembly);
+            services.AddMediatR(typeof(AddCommandeHandler).Assembly);
+            services.AddMediatR(typeof(RemoveCommandeHandler).Assembly);
+
+            services.AddMediatR(typeof(GetLigneCommandeListHandler).Assembly);
+            services.AddMediatR(typeof(AddLigneCommandeHandler).Assembly);
+            services.AddMediatR(typeof(RemoveLigneCommandeHandler).Assembly);
+
+            return services;
+        }
+
+    }
+}

CQRS/Backend.API/Config/DependencyInjectionRepository.cs

@@ -0,0 +1,23 @@
+using Backend.ApplicationCore.Interfaces.IRepositories;
+using Backend.Infrastructure.Repositories;
+using Backend.Persistence.Config;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Backend.API.Config
+{
+    internal static class DependencyInjectionRepository
+    {
+        internal static IServiceCollection AddDataDependencyInjectionRepository(this IServiceCollection services)
+        {
+            services.AddScoped<IApplicationDatabaseContext, ApplicationDatabaseContext>();
+            services.AddScoped<ICommandeRepository, CommandeRepository>();
+            services.AddScoped<ILigneCommandeRepository, LigneCommandeRepository>();
+            services.AddScoped<IProduitRepository, ProduitRepository>();
+            services.AddScoped<IProprieteRepository, ProprieteRepository>();
+            services.AddScoped<ITypeProprieteRepository, TypeProprieteRepository>();
+
+            return services;
+        }
+
+    }
+}

CQRS/Backend.API/Config/DependencyInjectionService.cs

@@ -0,0 +1,30 @@
+using Backend.ApplicationCore.Interfaces.IServices;
+using Backend.ApplicationCore.Services;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Config
+{
+    internal static class DependencyInjectionService
+    {
+        internal static IServiceCollection AddDependencyInjectionService(this IServiceCollection services)
+        {
+            services.AddScoped<ITypeProprieteService, TypeProprieteService>();
+            services.AddScoped<IProprieteService, ProprieteService>();
+            services.AddScoped<IProduitService, ProduitService>();
+            services.AddScoped<ICommandeService, CommandeService>();
+            services.AddScoped<ILigneCommandeService, LigneCommandeService>();
+            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+
+            return services;
+        }
+
+    }
+}

CQRS/Backend.API/Config/SwaggerExtensions.cs

@@ -0,0 +1,46 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Config
+{
+    internal static class SwaggerExtensions
+    {
+        internal static IServiceCollection AddSwaggerDocumentation(this IServiceCollection services)
+        {
+            services.AddSwaggerGen(options =>
+            {
+                options.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
+                {
+                    Title = "Sample CQRS Catalogue.Backend.API",
+                    Version = "v1",
+                    Description = "Sample .NET Core REST API CQRS implementation using Clean Architecture.",
+                });
+
+                var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
+                var commentsFileName = Assembly.GetExecutingAssembly().GetName().Name + ".XML";
+                var commentsFile = Path.Combine(baseDirectory, commentsFileName);
+               // options.IncludeXmlComments(commentsFile);
+            });
+
+            return services;
+        }
+
+        internal static IApplicationBuilder UseSwaggerDocumentation(this IApplicationBuilder app)
+        {
+            app.UseSwagger();
+
+            app.UseSwaggerUI(c =>
+            {
+                c.SwaggerEndpoint("/swagger/v1/swagger.json", "Sample CQRS API V1");
+            });
+
+            return app;
+        }
+    }
+}

CQRS/Backend.API/Controllers/CommandeController.cs

@@ -0,0 +1,167 @@
+
+using Backend.Domain;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class CommandeController : ControllerBase
+    {
+        private const string c_getAllCommande = "getAll"; 
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
+
+        private readonly ILogger<CommandeController> _log;
+        private readonly IMediator _mediator;
+
+        public CommandeController(ILogger<CommandeController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(c_getAllCommande)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllAsync()
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Type");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            try
+            {
+                var query = new GetCommandeListQuery();
+                using Task<IEnumerable<CommandeResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(c_postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddCommandeCommand cmd)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(c_deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveCommandeCommand removeCommandeCommand = new RemoveCommandeCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeCommandeCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CQRS/Backend.API/Controllers/LigneCommandeController.cs

@@ -0,0 +1,167 @@
+
+using Backend.Domain;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class LigneCommandeController : ControllerBase
+    {
+        private const string c_getAllLigneCommande = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
+
+        private readonly ILogger<LigneCommandeController> _log;
+        private readonly IMediator _mediator;
+
+        public LigneCommandeController(ILogger<LigneCommandeController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(c_getAllLigneCommande)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllAsync()
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Ligne commande");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            try
+            {
+                var query = new GetLigneCommandeListQuery();
+                using Task<IEnumerable<LigneCommandeResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update ligne commande id?
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(c_postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddLigneCommandeCommand cmd)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Ligne commande");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(c_deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete ligne commande by: {id}");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveLigneCommandeCommand removeLigneCommandeCommand = new RemoveLigneCommandeCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeLigneCommandeCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CQRS/Backend.API/Controllers/ProduitController.cs

@@ -0,0 +1,167 @@
+
+using Backend.Domain;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class ProduitController : ControllerBase
+    {
+        private const string c_getAllProduit = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
+
+        private readonly ILogger<ProduitController> _log;
+        private readonly IMediator _mediator;
+
+        public ProduitController(ILogger<ProduitController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(c_getAllProduit)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllAsync()
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all produit");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            try
+            {
+                var query = new GetProduitListQuery();
+                using Task<IEnumerable<ProduitResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update type
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(c_postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddProduitCommand cmd)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Produit");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(c_deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveProduitCommand removeProduitCommand = new RemoveProduitCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeProduitCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CQRS/Backend.API/Controllers/ProprieteController.cs

@@ -0,0 +1,167 @@
+
+using Backend.Domain;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class ProprieteController : ControllerBase
+    {
+        private const string c_getAllPropriete = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}";
+
+        private readonly ILogger<ProprieteController> _log;
+        private readonly IMediator _mediator;
+
+        public ProprieteController(ILogger<ProprieteController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(c_getAllPropriete)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllAsync()
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all Propriete");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            try
+            {
+                var query = new GetProprieteListQuery();
+                using Task<IEnumerable<ProprieteResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update propriete
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(c_postCreateOrUpdate)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddProprieteCommand cmd)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if(cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+           
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(c_deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete propriete by: {id}");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveProprieteCommand removeProprieteCommand = new RemoveProprieteCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeProprieteCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CQRS/Backend.API/Controllers/TypeProprieteController.cs

@@ -0,0 +1,166 @@
+using Backend.Domain;
+using Backend.Models;
+using Mediator;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Backend.API.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class TypeProprieteController : ControllerBase
+    {
+        private const string c_getAllTypePropriete = "getAll";
+        private const string c_postCreateOrUpdate = "createOrUpdate";
+        private const string c_deleteById = "deleteById/{id}"; 
+
+        private readonly ILogger<TypeProprieteController> _log;
+        private readonly IMediator _mediator;
+
+        public TypeProprieteController(ILogger<TypeProprieteController> log, IMediator mediator)
+        {
+            _log = log;
+            _mediator = mediator;
+        }
+
+        /// <summary>
+        /// get all type propriete
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet(c_getAllTypePropriete)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllAsync()
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to get all TypePropriete");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            try
+            {
+                var query = new GetTypeProprieteListQuery();
+                using Task<IEnumerable<TypeProprieteResponse>> typesTask = _mediator.Send(query);
+                await typesTask;
+                if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                {
+                    return Ok(typesTask.Result);
+                }
+                else
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                }
+            }
+            catch (Exception ex)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+            }
+
+        }
+
+        /// <summary>
+        /// create or update typePropriete
+        /// </summary>
+        /// <param name="cmd"></param>
+        /// <returns></returns>
+        [HttpPost(c_postCreateOrUpdate)] 
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> CreateOrUpdateAsync([FromBody] AddTypeProprieteCommand cmd)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to create or update Type");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if (cmd != null)
+            {
+                try
+                {
+                    using Task<int> typesTask = _mediator.Send(cmd);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+
+        }
+
+        /// <summary>
+        /// delete type by id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [HttpDelete(c_deleteById)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> DeleteByIdAsync([FromRoute] Guid id)
+        {
+            _log.LogDebug($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Request to delete type by: {id}");
+            if (_mediator == null)
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+            }
+            if (id != null)
+            {
+                try
+                {
+                    RemoveTypeProprieteCommand removeTypeProprieteCommand = new RemoveTypeProprieteCommand { Id = id };
+                    using Task<int> typesTask = _mediator.Send(removeTypeProprieteCommand);
+                    await typesTask;
+                    if (typesTask.IsCompleted && typesTask.IsCompletedSuccessfully)
+                    {
+                        return Ok(typesTask.Result);
+                    }
+                    else
+                    {
+                        _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_5XX}");
+                        return StatusCode(StatusCodes.Status500InternalServerError, ErrorsConstants.S_HTTP_ERROR_5XX);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - Exception:{ex.Message}");
+                    return StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
+                }
+            }
+            else
+            {
+                _log.LogError($"{this.GetType().Name} -> {MethodBase.GetCurrentMethod()} - {ErrorsConstants.S_HTTP_ERROR_4XX}");
+                return StatusCode(StatusCodes.Status400BadRequest, ErrorsConstants.S_HTTP_ERROR_4XX);
+            }
+
+        }
+    }
+}

CQRS/Backend.API/Dockerfile

@@ -0,0 +1,29 @@
+#See https://aka.ms/containerfastmode to understand how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
+#Depending on the operating system of the host machines(s) that will build or run the containers, the image specified in the FROM statement may need to be changed.
+#For more information, please see https://aka.ms/containercompat
+
+FROM mcr.microsoft.com/dotnet/aspnet:3.1 AS base
+WORKDIR /app
+EXPOSE 80
+
+FROM mcr.microsoft.com/dotnet/sdk:3.1 AS build
+WORKDIR /src
+COPY ["Backend.API/Backend.API.csproj", "Backend.API/"]
+COPY ["Backend.Common/Backend.Common.csproj", "Backend.Common/"]
+COPY ["Mediator/Mediator.csproj", "Mediator/"]
+COPY ["Backend.Models/Backend.Models.csproj", "Backend.Models/"]
+COPY ["Backend.Services/Backend.Services.csproj", "Backend.Services/"]
+COPY ["Backend.Data/Backend.Data.csproj", "Backend.Data/"]
+RUN dotnet restore "Backend.API/Backend.API.csproj"
+COPY . .
+WORKDIR "/src/Backend.API"
+RUN dotnet build "Backend.API.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "Backend.API.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "Backend.API.dll"]

CQRS/Backend.API/Program.cs

@@ -0,0 +1,26 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Backend.API
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateHostBuilder(args).Build().Run();
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
+    }
+}

CQRS/Backend.API/Properties/launchSettings.json

@@ -0,0 +1,36 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:43012/",
+      "sslPort": 0
+    }
+  },
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "Backend.API": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:5000"
+    },
+    "Docker (1)": {
+      "commandName": "Docker",
+      "launchBrowser": true,
+      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}/swagger",
+      "publishAllPorts": true
+    }
+  }
+}

CQRS/Backend.API/Startup.cs

@@ -0,0 +1,68 @@
+using Backend.API.Config;
+using Backend.ApplicationCore.Mapper;
+using Backend.Persistence.Config;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using System;
+
+namespace Backend.API
+{
+    public class Startup
+    {
+        private readonly IConfiguration _configuration = null;
+        private readonly IHostEnvironment _appEnvironment = null;
+        public Startup(IConfiguration configuration, IHostEnvironment appEnvironment)
+        {
+            _configuration = configuration;
+            _appEnvironment = appEnvironment;
+        }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddControllers();
+            services.AddOptions();
+            services.AddDependencyInjectionService();
+            services.AddDataDependencyInjectionRepository();
+            services.AddMediaRHandlerDependency();
+            services.AddAutoMapperConfig();
+            services.AddSwaggerDocumentation();
+            AddDatabase(services);
+        }
+
+
+
+        protected virtual void AddDatabase(IServiceCollection services)
+        {
+            if (services != null)
+            {
+                services.AddDatabaseModule(_configuration);
+            }
+        }
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IServiceProvider serviceProvider)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseRouting();
+
+            app.UseAuthorization();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapControllers();
+            });
+            app.UseApplicationDatabase(serviceProvider);
+            app.UseSwaggerDocumentation();
+        }
+
+    
+
+    }
+}

CQRS/Backend.API/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

CQRS/Backend.API/appsettings.json

@@ -0,0 +1,13 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "ConnectionStrings": {
+    "AppDbContext": "server=localhost; port=3306; database=cataloguedb; user=root; password=Password123*; Persist Security Info=False; Connect Timeout=300"
+  },
+  "AllowedHosts": "*"
+}

CQRS/Backend.API/bin/Debug/netcoreapp3.1/Backend.API.runtimeconfig.dev.json

@@ -0,0 +1,8 @@
+{
+  "runtimeOptions": {
+    "additionalProbingPaths": [
+      "C:\\Users\\Alex ONDOA BALEGNAMA\\.dotnet\\store\\|arch|\\|tfm|",
+      "C:\\Users\\Alex ONDOA BALEGNAMA\\.nuget\\packages"
+    ]
+  }
+}

CQRS/Backend.API/bin/Debug/netcoreapp3.1/Backend.API.runtimeconfig.json

@@ -0,0 +1,13 @@
+{
+  "runtimeOptions": {
+    "tfm": "netcoreapp3.1",
+    "framework": {
+      "name": "Microsoft.AspNetCore.App",
+      "version": "3.1.0"
+    },
+    "configProperties": {
+      "System.GC.Server": true,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}