Refactor/migrate ukstandard

obp-api/src/main/scala/code/api/ResourceDocs1_4_0/ResourceDocsAPIMethods.scala

@@ -189,6 +189,8 @@ trait ResourceDocsAPIMethods extends MdcLoggable with APIMethods220 with APIMeth
         case ApiVersion.v1_4_0 => resourceDocs  // fully on http4s — no Lift route filter
         case ApiVersion.v1_3_0 => resourceDocs  // fully on http4s — no Lift route filter
         case ApiVersion.`dynamic-entity` => resourceDocs  // runtime CRUD now on Http4sDynamicEntity; routes are Nil, skip Lift-route filter
+        case ApiVersion.ukOpenBankingV20 => resourceDocs  // fully on http4s — no Lift route filter
+        case ApiVersion.ukOpenBankingV31 => resourceDocs  // fully on http4s — no Lift route filter
         case _ => resourceDocs.filter(rd => versionRoutesClasses.contains(rd.partialFunction.getClass))
       }
 

obp-api/src/main/scala/code/api/UKOpenBanking/v2_0_0/Http4sUKOBv200.scala

@@ -0,0 +1,37 @@
+package code.api.UKOpenBanking.v2_0_0
+
+import cats.data.{Kleisli, OptionT}
+import cats.effect._
+import code.api.util.APIUtil.ResourceDoc
+import code.api.util.http4s.ResourceDocMiddleware
+import code.util.Helper.MdcLoggable
+import com.openbankproject.commons.util.ApiVersion
+import org.http4s._
+
+import scala.collection.mutable.ArrayBuffer
+
+/**
+ * UK Open Banking v2.0 — http4s aggregator (mirror of Berlin Group's Http4sBGv2).
+ *
+ * Wraps the migrated account-information routes with ResourceDocMiddleware and
+ * exposes `wrappedRoutes` for Http4sApp. All 5 v2.0 endpoints — including the two
+ * account-scoped ones (/accounts/ID/balances, /accounts/ID/transactions) — are
+ * migrated in Http4sUKOBv200AIS. The Lift ScannedApis aggregator
+ * (OBP_UKOpenBanking_200) registers `routes = Nil`, so no UK v2.0 path is served
+ * by Lift — nothing falls through to the Lift bridge.
+ */
+object Http4sUKOBv200 extends MdcLoggable {
+
+  type HttpF[A] = OptionT[IO, A]
+
+  val implementedInApiVersion: ApiVersion = ApiVersion.ukOpenBankingV20
+
+  val resourceDocs: ArrayBuffer[ResourceDoc] =
+    Http4sUKOBv200AIS.resourceDocs
+
+  val allRoutes: HttpRoutes[IO] = Kleisli[HttpF, Request[IO], Response[IO]] { req =>
+    Http4sUKOBv200AIS.routes(req)
+  }
+
+  val wrappedRoutes: HttpRoutes[IO] = ResourceDocMiddleware.apply(resourceDocs)(allRoutes)
+}

obp-api/src/main/scala/code/api/UKOpenBanking/v2_0_0/Http4sUKOBv200AIS.scala

