Added GetAllByPortfolioId method to IPortfolioEntryRepository interface

topnax · topnax · commit ae77bc12c845 · 2021-04-28T14:15:17.000+02:00
Implemented GetAllByPortfolioId method in SqlKataPortfolioEntryRepository and covered it with a simple test
Implemented PortfolioEntryService (not tested yet)
diff --git a/Database/SqlSchema.cs b/Database/SqlSchema.cs
@@ -4,6 +4,7 @@ namespace Database
 {
     public class SqlSchema
     {
+        // TODO column names into constants
         public static void Init(SqlKataDatabase db)
         {
             db.Get().Statement(@"
diff --git a/Repository/IRepository.cs b/Repository/IRepository.cs
@@ -26,4 +26,9 @@ public interface IMarketOrderRepository : IRepository<MarketOrder>
     public interface IPortfolioRepository : IRepository<Portfolio>
     {
     }
+    
+    public interface IPortfolioEntryRepository : IRepository<PortfolioEntry>
+    {
+        public List<PortfolioEntry> GetAllByPortfolioId(int portfolioId);
+    }
 }
diff --git a/Repository/SqlKataPortfolioEntryRepository.cs b/Repository/SqlKataPortfolioEntryRepository.cs
@@ -1,9 +1,11 @@
+using System.Collections.Generic;
 using Database;
 using Model;
+using SqlKata.Execution;
 
 namespace Repository
 {
-    public class SqlKataPortfolioEntryRepository : SqlKataRepository<PortfolioEntry>
+    public class SqlKataPortfolioEntryRepository : SqlKataRepository<PortfolioEntry>, IPortfolioEntryRepository
     {
         public SqlKataPortfolioEntryRepository(SqlKataDatabase db) : base(db, "portfolio_entries")
         {
@@ -16,7 +18,10 @@ public SqlKataPortfolioEntryRepository(SqlKataDatabase db) : base(db, "portfolio
             symbol = entry.Symbol,
             portfolio_id = entry.PortfolioId
         };
-        
+
         public override PortfolioEntry FromRow(dynamic d) => new((string) d.symbol, (int) d.portfolio_id, (int) d.id);
+
+        public List<PortfolioEntry> GetAllByPortfolioId(int portfolioId) =>
+            RowsToObjects(Db.Get().Query(tableName).Where("portfolio_id", portfolioId).Get());
     }
 }
diff --git a/Repository/SqlKataRepository.cs b/Repository/SqlKataRepository.cs
@@ -10,12 +10,12 @@ namespace Repository
     public abstract class SqlKataRepository<T> : IRepository<T>
     {
         protected readonly SqlKataDatabase Db;
-        private readonly string _tableName;
+        protected readonly string tableName;
 
         public SqlKataRepository(SqlKataDatabase db, string tableName)
         {
             this.Db = db;
-            this._tableName = tableName;
+            this.tableName = tableName;
         }
 
         public abstract object ToRow(T entry);
@@ -26,26 +26,26 @@ public SqlKataRepository(SqlKataDatabase db, string tableName)
 
         public int Add(T entry)
         {
-            var id = Db.Get().Query(_tableName).InsertGetId<int>(ToRow(entry));
+            var id = Db.Get().Query(tableName).InsertGetId<int>(ToRow(entry));
             return id;
         }
 
         public bool Update(T entry)
         {
-            var updated = Db.Get().Query(_tableName).Where("id", _getEntryId(entry)).Update(ToRow(entry));
+            var updated = Db.Get().Query(tableName).Where("id", _getEntryId(entry)).Update(ToRow(entry));
             return updated > 0;
         }
 
         public bool Delete(T entry)
         {
-            Db.Get().Query(_tableName).Where("id", _getEntryId(entry)).AsDelete();
+            Db.Get().Query(tableName).Where("id", _getEntryId(entry)).AsDelete();
             // TODO
             return true;
         }
 
         public T Get(int id)
         {
-            var result = Db.Get().Query(_tableName).Where("id", id).First();
+            var result = Db.Get().Query(tableName).Where("id", id).First();
             if (result == null)
             {
                 return default;
@@ -54,27 +54,12 @@ public T Get(int id)
             return FromRow(result);
         }
 
-        public List<T> GetAll()
-        {
-            var result = Db.Get().Query(_tableName).Get();
-            if (result == null)
-            {
-                return default;
-            }
-
-            var list = new List<T>();
-            foreach (var row in result)
-            {
-                list.Add(FromRow(row));
-            }
-
-            return list;
-        }
+        public List<T> GetAll() => RowsToObjects(Db.Get().Query(tableName).Select().Get());
 
-        public List<T> All()
+        protected List<T> RowsToObjects(IEnumerable<dynamic> rows)
         {
             List<T> items = new List<T>();
-            foreach (var row in Db.Get().Query(_tableName).Select().Get())
+            foreach (var row in rows)
             {
                 items.Add(FromRow(row));
             }
diff --git a/Services/Services/PortfolioEntryService.cs b/Services/Services/PortfolioEntryService.cs
@@ -0,0 +1,59 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Model;
+using Repository;
+
+namespace Services
+{
+    public interface IPortfolioEntryService
+    {
+        PortfolioEntry CreatePortfolioEntry(string symbol, int portfolioId);
+
+        bool DeletePortfolioEntry(PortfolioEntry entry);
+
+        bool UpdatePortfolio(PortfolioEntry entry);
+
+        PortfolioEntry GetPortfolioEntry(int id);
+
+        List<PortfolioEntry> GetPortfolioEntries(int portfolioId);
+    }
+
+    public class PortfolioEntryServiceImpl : IPortfolioEntryService
+    {
+        private IPortfolioEntryRepository _portfolioEntryRepository;
+
+        public PortfolioEntryServiceImpl(IPortfolioEntryRepository portfolioEntryRepository)
+        {
+            _portfolioEntryRepository = portfolioEntryRepository;
+        }
+
+
+        public PortfolioEntry CreatePortfolioEntry(string symbol, int portfolioId)
+        {
+            var portfolioEntry = new PortfolioEntry(symbol, portfolioId);
+            portfolioEntry = portfolioEntry with {Id = _portfolioEntryRepository.Add(portfolioEntry)};
+            return portfolioEntry;
+        }
+
+        public bool DeletePortfolioEntry(PortfolioEntry entry)
+        {
+            return _portfolioEntryRepository.Delete(entry);
+        }
+
+        public bool UpdatePortfolio(PortfolioEntry entry)
+        {
+            return _portfolioEntryRepository.Update(entry);
+        }
+
+        public PortfolioEntry GetPortfolioEntry(int id)
+        {
+            return _portfolioEntryRepository.Get(id);
+        }
+
+        public List<PortfolioEntry> GetPortfolioEntries(int portfolioId)
+        {
+            return _portfolioEntryRepository.GetAllByPortfolioId(portfolioId);
+        }
+    }
+}
diff --git a/Tests/Integration/Repository/MarketOrderTest.cs b/Tests/Integration/Repository/MarketOrderTest.cs
@@ -6,7 +6,6 @@
 using Repository;
 using SqlKata.Compilers;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace Tests.Integration.Repository
 {
@@ -39,8 +38,7 @@ public class MarketOrderRepositoryTest : IClassFixture<SqlKataMarketOrderReposit
         private SqlKataMarketOrderRepositoryFixture _marketOrderRepositoryFixture;
 
         // TODO test Delete method
-        public MarketOrderRepositoryTest(SqlKataMarketOrderRepositoryFixture marketOrderRepositoryFixture,
-            ITestOutputHelper testOutputHelper)
+        public MarketOrderRepositoryTest(SqlKataMarketOrderRepositoryFixture marketOrderRepositoryFixture)
         {
             this._marketOrderRepositoryFixture = marketOrderRepositoryFixture;
         }
@@ -86,26 +84,37 @@ public void Added_And_GetAll_AreEqual()
         {
             // fixture unique to this test
             var marketOrderRepositoryFixture = new SqlKataMarketOrderRepositoryFixture();
-            
+
             // arrange
             var marketOrder1 = new MarketOrder(new Decimal(10000.39), 10, new Decimal(1.1), DateTime.Now, true,
                 PortfolioEntryId: marketOrderRepositoryFixture.DefaultPortfolioEntryId);
-            var marketOrder2 = new MarketOrder(new Decimal(11000.39), 11, new Decimal(1.2), DateTime.Now.Subtract(TimeSpan.FromSeconds(3600)), true,
+            var marketOrder2 = new MarketOrder(new Decimal(11000.39), 11, new Decimal(1.2),
+                DateTime.Now.Subtract(TimeSpan.FromSeconds(3600)), true,
                 PortfolioEntryId: marketOrderRepositoryFixture.DefaultPortfolioEntryId);
-            var marketOrder3 = new MarketOrder(new Decimal(12000.39), 12, new Decimal(1.3), DateTime.Now.Subtract(TimeSpan.FromDays(30)), false,
+            var marketOrder3 = new MarketOrder(new Decimal(12000.39), 12, new Decimal(1.3),
+                DateTime.Now.Subtract(TimeSpan.FromDays(30)), false,
                 PortfolioEntryId: marketOrderRepositoryFixture.DefaultPortfolioEntryId);
 
             // act
-            marketOrder1 = marketOrder1 with {Id = marketOrderRepositoryFixture.MarketOrderRepository.Add(marketOrder1)};
-            marketOrder2 = marketOrder2 with {Id = marketOrderRepositoryFixture.MarketOrderRepository.Add(marketOrder2)};
-            marketOrder3 = marketOrder3 with {Id = marketOrderRepositoryFixture.MarketOrderRepository.Add(marketOrder3)};
-            
+            marketOrder1 = marketOrder1 with
+            {
+                Id = marketOrderRepositoryFixture.MarketOrderRepository.Add(marketOrder1)
+            };
+            marketOrder2 = marketOrder2 with
+            {
+                Id = marketOrderRepositoryFixture.MarketOrderRepository.Add(marketOrder2)
+            };
+            marketOrder3 = marketOrder3 with
+            {
+                Id = marketOrderRepositoryFixture.MarketOrderRepository.Add(marketOrder3)
+            };
+
             // assert
             var loadedPortfolios = marketOrderRepositoryFixture.MarketOrderRepository.GetAll();
             Assert.Equal(3, loadedPortfolios.Count);
-            Assert.Equal(new List<MarketOrder>{marketOrder1, marketOrder2, marketOrder3}, loadedPortfolios);
+            Assert.Equal(new List<MarketOrder> {marketOrder1, marketOrder2, marketOrder3}, loadedPortfolios);
         }
-        
+
         [Fact]
         public void AddUpdate_Updates()
         {
diff --git a/Tests/Integration/Repository/PortfolioEntryTest.cs b/Tests/Integration/Repository/PortfolioEntryTest.cs
@@ -15,6 +15,7 @@ public class SqlKataPortfolioEntryRepositoryFixture : IDisposable
         public SqlKataPortfolioEntryRepository PortfolioEntryRepository;
         private SqliteConnection _dbConnection;
         public int DefaultPortfolioId;
+        public int SecondaryPortfolioId;
 
         public SqlKataPortfolioEntryRepositoryFixture()
         {
@@ -24,6 +25,7 @@ public SqlKataPortfolioEntryRepositoryFixture()
             this.PortfolioRepository = new(db);
             this.PortfolioEntryRepository = new(db);
             DefaultPortfolioId = PortfolioRepository.Add(new("Foo", "Bar", Currency.Czk));
+            SecondaryPortfolioId = PortfolioRepository.Add(new("Bar", "Bar", Currency.Czk));
         }
 
         public void Dispose()
@@ -74,27 +76,86 @@ public void Added_And_Get_AreEqual()
             Assert.Equal(portfolioEntry,
                 _portfolioEntryRepositoryFixture.PortfolioEntryRepository.Get(portfolioEntry.Id));
         }
-        
+
         [Fact]
         public void Added_And_GetAll_AreEqual()
         {
             // fixture unique to this test
             var portfolioEntryRepositoryFixture = new SqlKataPortfolioEntryRepositoryFixture();
-            
+
             // arrange
             var portfolioEntry1 = new PortfolioEntry("btc", portfolioEntryRepositoryFixture.DefaultPortfolioId);
             var portfolioEntry2 = new PortfolioEntry("ada", portfolioEntryRepositoryFixture.DefaultPortfolioId);
             var portfolioEntry3 = new PortfolioEntry("ltc", portfolioEntryRepositoryFixture.DefaultPortfolioId);
 
             // act
-            portfolioEntry1 = portfolioEntry1 with {Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry1)};
-            portfolioEntry2 = portfolioEntry2 with {Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry2)};
-            portfolioEntry3 = portfolioEntry3 with {Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry3)};
-            
+            portfolioEntry1 = portfolioEntry1 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry1)
+            };
+            portfolioEntry2 = portfolioEntry2 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry2)
+            };
+            portfolioEntry3 = portfolioEntry3 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry3)
+            };
+
             // assert
             var loadedPortfolios = portfolioEntryRepositoryFixture.PortfolioEntryRepository.GetAll();
             Assert.Equal(3, loadedPortfolios.Count);
-            Assert.Equal(new List<PortfolioEntry>{portfolioEntry1, portfolioEntry2, portfolioEntry3}, loadedPortfolios);
+            Assert.Equal(new List<PortfolioEntry> {portfolioEntry1, portfolioEntry2, portfolioEntry3},
+                loadedPortfolios);
+        }
+
+        [Fact]
+        public void GetAllByPortfolioId_Returns_Correct_Entries()
+        {
+            // fixture unique to this test
+            var portfolioEntryRepositoryFixture = new SqlKataPortfolioEntryRepositoryFixture();
+
+            // arrange
+            var portfolioEntry1 = new PortfolioEntry("btc", portfolioEntryRepositoryFixture.DefaultPortfolioId);
+            var portfolioEntry2 = new PortfolioEntry("ada", portfolioEntryRepositoryFixture.DefaultPortfolioId);
+            var portfolioEntry3 = new PortfolioEntry("ltc", portfolioEntryRepositoryFixture.DefaultPortfolioId);
+            
+            var portfolioEntry4 = new PortfolioEntry("btc", portfolioEntryRepositoryFixture.SecondaryPortfolioId);
+            var portfolioEntry5 = new PortfolioEntry("eth", portfolioEntryRepositoryFixture.SecondaryPortfolioId);
+
+            // act
+            portfolioEntry1 = portfolioEntry1 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry1)
+            };
+            portfolioEntry2 = portfolioEntry2 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry2)
+            };
+            portfolioEntry3 = portfolioEntry3 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry3)
+            };
+            
+            portfolioEntry4 = portfolioEntry4 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry4)
+            };
+            portfolioEntry5 = portfolioEntry5 with
+            {
+                Id = portfolioEntryRepositoryFixture.PortfolioEntryRepository.Add(portfolioEntry5)
+            };
+
+            // assert
+            var loadedPortfolios = portfolioEntryRepositoryFixture.PortfolioEntryRepository.GetAllByPortfolioId(portfolioEntryRepositoryFixture.DefaultPortfolioId);
+            Assert.Equal(3, loadedPortfolios.Count);
+            Assert.Equal(new List<PortfolioEntry> {portfolioEntry1, portfolioEntry2, portfolioEntry3},
+                loadedPortfolios);
+            
+            var loadedPortfoliosSecondaryPortfolio = portfolioEntryRepositoryFixture.PortfolioEntryRepository.GetAllByPortfolioId(portfolioEntryRepositoryFixture.SecondaryPortfolioId);
+            Assert.Equal(2, loadedPortfoliosSecondaryPortfolio.Count);
+            Assert.Equal(new List<PortfolioEntry> {portfolioEntry4, portfolioEntry5},
+                loadedPortfoliosSecondaryPortfolio);
         }
 
         [Fact]

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ namespace Database`
`4`	`4`	`{`
`5`	`5`	`public class SqlSchema`
`6`	`6`	`{`
	`7`	`+ // TODO column names into constants`
`7`	`8`	`public static void Init(SqlKataDatabase db)`
`8`	`9`	`{`
`9`	`10`	`db.Get().Statement(@"`
Original file line number	Diff line number	Diff line change
`@@ -26,4 +26,9 @@ public interface IMarketOrderRepository : IRepository<MarketOrder>`
`26`	`26`	`public interface IPortfolioRepository : IRepository<Portfolio>`
`27`	`27`	`{`
`28`	`28`	`}`
	`29`	`+`
	`30`	`+ public interface IPortfolioEntryRepository : IRepository<PortfolioEntry>`
	`31`	`+ {`
	`32`	`+ public List<PortfolioEntry> GetAllByPortfolioId(int portfolioId);`
	`33`	`+ }`
`29`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
	`1`	`+using System.Collections.Generic;`
`1`	`2`	`using Database;`
`2`	`3`	`using Model;`
	`4`	`+using SqlKata.Execution;`
`3`	`5`
`4`	`6`	`namespace Repository`
`5`	`7`	`{`
`6`		`- public class SqlKataPortfolioEntryRepository : SqlKataRepository<PortfolioEntry>`
	`8`	`+ public class SqlKataPortfolioEntryRepository : SqlKataRepository<PortfolioEntry>, IPortfolioEntryRepository`
`7`	`9`	`{`
`8`	`10`	`public SqlKataPortfolioEntryRepository(SqlKataDatabase db) : base(db, "portfolio_entries")`
`9`	`11`	`{`
`@@ -16,7 +18,10 @@ public SqlKataPortfolioEntryRepository(SqlKataDatabase db) : base(db, "portfolio`
`16`	`18`	`symbol = entry.Symbol,`
`17`	`19`	`portfolio_id = entry.PortfolioId`
`18`	`20`	`};`
`19`		`-`
	`21`	`+`
`20`	`22`	`public override PortfolioEntry FromRow(dynamic d) => new((string) d.symbol, (int) d.portfolio_id, (int) d.id);`
	`23`	`+`
	`24`	`+ public List<PortfolioEntry> GetAllByPortfolioId(int portfolioId) =>`
	`25`	`+ RowsToObjects(Db.Get().Query(tableName).Where("portfolio_id", portfolioId).Get());`
`21`	`26`	`}`
`22`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,12 +10,12 @@ namespace Repository`
`10`	`10`	`public abstract class SqlKataRepository<T> : IRepository<T>`
`11`	`11`	`{`
`12`	`12`	`protected readonly SqlKataDatabase Db;`
`13`		`- private readonly string _tableName;`
	`13`	`+ protected readonly string tableName;`
`14`	`14`
`15`	`15`	`public SqlKataRepository(SqlKataDatabase db, string tableName)`
`16`	`16`	`{`
`17`	`17`	`this.Db = db;`
`18`		`- this._tableName = tableName;`
	`18`	`+ this.tableName = tableName;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public abstract object ToRow(T entry);`
`@@ -26,26 +26,26 @@ public SqlKataRepository(SqlKataDatabase db, string tableName)`
`26`	`26`
`27`	`27`	`public int Add(T entry)`
`28`	`28`	`{`
`29`		`- var id = Db.Get().Query(_tableName).InsertGetId<int>(ToRow(entry));`
	`29`	`+ var id = Db.Get().Query(tableName).InsertGetId<int>(ToRow(entry));`
`30`	`30`	`return id;`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public bool Update(T entry)`
`34`	`34`	`{`
`35`		`- var updated = Db.Get().Query(_tableName).Where("id", _getEntryId(entry)).Update(ToRow(entry));`
	`35`	`+ var updated = Db.Get().Query(tableName).Where("id", _getEntryId(entry)).Update(ToRow(entry));`
`36`	`36`	`return updated > 0;`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public bool Delete(T entry)`
`40`	`40`	`{`
`41`		`- Db.Get().Query(_tableName).Where("id", _getEntryId(entry)).AsDelete();`
	`41`	`+ Db.Get().Query(tableName).Where("id", _getEntryId(entry)).AsDelete();`
`42`	`42`	`// TODO`
`43`	`43`	`return true;`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public T Get(int id)`
`47`	`47`	`{`
`48`		`- var result = Db.Get().Query(_tableName).Where("id", id).First();`
	`48`	`+ var result = Db.Get().Query(tableName).Where("id", id).First();`
`49`	`49`	`if (result == null)`
`50`	`50`	`{`
`51`	`51`	`return default;`
`@@ -54,27 +54,12 @@ public T Get(int id)`
`54`	`54`	`return FromRow(result);`
`55`	`55`	`}`
`56`	`56`
`57`		`- public List<T> GetAll()`
`58`		`- {`
`59`		`- var result = Db.Get().Query(_tableName).Get();`
`60`		`- if (result == null)`
`61`		`- {`
`62`		`- return default;`
`63`		`- }`
`64`		`-`
`65`		`- var list = new List<T>();`
`66`		`- foreach (var row in result)`
`67`		`- {`
`68`		`- list.Add(FromRow(row));`
`69`		`- }`
`70`		`-`
`71`		`- return list;`
`72`		`- }`
	`57`	`+ public List<T> GetAll() => RowsToObjects(Db.Get().Query(tableName).Select().Get());`
`73`	`58`
`74`		`- public List<T> All()`
	`59`	`+ protected List<T> RowsToObjects(IEnumerable<dynamic> rows)`
`75`	`60`	`{`
`76`	`61`	`List<T> items = new List<T>();`
`77`		`- foreach (var row in Db.Get().Query(_tableName).Select().Get())`
	`62`	`+ foreach (var row in rows)`
`78`	`63`	`{`
`79`	`64`	`items.Add(FromRow(row));`
`80`	`65`	`}`