diff --git a/src/app/Repositories/IOrderRepository.cs b/src/app/Repositories/IOrderRepository.cs
index b88419f..26a1783 100644
--- a/src/app/Repositories/IOrderRepository.cs
+++ b/src/app/Repositories/IOrderRepository.cs
@@ -5,7 +5,7 @@ namespace app.Repositories;
 public interface IOrderRepository
 {
     event Action<Order> OrderProcessed;
-    void Add(Order order);
+    Order? Add(Order order);
     Order? GetById(int id);
     IReadOnlyCollection<Order> GetAll();
 }
diff --git a/src/app/Repositories/IProductsRepository.cs b/src/app/Repositories/IProductsRepository.cs
index 88c4869..f8ac063 100644
--- a/src/app/Repositories/IProductsRepository.cs
+++ b/src/app/Repositories/IProductsRepository.cs
@@ -6,4 +6,8 @@ public interface IProductsRepository
 {
     IReadOnlyCollection<Product> GetAll();
     Product? GetById(int Id);
+    IList<Product> GetProductByOrderId(int Id);
+    Product? Add(Product product);
+     bool Update(Product product);
+
 }
diff --git a/src/app/Services/OrderService.cs b/src/app/Services/OrderService.cs
index b707607..c0afdc6 100644
--- a/src/app/Services/OrderService.cs
+++ b/src/app/Services/OrderService.cs
@@ -15,10 +15,9 @@ public OrderService(IOrderRepository orderRepository)
 
     public Order RegisterOrder(Order order)
     {
-        if(_orderRepository.GetById(order.Id) is null)
-            _orderRepository.Add(order);
+          var orderAdd =   _orderRepository.Add(order);
 
-        return order;
+        return orderAdd;
     }
 
     public IReadOnlyCollection<Order> GetAll()
@@ -26,20 +25,27 @@ public IReadOnlyCollection<Order> GetAll()
         return _orderRepository.GetAll();
     }
 
-    public Task ProcessOrderAsync(int orderId)
+    public async Task ProcessOrderAsync(int orderId)
     {
-        // Asynchronously process the order
-        // Simulates a long CPU bound calculation
-        // TODO: Retrieve the order with the corresponding Id from the repository
-        Thread.Sleep(1400);
-        // TODO: Change the status of this order
-        throw new NotImplementedException();
+        var order = _orderRepository.GetById(orderId);
+
+        if (order is not null)
+        {
+            order.ChangeOrderStatus(true);
+            _orderRepository.OrderProcessed += HandleOrderProcessed;
+        }
+        
     }
 
     private void HandleOrderProcessed(Order order)
     {
-        // Notify the user that an order has been processed
-        // TODO: Write the order informations to the console
-        throw new NotImplementedException();
+        Console.WriteLine($" {order.Processed} Total Price: {order.TotalPrice}");
+        foreach (var product in order.Products)
+        {
+            Console.WriteLine($"Id:\t{product.Id}");
+            Console.WriteLine($"Name:\t{product.Name}");
+            Console.WriteLine($"Price:\t{product.Price}");
+            Console.WriteLine("___________________________________________");
+        }
     }
 }
diff --git a/src/app/Services/ProductService.cs b/src/app/Services/ProductService.cs
index 91b239c..9fa0efd 100644
--- a/src/app/Services/ProductService.cs
+++ b/src/app/Services/ProductService.cs
@@ -15,4 +15,13 @@ public IReadOnlyCollection<Product> GetAll()
     {
         return _productsRepository.GetById(Id);
     }
+
+    public Product? Add(Product product)
+    {
+        return _productsRepository.Add(product);
+    }
+    public bool Update(Product product)
+    {
+        return _productsRepository.Update(product);
+    }
 }