@@ -0,0 +1,194 @@
+package code.api.UKOpenBanking.v2_0_0
+
+import cats.data.{Kleisli, OptionT}
+import cats.effect.IO
+import code.api.APIFailureNewStyle
+import code.api.ResourceDocs1_4_0.SwaggerDefinitionsJSON
+import code.api.util.APIUtil.{EmptyBody, ResourceDoc, createQueriesByHttpParams, fullBoxOrException, unboxFull}
+import code.api.util.ApiTag._
+import code.api.util.CustomJsonFormats
+import code.api.util.ErrorMessages.{AuthenticatedUserIsRequired, UnknownError}
+import code.api.util.NewStyle
+import code.api.util.http4s.Http4sRequestAttributes.EndpointHelpers
+import code.api.util.newstyle.ViewNewStyle
+import code.model.BankAccountExtended
+import code.util.Helper.MdcLoggable
+import code.views.Views
+import com.github.dwickern.macros.NameOf.nameOf
+import com.openbankproject.commons.ExecutionContext.Implicits.global
+import com.openbankproject.commons.model.{AccountId, BankIdAccountId}
+import com.openbankproject.commons.util.{ApiVersion, ScannedApiVersion}
+import net.liftweb.common.Full
+import net.liftweb.http.provider.HTTPParam
+import net.liftweb.json.Formats
+import org.http4s._
+import org.http4s.dsl.io._
+
+import scala.collection.mutable.ArrayBuffer
+import scala.concurrent.Future
+
+/**
+ * UK Open Banking v2.0 — account-information endpoints migrated from Lift to http4s.
+ *
+ * Faithful migration of all 5 endpoints:
+ *  - getAccountList (/accounts), getAccount (/accounts/ID), getBalances (/balances)
+ *    — list/aggregate endpoints using getBankAccounts + a JSON factory.
+ *  - getAccountBalances (/accounts/ID/balances), getAccountTransactions
+ *    (/accounts/ID/transactions) — account-scoped endpoints; their 3-segment
+ *    patterns are distinct from the 2-segment ones, so http4s route matching
+ *    picks the correct handler.
+ * No v2.0 endpoint is left on Lift.
+ */
+object Http4sUKOBv200AIS extends MdcLoggable {
+  type HttpF[A] = OptionT[IO, A]
+  implicit val formats: Formats = CustomJsonFormats.formats
+  val implementedInApiVersion: ScannedApiVersion = ApiVersion.ukOpenBankingV20
+  val resourceDocs = ArrayBuffer[ResourceDoc]()
+  val ukV20Prefix = Root / ApiVersion.ukOpenBankingV20.urlPrefix / ApiVersion.ukOpenBankingV20.apiShortVersion
+
+  // GET /accounts — list all private accounts of the logged-in user
+  lazy val getAccountList: HttpRoutes[IO] = HttpRoutes.of[IO] {
+    case req @ GET -> `ukV20Prefix` / "accounts" =>
+      EndpointHelpers.withUser(req) { (u, cc) =>
+        val callContext = Some(cc)
+        for {
+          availablePrivateAccounts <- Views.views.vend.getPrivateBankAccountsFuture(u)
+          (accounts, _) <- NewStyle.function.getBankAccounts(availablePrivateAccounts, callContext)
+        } yield JSONFactory_UKOpenBanking_200.createAccountsListJSON(accounts)
+      }
+  }
+  resourceDocs += ResourceDoc(
+    null,
+    implementedInApiVersion,
+    nameOf(getAccountList),
+    "GET",
+    "/accounts",
+    "UK Open Banking: Get Account List",
+    """Reads a list of bank accounts, with balances where required.""",
+    EmptyBody,
+    SwaggerDefinitionsJSON.accountsJsonUKOpenBanking_v200,
+    List(AuthenticatedUserIsRequired, UnknownError),
+    List(apiTagUKOpenBanking, apiTagAccount, apiTagPrivateData),
+    http4sPartialFunction = Some(getAccountList)
+  )
+
+  // GET /accounts/{accountId} — single account
+  lazy val getAccount: HttpRoutes[IO] = HttpRoutes.of[IO] {
+    case req @ GET -> `ukV20Prefix` / "accounts" / accountId =>
+      EndpointHelpers.withUser(req) { (u, cc) =>
+        val callContext = Some(cc)
+        for {
+          availablePrivateAccounts <- Views.views.vend.getPrivateBankAccountsFuture(u).map(_.filter(_.accountId.value == accountId))
+          (accounts, _) <- NewStyle.function.getBankAccounts(availablePrivateAccounts, callContext)
+        } yield JSONFactory_UKOpenBanking_200.createAccountJSON(accounts)
+      }
+  }
+  resourceDocs += ResourceDoc(
+    null,
+    implementedInApiVersion,
+    nameOf(getAccount),
+    "GET",
+    "/accounts/ACCOUNT_ID",
+    "UK Open Banking: Get Account",
+    """Reads a bank account, with balances where required.""",
+    EmptyBody,
+    SwaggerDefinitionsJSON.accountsJsonUKOpenBanking_v200,
+    List(AuthenticatedUserIsRequired, UnknownError),
+    List(apiTagUKOpenBanking, apiTagAccount, apiTagPrivateData),
+    http4sPartialFunction = Some(getAccount)
+  )
+
+  // GET /balances — bulk balances for all private accounts
+  lazy val getBalances: HttpRoutes[IO] = HttpRoutes.of[IO] {
+    case req @ GET -> `ukV20Prefix` / "balances" =>
+      EndpointHelpers.withUser(req) { (u, cc) =>
+        val callContext = Some(cc)
+        for {
+          availablePrivateAccounts <- Views.views.vend.getPrivateBankAccountsFuture(u)
+          (accounts, _) <- NewStyle.function.getBankAccounts(availablePrivateAccounts, callContext)
+        } yield JSONFactory_UKOpenBanking_200.createBalancesJSON(accounts)
+      }
+  }
+  resourceDocs += ResourceDoc(
+    null,
+    implementedInApiVersion,
+    nameOf(getBalances),
+    "GET",
+    "/balances",
+    "UK Open Banking: Get Balances",
+    """Bulk retrieval of balances for all authorised accounts.""",
+    EmptyBody,
+    SwaggerDefinitionsJSON.accountBalancesUKV200,
+    List(AuthenticatedUserIsRequired, UnknownError),
+    List(apiTagUKOpenBanking, apiTagAccount, apiTagPrivateData),
+    http4sPartialFunction = Some(getBalances)
+  )
+
+  // GET /accounts/{accountId}/balances — account-level balances
+  lazy val getAccountBalances: HttpRoutes[IO] = HttpRoutes.of[IO] {
+    case req @ GET -> `ukV20Prefix` / "accounts" / accountIdStr / "balances" =>
+      EndpointHelpers.withUser(req) { (u, cc) =>
+        for {
+          (account, _) <- NewStyle.function.getBankAccountByAccountId(AccountId(accountIdStr), Some(cc))
+          view <- ViewNewStyle.checkOwnerViewAccessAndReturnOwnerView(u, BankIdAccountId(account.bankId, account.accountId), Some(cc))
+          moderatedAccount <- Future {
+            BankAccountExtended(account).moderatedBankAccount(view, BankIdAccountId(account.bankId, account.accountId), Full(u), Some(cc))
+          } map { x => unboxFull(fullBoxOrException(x ~> APIFailureNewStyle(UnknownError, 400, Some(cc.toLight)))) }
+        } yield JSONFactory_UKOpenBanking_200.createAccountBalanceJSON(moderatedAccount)
+      }
+  }
+  resourceDocs += ResourceDoc(
+    null,
+    implementedInApiVersion,
+    nameOf(getAccountBalances),
+    "GET",
+    "/accounts/ACCOUNT_ID/balances",
+    "UK Open Banking: Get Account Balances",
+    """An AISP may retrieve the account balance information resource for a specific AccountId.""",
+    EmptyBody,
+    SwaggerDefinitionsJSON.accountBalancesUKV200,
+    List(AuthenticatedUserIsRequired, UnknownError),
+    List(apiTagUKOpenBanking, apiTagAccount, apiTagPrivateData),
+    http4sPartialFunction = Some(getAccountBalances)
+  )
+
+  // GET /accounts/{accountId}/transactions — account-level transactions
+  lazy val getAccountTransactions: HttpRoutes[IO] = HttpRoutes.of[IO] {
+    case req @ GET -> `ukV20Prefix` / "accounts" / accountIdStr / "transactions" =>
+      EndpointHelpers.withUser(req) { (u, cc) =>
+        for {
+          (account, _) <- NewStyle.function.getBankAccountByAccountId(AccountId(accountIdStr), Some(cc))
+          (bank, _) <- NewStyle.function.getBank(account.bankId, Some(cc))
+          view <- ViewNewStyle.checkOwnerViewAccessAndReturnOwnerView(u, BankIdAccountId(account.bankId, account.accountId), Some(cc))
+          params <- Future {
+            createQueriesByHttpParams(req.headers.headers.toList.map(h => HTTPParam(h.name.toString, List(h.value))))
+          } map { x => unboxFull(fullBoxOrException(x ~> APIFailureNewStyle(UnknownError, 400, Some(cc.toLight)))) }
+          (transactions, _) <- Future {
+            BankAccountExtended(account).getModeratedTransactions(bank, Full(u), view, BankIdAccountId(account.bankId, account.accountId), Some(cc), params)
+          } map { x => unboxFull(fullBoxOrException(x ~> APIFailureNewStyle(UnknownError, 400, Some(cc.toLight)))) }
+        } yield JSONFactory_UKOpenBanking_200.createTransactionsJson(transactions, Nil)
+      }
+  }
+  resourceDocs += ResourceDoc(
+    null,
+    implementedInApiVersion,
+    nameOf(getAccountTransactions),
+    "GET",
+    "/accounts/ACCOUNT_ID/transactions",
+    "UK Open Banking: Get Account Transactions",
+    """Reads account data from a given account addressed by "account-id".""",
+    EmptyBody,
+    SwaggerDefinitionsJSON.transactionsJsonUKV200,
+    List(AuthenticatedUserIsRequired, UnknownError),
+    List(apiTagUKOpenBanking, apiTagTransaction, apiTagPrivateData),
+    http4sPartialFunction = Some(getAccountTransactions)
+  )
+
+  val routes: HttpRoutes[IO] = Kleisli[HttpF, Request[IO], Response[IO]] { req =>
+    getAccountList(req)
+      .orElse(getAccount(req))
+      .orElse(getAccountBalances(req))
+      .orElse(getAccountTransactions(req))
+      .orElse(getBalances(req))
+  }
+}

