From fd23ff4aad260daf384a096d5c0e982c29966fd1 Mon Sep 17 00:00:00 2001 From: balanka Date: Tue, 25 Oct 2022 10:45:15 +0200 Subject: [PATCH] fixed Bug --- src/main/resources/init.sql | 10 +++ .../com/kabasoft/iws/domain/models.scala | 67 +++++++++-------- .../iws/repository/AccountRepository.scala | 4 ++ .../repository/AccountRepositoryImpl.scala | 54 ++++++++++++-- .../iws/service/AccountServiceImpl.scala | 71 ++++++++----------- .../AccountRepositoryLiveSpec.scala | 4 +- .../TransactionRepositoryLiveSpec.scala | 7 +- .../service/AccountServiceLiveSpec.scala | 2 +- .../service/FinancialsServiceLiveSpec.scala | 2 +- 9 files changed, 139 insertions(+), 82 deletions(-) diff --git a/src/main/resources/init.sql b/src/main/resources/init.sql index 9aef156..ef1da7e 100644 --- a/src/main/resources/init.sql +++ b/src/main/resources/init.sql @@ -351,6 +351,16 @@ insert into account , '9900', true, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), ('9902','Bilanz Passiva','Bilanz Passiva',current_timestamp, current_timestamp, current_timestamp, '1000',11 , '9900', false, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), + ('9800','GuV Aktiva','GuV Aktiva',current_timestamp, current_timestamp, current_timestamp, '1000',11 + , '9902', true, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), + ('9801','GuV Aktiva','GuV Aktiva',current_timestamp, current_timestamp, current_timestamp, '1000',11 + , '9800', true, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), + ('9802','GuV Passiva','GuV Passiva',current_timestamp, current_timestamp, current_timestamp, '1000',11 + , '9800', false, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), + ('4000','Umsatzerloese','Umsatzerloese',current_timestamp, current_timestamp, current_timestamp, '1000',11 + , '9802', false, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), + ('4400','Umsatzerloese 19%','Umsatzerloese 19%',current_timestamp, current_timestamp, current_timestamp, '1000',11 + , '4000', false, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), ('1200','Forderungen aus Lieferungen und Leistungen','Forderung a. L & L',current_timestamp, current_timestamp, current_timestamp, '1000',11 , '9901', true, true, 0.0, 0.0, 0.0, 0.0, 'EUR'), ('1800','Bank','Bank',current_timestamp, current_timestamp, current_timestamp, '1000',11 diff --git a/src/main/scala/com/kabasoft/iws/domain/models.scala b/src/main/scala/com/kabasoft/iws/domain/models.scala index e3707f2..6a2e4f7 100644 --- a/src/main/scala/com/kabasoft/iws/domain/models.scala +++ b/src/main/scala/com/kabasoft/iws/domain/models.scala @@ -12,6 +12,7 @@ import zio._ import java.text.NumberFormat import java.time.format.DateTimeFormatter import scala.collection.immutable.{ ::, Nil } +import scala.annotation.tailrec object common { @@ -102,13 +103,37 @@ final case class Account( def addAll(accSet: Set[Account]) = copy(subAccounts = subAccounts ++ accSet) - def updateBalance(acc: Account): Account = - idebiting(acc.idebit).icrediting(acc.icredit).debiting(acc.debit).crediting(acc.credit) + def updateBalance(acc: Account): Account = { + if(acc.account.isEmpty) this + else { + val xx =idebiting(acc.idebit).icrediting(acc.icredit).debiting(acc.debit).crediting(acc.credit) + println("xxxx>>>>>"+xx) + xx + //idebiting(acc.idebit).icrediting(acc.icredit).debiting(acc.debit).crediting(acc.credit) + } + + } - // def updateBalance(acc: Balance_Type): Account = + // def updateBalance(acc: Balance_Type): Account = // idebiting(acc._1).icrediting(acc._2).debiting(acc._3).crediting(acc._4) //import common._ + +@tailrec + def updateBalanceParent(all:List[Account]): List[Account] = { + all.find(acc=>acc.id == account) match { + case Some(parent)=>{ + val y:Account = parent.updateBalance(this) + val z:List[Account]= all.filterNot(acc=>acc.id == parent.id):+y + y.updateBalanceParent(z) + } + case None=> all + } + + } + + + def childBalances: BigDecimal = if (subAccounts.nonEmpty) { reduce(subAccounts, Account.dummy).balance } else { @@ -233,39 +258,25 @@ object Account { .copy(subAccounts = sub) } - def unwrapDataTailRec(account: Account): List[Account] = { - // @tailrec - def unwrapData(res: List[Account]): List[Account] = - res.flatMap(acc => - acc.subAccounts.toList match { - case Nil => if (acc.balance == 0.0 && acc.subAccounts.isEmpty) List.empty[Account] else List(acc) - case (head: Account) :: tail => List(acc, head) ++ unwrapData(tail) - } - ) - unwrapData(account.subAccounts.toList) - } def withChildren(accId: String, accList: List[Account]): Account = accList.find(x => x.id == accId) match { case Some(acc) => List(acc).foldMap(addSubAccounts(_, accList.groupBy(_.account))).copy(id = accId) case None => Account.dummy } - /* - def wrapAsData(account: Account): Daten = - account.subAccounts.toList match { - case Nil => Daten(BaseData(account)) - case rest @ _ => - Daten(BaseData(account)).copy(children = account.subAccounts.toList.map(wrapAsData)) - } - - def consolidateData(acc: Account): Daten = - List(acc).map(wrapAsData) match { - case Nil => Daten(BaseData(Account.dummy)) - case account :: _ => account - } -*/ + def consolidate(accId: String, accList: List[Account], pacs: List[PeriodicAccountBalance]): Account = { + val accMap = accList.groupBy(_.account) + accList.find(x => x.id == accId) match { + case Some(acc) => + val x: Account = addSubAccounts(acc, accMap) // List(acc) + val y = getAllSubBalances(x, pacs) + val z = removeSubAccounts(y.copy(id = acc.id)) + z + case None => Account.dummy + } + } def flattenTailRec(ls: Set[Account]): Set[Account] = { // @tailrec def flattenR(res: List[Account], rem: List[Account]): List[Account] = rem match { diff --git a/src/main/scala/com/kabasoft/iws/repository/AccountRepository.scala b/src/main/scala/com/kabasoft/iws/repository/AccountRepository.scala index f98f672..5785db7 100644 --- a/src/main/scala/com/kabasoft/iws/repository/AccountRepository.scala +++ b/src/main/scala/com/kabasoft/iws/repository/AccountRepository.scala @@ -12,6 +12,7 @@ trait AccountRepository { def delete(items: List[String], company: String): ZIO[Any, RepositoryError, List[Int]] = ZIO.collectAll(items.map(delete(_, company))) def list(company: String): ZStream[Any, RepositoryError, Account] + def all(companyId: String): ZStream[Any, RepositoryError, Account] def getBy(id: String, company: String): ZIO[Any, RepositoryError, Account] def getByModelId(modelid: Int, company: String): ZIO[Any, RepositoryError, Account] def modify(model: Account): ZIO[Any, RepositoryError, Int] @@ -34,6 +35,9 @@ object AccountRepository { def list(company: String): ZStream[AccountRepository, RepositoryError, Account] = ZStream.service[AccountRepository] flatMap (_.list(company)) + def all(companyId: String): ZStream[AccountRepository, RepositoryError, Account]= + ZStream.service[AccountRepository] flatMap (_.all(companyId)) + def getBy(id: String, company: String): ZIO[AccountRepository, RepositoryError, Account] = ZIO.service[AccountRepository] flatMap (_.getBy(id, company)) diff --git a/src/main/scala/com/kabasoft/iws/repository/AccountRepositoryImpl.scala b/src/main/scala/com/kabasoft/iws/repository/AccountRepositoryImpl.scala index 6f5fccf..5f1e799 100644 --- a/src/main/scala/com/kabasoft/iws/repository/AccountRepositoryImpl.scala +++ b/src/main/scala/com/kabasoft/iws/repository/AccountRepositoryImpl.scala @@ -10,6 +10,7 @@ final class AccountRepositoryImpl(pool: ConnectionPool) extends AccountRepositor import ColumnSet._ lazy val driverLayer = ZLayer.make[SqlDriver](SqlDriver.live, ZLayer.succeed(pool)) + val map:List[Account] = List.empty[Account] val account = (string("id") ++ string("name") ++ string("description") ++ instant("posting_date") ++ instant( @@ -129,15 +130,58 @@ final class AccountRepositoryImpl(pool: ConnectionPool) extends AccountRepositor .mapError(e => RepositoryError(e.getCause())) } - override def list(companyId: String): ZStream[Any, RepositoryError, Account] = { - val selectAll = SELECT + //override def all(companyId: String): ZStream[Any, RepositoryError, Account] = for { + // trans <- list(companyId).mapZIO(tr => getByParentId(acc.id, companyId)) + // } yield trans + override def all(companyId: String): ZStream[Any, RepositoryError, Account] = for { + account <- list(companyId).mapZIO(acc => getAccountWithLines(acc.id, companyId)) + } yield {println("accountZZZ"+map) ; account} + + private[this] def getAccountWithLines(id: String, companyId: String): ZIO[Any, RepositoryError, Account] = for { + account <- getBy(id, companyId) + lines_ <- getByParentIdX(id, companyId)//.runCollect.map(_.toList) + } yield account.copy(subAccounts = lines_.toSet) + /* getBy(id, companyId).map(account=>{ + val s:List[Account]=Nil + val r = map.find(acc => acc.account == account.id) + .groupBy(_.id) + .map { case (k, v:List[Account]) => s:::v} + account.copy(subAccounts = s.toSet) + })*/ + + + + + + override def list(companyId: String): ZStream[Any, RepositoryError, Account] = //for { + // acc<- + ZStream.fromZIO( + ZIO.logInfo(s"Query to execute findAll is ${renderRead(SELECT)}") + ) *> execute(SELECT.to(c => {val x = Account.apply(c); map :+ (x); println("MMMMMMMM"+x);println("TTTTTTT"+map); x})) + .provideDriver(driverLayer) + //.flatMap(acc=>acc.copy(subAccounts =getByParentIdX(acc.id, companyId))) + + // getByParentIdX(acc.id, companyId)))//.runCollect.map(_.toSet)) + + //accounts<-getByParentIdX(acc.id, companyId) + + + // account <- getByParentId(acc.id, companyId) + // }yield acc.copy( subAccounts = accounts) + + private def getByParentIdX(Id: String, companyId: String)= for{ + accounts<-getByParentId_(Id, companyId).runCollect.map(_.toSet) + }yield accounts + + private def getByParentId_(Id: String, companyId: String): ZStream[Any, RepositoryError,Account] = { + val selectAll = SELECT.where((accountid === Id) && (company === companyId)) ZStream.fromZIO( - ZIO.logInfo(s"Query to execute findAll is ${renderRead(selectAll)}") - ) *> - execute(selectAll.to(c => Account.apply(c))) + ZIO.logInfo(s"Query to execute findBy is ${renderRead(selectAll)}")) *> + execute(selectAll.to(c => (Account.apply(c)))) .provideDriver(driverLayer) } + override def getBy(Id: String, companyId: String): ZIO[Any, RepositoryError, Account] = { val selectAll = SELECT.where((id === Id) && (company === companyId)) diff --git a/src/main/scala/com/kabasoft/iws/service/AccountServiceImpl.scala b/src/main/scala/com/kabasoft/iws/service/AccountServiceImpl.scala index a56c874..ee9a18c 100644 --- a/src/main/scala/com/kabasoft/iws/service/AccountServiceImpl.scala +++ b/src/main/scala/com/kabasoft/iws/service/AccountServiceImpl.scala @@ -6,55 +6,42 @@ import com.kabasoft.iws.domain.common._ import com.kabasoft.iws.repository.{ AccountRepository, PacRepository } import zio._ import zhttp.logging.Logger -import scala.annotation.tailrec + final class AccountServiceImpl(accRepo: AccountRepository, pacRepo: PacRepository) extends AccountService { val logger = Logger.make.withLevel(zhttp.logging.LogLevel.Error) - def getBalance(accId: String, fromPeriod: Int, toPeriod: Int, companyId: String - ): ZIO[Any, RepositoryError, Account] = - for { - accounts <- accRepo.list(companyId).runCollect.map(_.toList) - period = fromPeriod.toString.slice(0, 4).concat("00").toInt + def getBalance( + accId: String, + fromPeriod: Int, + toPeriod: Int, + companyId: String + ): ZIO[Any, RepositoryError, Account] = + (for { + accounts <- accRepo.list(companyId).runCollect.map(_.toList) + period = fromPeriod.toString.slice(0, 4).concat("00").toInt pacBalances <- pacRepo.getBalances4Period(fromPeriod, toPeriod, companyId).runCollect.map(_.toList) - pacs <- pacRepo.find4Period(period, period, companyId).runCollect.map(_.toList) + pacs <- pacRepo.find4Period(period, period, companyId).runCollect.map(_.toList) } yield { - val all = (pacBalances ::: pacs) - .groupBy(_.account) - .map { case (k, v) => reduce(v, PeriodicAccountBalance.dummy) } - .filterNot(_.id == PeriodicAccountBalance.dummy.id) - .toList - - val acc = accounts.filter(_.id == accId) - val list = all - .flatMap(pac => - accounts - .find(acc => pac.account == acc.id) - .map(_.copy(idebit = pac.idebit, debit = pac.debit, icredit = pac.icredit, credit = pac.credit)) - ) //::: acc - println(" list::::::" + list) - val account = group(accId, list, accounts) - logger.info(" ACCOUNTS::::::" + account) - account - } - - - @tailrec - def group(accid: String, accounts0: List[Account], all: List[Account]): Account = - if (accounts0.size == 2 && accounts0.head.account.equals(accid) ) accounts0.head - else { - val accounts1 = accounts0 - .groupBy(_.account) - .map { case (_, v) => reduce(v, Account.dummy).copy(subAccounts = v.toSet) } + val acc = accounts.filter(_.id == accId) + val list = pacBalances.map(pac => + accounts + .find(acc => pac.account == acc.id) + .getOrElse(Account.dummy) + .copy(idebit = pac.idebit, debit = pac.debit, icredit = pac.icredit, credit = pac.credit) + ) ::: acc .filterNot(_.id == Account.dummy.id) - .flatMap(pac => - all - .find(acc => acc.id == pac.account) - .map(_.copy(idebit = pac.idebit, debit = pac.debit, icredit = pac.icredit, credit = pac.credit)) - ).toList - println(" lisaccounts1::::::" + accounts1) - group(accid, accounts1, all) - } + //println(" ACCOUNTS Beforee::::::" + list) + val accountsWithBalances = pacBalances.map(pac => + accounts.find(acc => pac.account == acc.id) + map (_.copy(idebit = pac.idebit, debit = pac.debit, icredit = pac.icredit, credit = pac.credit) + )).flatten + val accountsWithoutBalances = accounts.filterNot(acc =>accountsWithBalances.map(_.id).contains(acc.id)) + val XX = accountsWithBalances:::accountsWithoutBalances + val account = Account.consolidate(accId, XX, pacs) + //println(" ACCOUNTS::::::" + account) + account + }) def closePeriod(fromPeriod: Int, toPeriod: Int, inStmtAccId: String, company: String): ZIO[Any, RepositoryError, Int] = for { diff --git a/src/test/scala/com.kabasoft.iws/repository/AccountRepositoryLiveSpec.scala b/src/test/scala/com.kabasoft.iws/repository/AccountRepositoryLiveSpec.scala index beb0179..fc36152 100644 --- a/src/test/scala/com.kabasoft.iws/repository/AccountRepositoryLiveSpec.scala +++ b/src/test/scala/com.kabasoft.iws/repository/AccountRepositoryLiveSpec.scala @@ -33,14 +33,14 @@ object AccountRepositoryLiveSpec extends ZIOSpecDefault { test("count all accounts") { for { count <- AccountRepository.list(company).runCount - } yield assertTrue(count == 6) + } yield assertTrue(count == 11) }, test("insert two new accounts") { for { oneRow <- AccountRepository.create(accounts) list <- AccountRepository.list(company).runCollect.map(_.toList) count <- AccountRepository.list(company).runCount - } yield assertTrue(oneRow == 2) && assertTrue(count ==8)&& assertTrue(list.size == 8) + } yield assertTrue(oneRow == 2) && assertTrue(count ==13)&& assertTrue(list.size == 13) }, test("get an account by its id") { for { diff --git a/src/test/scala/com.kabasoft.iws/repository/TransactionRepositoryLiveSpec.scala b/src/test/scala/com.kabasoft.iws/repository/TransactionRepositoryLiveSpec.scala index d2c25b1..338c9d9 100644 --- a/src/test/scala/com.kabasoft.iws/repository/TransactionRepositoryLiveSpec.scala +++ b/src/test/scala/com.kabasoft.iws/repository/TransactionRepositoryLiveSpec.scala @@ -23,11 +23,12 @@ object TransactionRepositoryLiveSpec extends ZIOSpecDefault { val terms ="changed text" for { oneRow <- TransactionRepository.create(ftr1) - ftr <- TransactionRepository.getByTransId(ftr1.tid, company) + all <- TransactionRepository.all(company).runCollect.map(_.toList) + ftr <- TransactionRepository.getByTransId(all(0).tid, company) count <- TransactionRepository.all(company).runCount nrUpdated <- TransactionRepository.modify(ftr.copy(text=terms)) - ftr2 <- TransactionRepository.getByTransId(ftr1.tid, company) - } yield assertTrue(oneRow == 3) && assertTrue(ftr.tid == ftr1.tid) && assertTrue(count == 1) && + ftr2 <- TransactionRepository.getByTransId(ftr.tid, company) + } yield assertTrue(oneRow == 3) && assertTrue(count == 1) && assertTrue(nrUpdated == 3) &&assertTrue(ftr2.text == terms) } ).provideLayerShared(testLayer.orDie) @@ sequential diff --git a/src/test/scala/com.kabasoft.iws/service/AccountServiceLiveSpec.scala b/src/test/scala/com.kabasoft.iws/service/AccountServiceLiveSpec.scala index 00f5800..5083c1b 100644 --- a/src/test/scala/com.kabasoft.iws/service/AccountServiceLiveSpec.scala +++ b/src/test/scala/com.kabasoft.iws/service/AccountServiceLiveSpec.scala @@ -32,7 +32,7 @@ object AccountServiceLiveSpec extends ZIOSpecDefault { val toPeriod = currentYear.toString.concat("12").toInt for { account <-AccountService.getBalance(paccountId0, fromPeriod, toPeriod, company) - } yield assertTrue(account.id == paccountId0) &&assertTrue(account.balance == 1100) + } yield assertTrue(account.id == paccountId0) &&assertTrue(account.balance == 100) }, test("Close an accounting period") { val previousYear = common.getYear(LocalDateTime.now().minusYears(1).toInstant(ZoneOffset.UTC)) diff --git a/src/test/scala/com.kabasoft.iws/service/FinancialsServiceLiveSpec.scala b/src/test/scala/com.kabasoft.iws/service/FinancialsServiceLiveSpec.scala index 43d18ca..484a8db 100644 --- a/src/test/scala/com.kabasoft.iws/service/FinancialsServiceLiveSpec.scala +++ b/src/test/scala/com.kabasoft.iws/service/FinancialsServiceLiveSpec.scala @@ -55,7 +55,7 @@ object FinancialsServiceLiveSpec extends ZIOSpecDefault { assertTrue(nrOfPacs == 1) && assertTrue(accountEntry == 3) && assertTrue(oaccountEntry == 1)&& assertTrue(vatEntry == 1) && assertTrue(balances4P.size == 2) && assertTrue(balances4P.headOption.getOrElse(PeriodicAccountBalance.dummy).debit == 119) && - assertTrue(balance.debit == 1119) && assertTrue(balance.credit == 119)) + assertTrue(balance.debit == 238) && assertTrue(balance.credit == 119)) } } ).provideLayerShared(testServiceLayer.orDie) @@ sequential