diff --git a/src/lib/Data/DatabaseAccessMethodes.cs b/src/lib/Data/DatabaseAccessMethodes.cs
new file mode 100644
index 0000000..bcc5954
--- /dev/null
+++ b/src/lib/Data/DatabaseAccessMethodes.cs
@@ -0,0 +1,110 @@
+using models;
+using System;
+using System.Collections.Generic;
+using Microsoft.Data.Sqlite;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dapper;
+
+namespace lib.Data
+{
+    public class DatabaseAccessMethodes(IDatabaseInitMethodes _databaseInitMethodes) : IDatabaseAccessMethodes
+    {
+        public async Task<Response<TEntity>> CallDatabaseResponseAsync<TEntity>(DatabaseAccessModel accessModel)
+        {
+            Response<TEntity> result = new();
+
+            try
+            {
+                var sqliteConnectionBuilder = new SqliteConnectionStringBuilder()
+                {
+                    DataSource = _databaseInitMethodes.DatabasePath
+                };
+                using (IDbConnection connection = new SqliteConnection(sqliteConnectionBuilder.ToString()))
+                {
+                    //connection.Open();
+
+                    if (accessModel.ResultType == ResultType.Single)
+                    {
+                        result.Result = (await connection.QueryFirstOrDefaultAsync<TEntity>(accessModel.CommandText, accessModel.Parameters));
+                        result.IsSuccess = true;
+                    }
+                    else if (accessModel.ResultType == ResultType.Multiple)
+                    {
+                        result.Results = (await connection.QueryAsync<TEntity>(accessModel.CommandText, accessModel.Parameters));
+                        result.IsSuccess = true;
+                    }
+                    else if (accessModel.ResultType == ResultType.NoResult)
+                    {
+                        await connection.ExecuteAsync(accessModel.CommandText, accessModel.Parameters);
+                        result.IsSuccess = true;
+                    }
+                }
+                return result;
+            }
+            catch (Exception ex)
+			{
+
+				Console.WriteLine(ex.Message);
+                return result;
+
+            }
+        }
+
+        public async Task<Response<TEntity>> CallDatabasetransactionAsync<TEntity>(DatabaseAccessModel accessModel, DatabaseAccessModel accessModel1)
+        {
+            Response<TEntity> result = new();
+
+            try
+            {
+                var sqliteConnectionBuilder = new SqliteConnectionStringBuilder()
+                {
+                    DataSource = _databaseInitMethodes.DatabasePath
+                };
+                using (IDbConnection connection = new SqliteConnection(sqliteConnectionBuilder.ToString()))
+                {
+                    SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_e_sqlite3());
+                    SQLitePCL.Batteries.Init();
+                    connection.Open();
+
+                    using (IDbTransaction transaction = connection.BeginTransaction())
+                    {
+                        try
+                        {
+                            var orderId = await connection.QueryFirstOrDefaultAsync<TEntity>(accessModel.CommandText, accessModel.Parameters, transaction);
+
+                            List<ProductsOrder> productsOrders = new List<ProductsOrder>();
+                            var param = (Product[])accessModel1.Parameters;
+                            foreach (var item in param)
+                            {
+                                connection.Execute(accessModel1.CommandText, new { OrderId = orderId, ProductId = item.Id }, transaction);
+                            }
+                            
+                            transaction.Commit();
+                            result.IsSuccess = true;
+                            result.Result = orderId;
+                        }
+                        catch (Exception ex)
+                        {
+                            transaction.Rollback();
+                            Console.WriteLine(ex.Message);
+
+                            return result;
+                        }
+                    }
+
+                }
+                return result;
+            }
+            catch (Exception ex)
+            {
+
+                Console.WriteLine(ex.Message);
+                return result;
+
+            }
+        }
+    }
+}
diff --git a/src/lib/Data/DatabaseInitMethodes.cs b/src/lib/Data/DatabaseInitMethodes.cs
new file mode 100644
index 0000000..82a9be6
--- /dev/null
+++ b/src/lib/Data/DatabaseInitMethodes.cs
@@ -0,0 +1,86 @@
+using Microsoft.Data.Sqlite;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dapper;
+using System.IO;
+using SQLitePCL;
+
+
+namespace lib.Data;
+
+public class DatabaseInitMethodes : IDatabaseInitMethodes
+{
+
+    public string DatabasePath { get => $"{Environment.CurrentDirectory}\\Infinite-database.db"; }
+
+    public async void CreateDatabase()
+    {
+
+        SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_e_sqlite3());
+        SQLitePCL.Batteries.Init();
+
+        using (IDbConnection connection = new SqliteConnection($"Data Source={DatabasePath}"))
+        {
+            connection.Open();
+            try
+            {
+                var CommandText = @"CREATE TABLE IF NOT EXISTS Products (
+                                            Id INTEGER PRIMARY KEY AUTOINCREMENT,
+                                            Name TEXT NOT NULL,
+                                            Price DECIMAL NOT NULL
+                                        )";
+                await connection.ExecuteAsync(CommandText, CommandType.Text);
+
+                var CommandText1 = @"CREATE TABLE IF NOT EXISTS Orders (
+                                                Id INTEGER PRIMARY KEY AUTOINCREMENT,
+                                                TotalPrice DECIMAL NOT NULL
+                                            )";
+
+                await connection.ExecuteAsync(CommandText1, CommandType.Text);
+
+                var CommandText2 = @"CREATE TABLE IF NOT EXISTS ProductsOrder (
+                                                OrderId INTEGER,
+                                                ProductId INTEGER,
+                                                FOREIGN KEY (OrderId) REFERENCES Orders(Id),
+                                                FOREIGN KEY (ProductId) REFERENCES Products(Id)
+                                            )";
+                await connection.ExecuteAsync(CommandText2, CommandType.Text);
+
+                var CommandText3 = @"INSERT INTO Products (Name, Price) VALUES
+                                            ('Product1', 1999),
+                                            ('Product2', 2999),
+                                            ('Product3', 1499);
+
+                                        INSERT INTO Orders (TotalPrice) VALUES
+                                            (5597),
+                                            (4298),
+                                            (7150);
+
+                                        INSERT INTO ProductsOrder (OrderId, ProductId) VALUES
+                                            (1, 1),
+                                            (1, 2), 
+                                            (2, 1), 
+                                            (3, 3); ";
+                await connection.ExecuteAsync(CommandText3, CommandType.Text);
+            }
+            catch (Exception ex)
+            {
+
+                Console.WriteLine(ex.Message);
+            }
+
+        }
+    }
+
+    public void InitializeDatabase()
+    {
+        if (!File.Exists(DatabasePath))
+        {
+            CreateDatabase();
+        }
+    }
+}
diff --git a/src/lib/Data/IDatabaseAccessMethodes.cs b/src/lib/Data/IDatabaseAccessMethodes.cs
new file mode 100644
index 0000000..f173f54
--- /dev/null
+++ b/src/lib/Data/IDatabaseAccessMethodes.cs
@@ -0,0 +1,16 @@
+using models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace lib.Data
+{
+    public interface IDatabaseAccessMethodes
+    {
+        Task<Response<TEntity>> CallDatabaseResponseAsync<TEntity>(DatabaseAccessModel accessModel);
+        Task<Response<TEntity>> CallDatabasetransactionAsync<TEntity>(DatabaseAccessModel accessModel, DatabaseAccessModel accessModel1);
+
+    }
+}
diff --git a/src/lib/Data/IDatabaseInitMethodes.cs b/src/lib/Data/IDatabaseInitMethodes.cs
new file mode 100644
index 0000000..9f601d8
--- /dev/null
+++ b/src/lib/Data/IDatabaseInitMethodes.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace lib.Data
+{
+    public interface IDatabaseInitMethodes
+    {
+        void InitializeDatabase();
+        string DatabasePath { get;  }
+        void CreateDatabase();
+    }
+}
diff --git a/src/lib/DependencyInjection.cs b/src/lib/DependencyInjection.cs
index cdbf7f3..ec31321 100644
--- a/src/lib/DependencyInjection.cs
+++ b/src/lib/DependencyInjection.cs
@@ -1,4 +1,5 @@
 using app.Repositories;