obp-api/src/main/scala/code/api/UKOpenBanking/v2_0_0/OBP_UKOpenBanking_200.scala

@@ -1,68 +1,46 @@
-/**
-Open Bank Project - API
-Copyright (C) 2011-2019, TESOBE GmbH.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Email: contact@tesobe.com
-TESOBE GmbH.
-Osloer Strasse 16/17
-Berlin 13359, Germany
-
-This product includes software developed at
-TESOBE (http://www.tesobe.com/)
-
-  */
 package code.api.UKOpenBanking.v2_0_0
 
 import code.api.OBPRestHelper
-import code.api.util.APIUtil.{OBPEndpoint, getAllowedEndpoints}
+import code.api.util.APIUtil.{OBPEndpoint, ResourceDoc}
 import code.api.util.ScannedApis
 import code.util.Helper.MdcLoggable
+import com.openbankproject.commons.util.{ApiVersion, ApiVersionStatus, ScannedApiVersion}
 
-import scala.collection.immutable.Nil
-import code.api.UKOpenBanking.v2_0_0.APIMethods_UKOpenBanking_200._
-import com.openbankproject.commons.util.{ApiVersion, ApiVersionStatus}
-
+import scala.collection.mutable.ArrayBuffer
 
 /*
-This file defines which endpoints from all the versions are available in v1
+ * All v2.0 UK Open Banking endpoints have been migrated to Http4sUKOBv200AIS.
+ * This stub is retained for ScannedApis registration (class-path scanning) and
+ * so that external callers (APIUtil, SwaggerJSONFactory) that access
+ * OBP_UKOpenBanking_200.apiVersion / .allResourceDocs continue to compile.
+ * Routes are served by Http4sUKOBv200.wrappedRoutes in Http4sApp (ahead of the Lift bridge).
  */