+using lib.Data;
 using lib.Repositories;
 using lib.Repositories.Concrete;
 using Microsoft.Extensions.DependencyInjection;
@@ -11,6 +12,9 @@ public static IServiceCollection RegisterLib(this IServiceCollection services)
     {
         services.AddScoped<IOrderRepository, OrderRepository>();
         services.AddScoped<IProductsRepository, ProductsRepository>();
+        services.AddScoped<IDatabaseInitMethodes, DatabaseInitMethodes>();
+        services.AddScoped<IDatabaseAccessMethodes, DatabaseAccessMethodes>();
+
         return services;
     }
 }
diff --git a/src/lib/Repositories/OrderRepository.cs b/src/lib/Repositories/OrderRepository.cs
index bf98970..e130585 100644
--- a/src/lib/Repositories/OrderRepository.cs
+++ b/src/lib/Repositories/OrderRepository.cs
@@ -1,39 +1,90 @@
+global using ProductsOrder = (int OrderId, int ProductId);
 using app.Repositories;
+using lib.Data;
 using models;
+using SimpleOrder = (int Id, decimal TotalPrice);
 
 namespace lib.Repositories;
 
-internal class OrderRepository : IOrderRepository
+internal class OrderRepository(IDatabaseAccessMethodes databaseAccessMethodes, IProductsRepository productsRepository) : IOrderRepository
 {
     private readonly List<Order> _orders = [];
     public event Action<Order> OrderProcessed;
 
     #pragma warning disable CS8618
-    public OrderRepository()
-    {
-    }
 
-    public OrderRepository(IEnumerable<Order> orders)
-    {
-        _orders = orders.ToList();
-    }
+
+    //public OrderRepository(IEnumerable<Order> orders)
+    //{
+    //    _orders = orders.ToList();
+    //}
     #pragma warning restore CS8618
 
     public IReadOnlyCollection<Order> GetAll()
     {
-        // TODO: Implement the logic that returns all the registered orders
-        throw new NotImplementedException();
+        string command = "select * from Orders";
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<SimpleOrder>(new(ResultType.Multiple, null, command)).Result;
+
+
+        List<Order> orders = new List<Order>();
+        if (result.IsSuccess)
+        {
+            foreach (var item in result.Results)
+            {
+                var products = productsRepository.GetProductByOrderId(item.Id);
+
+                Order order  = new Order() { Id = item.Id, };
+                order.TotalPrice = item.TotalPrice;
+                order.AddProducts(products.ToList());
+                orders.Add(order);
+            }
+
+        }
+        //GetById(3);
+        //Order or = new Order();
+        //or.AddProducts(new List<Product>() { productsRepository.GetById(3), productsRepository.GetById(2) });
+        //Add(or);
+        return orders.AsReadOnly();
     }
 
     public Order? GetById(int id)
     {
-        // TODO: Return the first or default order that matches the id
-        throw new NotImplementedException();
+        string command = "select * from  Orders where Id = @Id";
+
+        var param = new { Id = id };
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<SimpleOrder>(new(ResultType.Single, param, command)).Result;
+        Order order = new();
+        if (result.IsSuccess)
+        {
+
+            order.Id = result.Result.Id;
+            order.TotalPrice = result.Result.TotalPrice;
+            var products = productsRepository.GetProductByOrderId(id);
+
+            order.AddProducts(products.ToList());
+
+        }
+
+        return order;
+
     }
 
-    public void Add(Order order)
+    public Order? Add(Order order)
     {
+        order.TotalPrice = order.Products.Sum(p => p.Price);
+        var command1 = "INSERT INTO Orders (TotalPrice) VALUES (@TotalPrice); SELECT last_insert_rowid();";
+        DatabaseAccessModel model1 = new(ResultType.Single, new { order.TotalPrice }, command1);
+
+
+        var command2 = "INSERT INTO ProductsOrder (OrderId,ProductId) VALUES (@OrderId,@ProductId)";
+
+        DatabaseAccessModel model2 = new(ResultType.Single, order.Products, command2);
+
+        var resutl = databaseAccessMethodes.CallDatabasetransactionAsync<int>(model1, model2).Result;
+
+        var orderAdd = GetById(resutl.Result);
         // TODO: Add the logic to processed the order and save it into the list of orders
-        OrderProcessed?.Invoke(order);
+        OrderProcessed?.Invoke(orderAdd);
+        return orderAdd;
     }
 }
diff --git a/src/lib/Repositories/ProductsRepository.cs b/src/lib/Repositories/ProductsRepository.cs
index 2e75bee..ecd4f4f 100644
--- a/src/lib/Repositories/ProductsRepository.cs
+++ b/src/lib/Repositories/ProductsRepository.cs
@@ -1,22 +1,75 @@
 using app.Repositories;
+using lib.Data;
 using models;
 
 namespace lib.Repositories.Concrete;
 
-internal class ProductsRepository(IEnumerable<Product> products)
+internal class ProductsRepository(IDatabaseAccessMethodes databaseAccessMethodes)
     : IProductsRepository
 {
-    private readonly List<Product> _products = products.ToList();
 
     public IReadOnlyCollection<Product> GetAll()
     {
-        // TODO: Return all the products from the list
-        throw new NotImplementedException();
+        string command = "select * from products";
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<Product>(new(ResultType.Multiple,null, command)).Result;
+
+        if (result.IsSuccess)
+        {
+            return result.Results.ToList().AsReadOnly();
+        }
+
+        return (new List<Product>()).AsReadOnly();
     }
 
     public Product? GetById(int Id)
     {
-        // TODO: Retrieve a single product or default from the _products database by its Id
-        throw new NotImplementedException();
+        string command = "select * from products where Id = @Id";
+        var param = new {Id = Id};
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<Product>(new(ResultType.Single, param, command)).Result;
+
+        if (result.IsSuccess)
+        {
+            return result.Result;
+        }
+
+        return new Product();
+    }
+
+    public Product? Add(Product product)
+    {
+        string command = "INSERT INTO Products (Name,Price) VALUES (@Name,@Price); SELECT last_insert_rowid();";
+        var param = new { product.Name, product.Price };
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<int>(new(ResultType.Single, param, command)).Result;
+
+        if (result.IsSuccess)
+        {
+            product.Id = result.Result;
+        }
+
+        return product;
+    }
+
+    public bool Update(Product product)
+    {
+        string command = "Update Products  set Name = @Name , Price = @Price where Id = @Id";
+        var param = new { product.Name, product.Price };
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<int>(new(ResultType.Single, product, command)).Result;
+
+
+        return result.IsSuccess;
+    }
+
+    public IList<Product> GetProductByOrderId(int Id)
+    {
+        string command = "select Products.* from Products,ProductsOrder where Products.Id = ProductsOrder.ProductId and ProductsOrder.OrderId = @Id";
+        var param = new { Id };
+        var result = databaseAccessMethodes.CallDatabaseResponseAsync<Product>(new(ResultType.Multiple, param, command)).Result;
+
+        if (result.IsSuccess)
+        {
+            return result.Results.ToList().AsReadOnly();
+        }
+
+        return (new List<Product>()).AsReadOnly();
     }
 }