+object OBP_UKOpenBanking_200 extends OBPRestHelper with MdcLoggable with ScannedApis {
 
+  override val apiVersion: ScannedApiVersion = ApiVersion.ukOpenBankingV20
+  val versionStatus: String = ApiVersionStatus.DRAFT.toString
 
-object OBP_UKOpenBanking_200 extends OBPRestHelper with MdcLoggable with ScannedApis{
-
-  override val apiVersion = ApiVersion.ukOpenBankingV20
-  val versionStatus = ApiVersionStatus.DRAFT.toString
-
-  val allEndpoints = 
-    getAccountList :: 
-    getAccountTransactions :: 
-    getAccount :: 
-    getAccountBalances :: 
-    getBalances :: 
-    Nil
-
-  override val allResourceDocs = resourceDocs
-
-  // Filter the possible endpoints by the disabled / enabled Props settings and add them together
-  override val routes : List[OBPEndpoint] = getAllowedEndpoints(allEndpoints,resourceDocs)
-
-
-  // Make them available for use!
-  registerRoutes(routes, allResourceDocs, apiPrefix)
-
-  logger.info(s"version $version has been run! There are ${routes.length} routes.")
+  override val allResourceDocs: ArrayBuffer[ResourceDoc] = Http4sUKOBv200.resourceDocs
 
+  override val routes: List[OBPEndpoint] = Nil
 }
+
+// ─── Original Lift aggregator (commented out) ────────────────────────────────
+//import code.api.UKOpenBanking.v2_0_0.APIMethods_UKOpenBanking_200._
+//import scala.collection.immutable.{Nil => immNil}
+//import code.api.util.APIUtil.getAllowedEndpoints
+//
+//  val allEndpoints =
+//    getAccountList ::
+//    getAccountTransactions ::
+//    getAccount ::
+//    getAccountBalances ::
+//    getBalances ::
+//    immNil
+//
+//  override val allResourceDocs = resourceDocs
+//
+//  override val routes : List[OBPEndpoint] = getAllowedEndpoints(allEndpoints, resourceDocs)
+//
+//  registerRoutes(routes, allResourceDocs, apiPrefix)
+//  logger.info(s"version $version has been run! There are ${routes.length} routes.")