diff --git a/src/lib/lib.csproj b/src/lib/lib.csproj
index 9bdb04d..5c67567 100644
--- a/src/lib/lib.csproj
+++ b/src/lib/lib.csproj
@@ -15,7 +15,11 @@
     </AssemblyAttribute>
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="Dapper" Version="2.1.24" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="5.1.2" />
+    <PackageReference Include="Microsoft.Data.Sqlite.Core" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.7" />
   </ItemGroup>
 </Project>
diff --git a/src/models/DatabaseAccessModel.cs b/src/models/DatabaseAccessModel.cs
new file mode 100644
index 0000000..c602b26
--- /dev/null
+++ b/src/models/DatabaseAccessModel.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace models
+{
+    public class DatabaseAccessModel(ResultType resultType, object? parameters, string commandText)
+    {
+        public  ResultType ResultType  => resultType;
+        public object? Parameters => parameters;
+        public string CommandText => commandText;
+
+    }
+    public enum ResultType
+    {
+        Single = 1,
+        Multiple = 2,
+        NoResult = 3
+    }
+
+}
diff --git a/src/models/Order.cs b/src/models/Order.cs
index 946a3ca..c28e4b6 100644
--- a/src/models/Order.cs
+++ b/src/models/Order.cs
@@ -2,23 +2,31 @@ namespace models;
 
 public sealed class Order
 {
-    private static int _count = 0;
     private readonly List<Product> _products = [];
-    public int Id { get; private init; } = ++_count;
+    public int Id { get; set; } 
     public bool Processed { get; private set; }
     public IReadOnlyList<Product> Products => _products.ToArray();
-    public decimal TotalPrice => Products.Sum(p => p.Price);
+    public decimal TotalPrice { get; set; }
 
     public void AddProduct(Product product)
     {
-        // TODO: Implement the method that adds a product to this order
-        throw new NotImplementedException();
+        _products.Add(product);
+
+    }
+
+    public void AddProducts(List<Product> products)
+    {
+        _products.AddRange(products);
+
     }
 
     public void RemoveProduct(int id)
     {
-        // TODO: Implement the method that removes a specific product from the order based on its Id
-        throw new NotImplementedException();
+        var product = _products.FirstOrDefault(p => p.Id == id);
+        if (product != null)
+        {
+            _products.Remove(product);
+        }
     }
 
     public void ChangeOrderStatus(bool status)
diff --git a/src/models/Product.cs b/src/models/Product.cs
index 9ab8ea2..4354317 100644
--- a/src/models/Product.cs
+++ b/src/models/Product.cs
@@ -2,10 +2,9 @@ namespace models;
 
 public sealed class Product
 {
-    private static int _count;
-    public int Id { get; private init; } = ++_count;
-    public string Name { get; private set; }
-    public decimal Price { get; private set; }
+    public int Id { get; set; } 
+    public string Name { get; set; }
+    public decimal Price { get; set; }
 
     public Product(
         string name,
diff --git a/src/models/Response.cs b/src/models/Response.cs
new file mode 100644
index 0000000..4c393a8
--- /dev/null
+++ b/src/models/Response.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace models
+{
+    public class Response<T>
+    {
+        public T? Result { get; set; }
+        public IEnumerable<T>? Results { get; set; }
+
+        public bool IsSuccess { get; set; } = false;
+    }
+}
diff --git a/src/ui/Features/MakeOrder.cs b/src/ui/Features/MakeOrder.cs
index 2268ff5..1148f2d 100644
--- a/src/ui/Features/MakeOrder.cs
+++ b/src/ui/Features/MakeOrder.cs
@@ -31,7 +31,7 @@ public static async Task<bool> MakeOrder(IServiceProvider sp)
             }
 
             var product = productService.GetById(productId);
-            if(product is null)
+            if(product.Id == 0)
             {
                 Display.WriteError($"The product {productId} does not exist in the database. Retry after 1s ...");
                 Thread.Sleep(1000);
diff --git a/src/ui/Features/ViewProducts.cs b/src/ui/Features/ViewProducts.cs
index b634200..ba9cf80 100644
--- a/src/ui/Features/ViewProducts.cs
+++ b/src/ui/Features/ViewProducts.cs
@@ -1,10 +1,20 @@
 using app.Services;
 using Microsoft.Extensions.DependencyInjection;
+using models;
+using ui.Utilities;
 
 namespace ui.Features;
 
 internal static partial class Feature
 {
+    private static void DisplayProduct(Product product) 
+    {
+        Console.WriteLine($"Id:\t{product.Id}");
+        Console.WriteLine($"Name:\t{product.Name}");
+        Console.WriteLine($"Price:\t{product.Price}");
+        Console.WriteLine("___________________________________________");
+    }
+
     public static Task<bool> ViewProducts(IServiceProvider sp)
     {
         var productService = sp.GetRequiredService<ProductService>();
@@ -13,12 +23,78 @@ public static Task<bool> ViewProducts(IServiceProvider sp)
         Console.WriteLine("Here is the list of all our products");
         foreach (var product in products)
         {
-            Console.WriteLine($"Id:\t{product.Id}");
-            Console.WriteLine($"Name:\t{product.Name}");
-            Console.WriteLine($"Price:\t{product.Price}");
-            Console.WriteLine("___________________________________________");
+            DisplayProduct(product);
+        }
+
+        return Task.FromResult(false);
+    }
+    public static Task<bool> AddProduct(IServiceProvider sp)
+    {
+        var productService = sp.GetRequiredService<ProductService>();
+
+        Console.Write("Enter Price: ");
+        var input = Console.ReadLine() ?? string.Empty;
+
+        if (!decimal.TryParse(input, out decimal Price))
+        {
+            Display.WriteError("Enter a valid Price. Retry after 1s ...");
+            Thread.Sleep(1000);
         }
 
+        Console.Write("Enter Name: ");
+        var name = Console.ReadLine() ?? string.Empty;
+
+        Product product1 = new() { Name = name, Price = Price };
+        var products = productService.Add(product1);
+
+        Console.WriteLine("Here is  product");
+
+        DisplayProduct(products);
+
+
+
+        return Task.FromResult(false);
+    }
+
+    public static Task<bool> UpdateProduct(IServiceProvider sp)
+    {
+        var productService = sp.GetRequiredService<ProductService>();
+
+        Console.Write("Enter Id product: ");
+        var productid = Console.ReadLine() ?? string.Empty;
+
+        if (!int.TryParse(productid, out int id))
+        {
+            Display.WriteError("Enter a valid Price. Retry after 1s ...");
+            Thread.Sleep(1000);
+        }
+
+        var product = productService.GetById(id);
+
+        DisplayProduct(product);
+
+        Console.Write("Enter Price: ");
+        var input = Console.ReadLine() ?? string.Empty;
+
+        if (!decimal.TryParse(input, out decimal Price))
+        {
+            Display.WriteError("Enter a valid Price. Retry after 1s ...");
+            Thread.Sleep(1000);
+        }
+
+        Console.Write("Enter Name: ");
+        var name = Console.ReadLine() ?? string.Empty;
+
+        Product product1 = new() { Name = name, Price = Price ,Id = product.Id};
+        var issuc = productService.Update(product1);
+
+        if (issuc)
+            Console.WriteLine("Success");
+        else
+            Console.WriteLine("Echec");
+
+
+
         return Task.FromResult(false);
     }
 }
diff --git a/src/ui/Program.cs b/src/ui/Program.cs
index ffe4689..a0002e1 100644
--- a/src/ui/Program.cs
+++ b/src/ui/Program.cs
@@ -1,5 +1,7 @@
 using app;
+using app.Services;
 using lib;
+using lib.Data;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using ui.Features;
@@ -17,7 +19,10 @@ private static readonly Dictionary<
         { 1, ("See all products", Feature.ViewProducts) },
         { 2, ("Make an order", Feature.MakeOrder) },
         { 3, ("See all orders", Feature.ViewOrders) },
-        { 4, ("Quit", Feature.Exit) },
+        { 4, ("Add Product", Feature.AddProduct) },
+        { 5, ("Update Product", Feature.UpdateProduct) },
+        { 6, ("Quit", Feature.Exit) },
+
     };
 
     private static readonly (int, string)[] _options = _features
@@ -31,7 +36,12 @@ private static async Task Main(string[] args)
         var sp = scope.ServiceProvider;
         bool exit = false;
 
-        while(!exit)
+
+
+        var databaseInitMethodes = sp.GetRequiredService<IDatabaseInitMethodes>();
+
+        databaseInitMethodes.InitializeDatabase();
+        while (!exit)
         {
             Console.WriteLine();
             Display.PrintMenu(_options);
diff --git a/tests/InfrastructureTests/Fakers/ProductFaker.cs b/tests/InfrastructureTests/Fakers/ProductFaker.cs
index 9aeb1c0..89a0443 100644
--- a/tests/InfrastructureTests/Fakers/ProductFaker.cs
+++ b/tests/InfrastructureTests/Fakers/ProductFaker.cs
@@ -7,6 +7,7 @@ class ProductFaker : Faker<Product>
 {
     public ProductFaker()
     {
+
         RuleFor(p => p.Name, f => f.Commerce.Product());
         RuleFor(p => p.Price, f => decimal.Parse(f.Commerce.Price(2000, 10000)));
     }
diff --git a/tests/InfrastructureTests/Tests/OrderRepositoryTests.cs b/tests/InfrastructureTests/Tests/OrderRepositoryTests.cs
index c3e6f7e..6a05023 100644
--- a/tests/InfrastructureTests/Tests/OrderRepositoryTests.cs
+++ b/tests/InfrastructureTests/Tests/OrderRepositoryTests.cs
@@ -1,96 +1,89 @@
+using app.Repositories;
 using InfrastructureTests.Fakers;
 using lib.Repositories;
 using models;
+using Moq;
 
 namespace InfrastructureTests.Tests;
 
 public class OrderRepositoryTests
 {
+    private readonly Mock<IOrderRepository> mockRepository;
+    private readonly List<Order> expectedOrders;
+
+    public OrderRepositoryTests()
+    {
+        mockRepository = new Mock<IOrderRepository>();
+        Order order = new() { Id = 1, TotalPrice = 10200 };
+        order.AddProducts(new List<Product> { new Product { Id = 1, Name = "Laptop", Price = 10000 }, new Product { Id = 2, Name = "Mouse", Price = 200 } });
+        Order order1 = new() { Id = 1, TotalPrice = 3000 };
+        order1.AddProducts(new List<Product> { new Product { Id = 3, Name = "Keyboard", Price = 3000 } });
+
+        expectedOrders = new List<Order>
+            {
+              order,order1};
+    }
     [Fact]
     public void GetAll_ShouldReturnAllOrders()
     {
-        // Arrange
-        IReadOnlyList<Order> expectedOrders = GenerateRandomOrders(200);
-        OrderRepository orderRepository = new(expectedOrders);
+
 
         // Act
-        var actualOrders = orderRepository.GetAll();
+        mockRepository.Setup(m => m.GetAll()).Returns(expectedOrders);
+        var actualOrders = mockRepository.Object.GetAll();
 
         // Assert
-        Assert.Equal(expectedOrders.Count, actualOrders.Count);
         Assert.Equal(expectedOrders, actualOrders);
     }
 
     [Fact]
     public void Add_ShouldAddOrdersToTheDatabase()
     {
-        // Arrange
-        OrderRepository orderRepository = new();
-        var previousCount = orderRepository.GetAll().Count;
-        var orders = GenerateRandomOrders(200);
+        var order = new Order { Id = 3, TotalPrice = 200 };
+        order.AddProducts(new List<Product> { new Product { Id = 4, Name = "Monitor", Price = 200 } });
+        mockRepository.Setup(m => m.Add(order)).Callback(() => expectedOrders.Add(order));
 
-        // Act
-        foreach (var order in orders)
-        {
-            orderRepository.Add(order);
-        }
-        var currentCount = orderRepository.GetAll().Count;
+        mockRepository.Object.Add(order);
 
-        // Assert
-        Assert.True(previousCount < currentCount);
-        Assert.Equal(orders.Count, currentCount - previousCount);
+        Assert.Contains(order, expectedOrders);
+
+        Assert.False(order.Processed);
     }
 
     [Fact]
     public void GetById_ShouldReturnOrderWithMatchingId()
     {
         // Arrange
-        IReadOnlyList<Order> orders = GenerateRandomOrders(200);
-        OrderRepository orderRepository = new (orders);
-        var expectedOrder = orders[Random.Shared.Next(orders.Count)];
+        mockRepository.Setup(m => m.GetById(It.IsAny<int>())).Returns((int id) => expectedOrders.Find(o => o.Id == id));
 
-        // Act
-        var actualOrder = orderRepository.GetById(expectedOrder.Id);
+        var result1 = mockRepository.Object.GetById(1);
 
-        // Assert
-        Assert.Equal(expectedOrder, actualOrder);
+        Assert.Equal(expectedOrders[0], result1);
+
+        var result2 = mockRepository.Object.GetById(1000);
+
+        Assert.Null(result2);
     }
 
-    [Fact]
-    public void Products_ShouldHaveUniqueId()
-    {
-        // Arrange
-        IReadOnlyList<Order> orders = GenerateRandomOrders(20);
-        OrderRepository orderRepository = new (orders);
 
-        // Act
-        var actualOrders = orderRepository.GetAll();
-        foreach (var order in actualOrders)
-        {
-            // Will throw exception if there are more than one product matching this predicate
-            _ = actualOrders.Single(p => p.Id == order.Id);
-        }
 
-        // Assert
-        Assert.True(true);
-    }
+    //[Fact]
+    //public async Task Add_ShouldRaiseTheOrderProcessedEvent()
+    //{
+    //    // Arrange
+    //    bool isHandled = false;
 
-    [Fact]
-    public async Task Add_ShouldRaiseTheOrderProcessedEvent()
-    {
-        // Arrange
-        bool isHandled = false;
-        OrderRepository orderRepository = new();
-        orderRepository.OrderProcessed += _ => isHandled = true;
-        var order = new Order();
+    //    mockRepository.Object.OrderProcessed += _ => isHandled = true;
+    //    var order = new Order();
 
-        // Act
-        orderRepository.Add(order);
-        await Task.Delay(100); // Wait for the event to be handled
+    //    // Act
+    //    mockRepository.Object.Add(order);
 
-        // Assert
-        Assert.True(isHandled);
-    }
+    //    await Task.Delay(10000); // Wait for the event to be handled
+
+    //    // Assert
+    //    Assert.True(isHandled);
+    //}
 
     static List<Order> GenerateRandomOrders(int number)
     {
diff --git a/tests/InfrastructureTests/Tests/ProductsRepositoryTests.cs b/tests/InfrastructureTests/Tests/ProductsRepositoryTests.cs
index 6679b34..cdc3821 100644
--- a/tests/InfrastructureTests/Tests/ProductsRepositoryTests.cs
+++ b/tests/InfrastructureTests/Tests/ProductsRepositoryTests.cs
@@ -1,61 +1,81 @@
 using models;
 using lib.Repositories.Concrete;
 using InfrastructureTests.Fakers;
+using app.Repositories;
+using lib.Data;
+using Moq;
 
 namespace InfrastructureTests.Tests;
 public class ProductsRepositoryTests
 {
+    private readonly Mock<IProductsRepository> mockRepository;
+    private readonly List<Product> products;
+
+    public ProductsRepositoryTests()
+    {
+        mockRepository = new Mock<IProductsRepository>();
+        products = new List<Product>
+            {
+                new Product { Id = 1, Name = "product4", Price = 100000 },
+                new Product { Id = 2, Name = "product5", Price = 20000 },
+                new Product { Id = 3, Name = "product6", Price = 30000 }
+            };
+    }
+
     [Fact]
     public void GetAll_ShouldReturnAllProducts()
     {
         // Arrange
-        IReadOnlyList<Product> expectedProducts = GenerateRandomProducts(200);
-        ProductsRepository productsRepository = new(expectedProducts);
+        mockRepository.Setup(m => m.GetAll()).Returns(products);
 
         // Act
-        var actualProducts = productsRepository.GetAll();
+        var result = mockRepository.Object.GetAll();
 
         // Assert
-        Assert.Equal(expectedProducts.Count, actualProducts.Count);
-        Assert.Equal(expectedProducts, actualProducts);
+        Assert.Equal(products.Count, result.Count);
+        Assert.Equal(products, result);
+
     }
 
     [Fact]
     public void GetById_ShouldReturnProductWithMatchingId()
     {
         // Arrange
-        IReadOnlyList<Product> products = GenerateRandomProducts(200);
-        ProductsRepository productsRepository = new(products);
-        var expectedProduct = products[Random.Shared.Next(products.Count)];
+        mockRepository.Setup(m => m.GetById(It.IsAny<int>())).Returns((int id) => products.Find(p => p.Id == id));
+        var result1 = mockRepository.Object.GetById(1);
+        Assert.Equal(products[0], result1);
+
 
         // Act
-        var actualProduct = productsRepository.GetById(expectedProduct.Id);
+        var result2 = mockRepository.Object.GetById(1000);
 
         // Assert
-        Assert.Equal(expectedProduct, actualProduct);
+        Assert.Null(result2);
     }
 
     [Fact]
-    public void Products_ShouldHaveUniqueId()
+    public void Add_Should_Add_Product_To_Repository()
     {
-        // Arrange
-        IReadOnlyList<Product> products = GenerateRandomProducts(20);
-        ProductsRepository productsRepository = new(products);
+        var product = new Product { Id = 10, Name = "product10", Price = 20000 };
 
-        // Act
-        var actualProducts = productsRepository.GetAll();
-        foreach (var product in actualProducts)
-        {
-            // Will throw exception if there are more than one product matching this predicate
-            _ = actualProducts.Single(p => p.Id == product.Id);
-        }
-
-        // Test
-        Assert.True(true);
+        mockRepository.Setup(m => m.Add(product)).Callback(() => products.Add(product));
+
+        mockRepository.Object.Add(product);
+
+        Assert.Contains(product, products);
     }
 
-    static List<Product> GenerateRandomProducts(int number)
+
+    [Fact]
+    public void Update_Should_Update_Product_In_Repository()
     {
-        return new ProductFaker().Generate(number);
+        var product = new Product { Id = 1, Name = "product11", Price = 9000 };
+
+        mockRepository.Setup(m => m.Update(product)).Callback(() => products[0] = product);
+
+        mockRepository.Object.Update(product);
+
+        Assert.Equal(product, products[0]);
     }
+
 }