There's nothing here!
+
+
+This README is for anyone who would like to contribute to Izanami.
+
+If you're interested in Izanami documentation, [it's here]().
+
+## Start application locally
+
+### Izanami frontend
+
+```sh
+cd izanami-frontend
+npm run dev
+```
+
+### Local database & misc tools
+
+```sh
+docker-compose rm -f && docker-compose up
+```
+
+### Izanami backend
+
+```sh
+sbt -jvm-debug 5005
+~run -Dconfig.resource=dev.conf
+```
+
+Once everything is started, just browse to [localhost:3000](http://localhost:3000).
+
+
+In a developement setup, it may be usefull to craft tokens with longer TTL
+
+```
+sbt -jvm-debug 5005
+~run -Dconfig.resource=dev.conf -Dapp.sessions.TTL=604800
+```
+
+### Backend tests
+
+To run test, you can either start Izanami and associated tooling (db, ...) with above commands or just run a suite / a test.
+
+In fact, an Izanami instance and docker containers will be started by tests if none is running. This could be usefull for coverage / debug.
+
+You'll need docker-compose installed locally to run tests like this, due to [this issue](https://github.com/testcontainers/testcontainers-java/issues/7239).
+
+#### Colima setup
+
+To run test without having starting docker-compose, you'll need these env variables to be set.
+
+```sh
+DOCKER_HOST=unix://${HOME}/.colima/default/docker.sock;
+RYUK_CONTAINER_PRIVILEGED=true;
+TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock
+```
+
+
+## Package application
+
+To package frontend :
+
+```sh
+cd izanami-frontend
+npm run build
+```
+
+To package backend (make sure to package frontend first) :
+
+```sh
+sbt "set test in assembly := {}" clean assembly
+```
+
+To start generated jar
+
+```sh
+java -Dconfig.resource=dev.conf -jar ./target/scala-2.13/izanami.jar
+```
+
+To build docker image (after packaging frontend and backends)
+
+```sh
+docker build -t izanami .
+```
+To test docker image
+
+```sh
+docker run --env IZANAMI_PG_URI=postgresql://postgres:postgres@host.docker.internal:5432/postgres -p 9000:9000 izanami
+```
diff --git a/app/fr/maif/izanami/application.scala b/app/fr/maif/izanami/application.scala
new file mode 100644
index 000000000..2c239946a
--- /dev/null
+++ b/app/fr/maif/izanami/application.scala
@@ -0,0 +1,115 @@
+package fr.maif.izanami
+
+import com.softwaremill.macwire.wire
+import controllers.{Assets, AssetsComponents}
+import fr.maif.izanami.env.Env
+import fr.maif.izanami.errors.IzanamiHttpErrorHandler
+import fr.maif.izanami.v1.WasmManagerClient
+import fr.maif.izanami.web.{ClientApiKeyAction, _}
+import play.api.ApplicationLoader.Context
+import play.api._
+import play.api.http.{DefaultHttpFilters, HttpErrorHandler}
+import play.api.libs.ws.ahc.AhcWSComponents
+import play.api.mvc.EssentialFilter
+import play.api.routing.Router
+import play.filters.HttpFiltersComponents
+import play.filters.cors.{CORSConfig, CORSFilter}
+import play.filters.csp.{CSPComponents, CSPFilter, CSPResultProcessor}
+import play.filters.csrf.CSRFFilter
+import play.filters.gzip.GzipFilterComponents
+import play.filters.headers.{SecurityHeadersConfig, SecurityHeadersFilter}
+import play.filters.https.{RedirectHttpsComponents, RedirectHttpsConfiguration, RedirectHttpsFilter}
+import router.Routes
+
+import scala.concurrent.duration.DurationInt
+import scala.concurrent.{Await, Future}
+
+class IzanamiLoader extends ApplicationLoader {
+ private val logger = Logger("IzanamiLoader")
+
+ def load(context: ApplicationLoader.Context): Application = {
+ LoggerConfigurator(context.environment.classLoader).foreach {
+ _.configure(context.environment, context.initialConfiguration, Map.empty)
+ }
+ val components = new IzanamiComponentsInstances(context)
+ Await.result(components.onStart(), 10.seconds)
+ components.application
+ }
+}
+
+class IzanamiComponentsInstances(
+ context: Context
+) extends BuiltInComponentsFromContext(context)
+ with AssetsComponents
+ with AhcWSComponents
+ with HttpFiltersComponents
+ with CSPComponents
+ with RedirectHttpsComponents
+ with GzipFilterComponents {
+
+ override lazy val httpFilters: Seq[EssentialFilter] = super.httpFilters.filter {
+ case _: CSRFFilter => false
+ case _ => false
+ } :+ corsFilter :+ /*cspFilter :+ redirectHttpsFilter :*/ gzipFilter
+ override lazy val httpErrorHandler: HttpErrorHandler = wire[IzanamiHttpErrorHandler]
+
+ implicit lazy val env: Env = new Env(
+ configuration = configuration,
+ environment = environment,
+ Ws = wsClient
+ )
+
+ lazy val filters = new DefaultHttpFilters(httpFilters: _*)
+
+ lazy val authAction = wire[TenantAuthActionFactory]
+ lazy val tenantAuthAction = wire[ProjectAuthActionFactory]
+ lazy val adminAuthAction = wire[AdminAuthAction]
+ lazy val keyAuthAction = wire[KeyAuthActionFactory]
+ lazy val authenticatedAction = wire[AuthenticatedAction]
+ lazy val detailledAuthAction = wire[DetailledAuthAction]
+ lazy val detailledRightForTenantFactory = wire[DetailledRightForTenantFactory]
+ lazy val tenantRightsAction = wire[TenantRightsAction]
+ lazy val sessionAuthAction = wire[AuthenticatedSessionAction]
+ lazy val wasmManagerClient = wire[WasmManagerClient]
+ lazy val clientApiKeyAction = wire[ClientApiKeyAction]
+
+ lazy val featureController = wire[FeatureController]
+ lazy val tenantController = wire[TenantController]
+ lazy val projectController = wire[ProjectController]
+ lazy val tagController = wire[TagController]
+ lazy val apiKeyController = wire[ApiKeyController]
+ lazy val featureContextController = wire[FeatureContextController]
+ lazy val userController = wire[UserController]
+ lazy val loginController = wire[LoginController]
+ lazy val configurationController = wire[ConfigurationController]
+ lazy val pluginController = wire[PluginController]
+ lazy val importController = wire[ImportController]
+ lazy val legacyController = wire[LegacyController]
+ lazy val eventController = wire[EventController]
+ lazy val frontendController = wire[FrontendController]
+
+ override lazy val assets: Assets = wire[Assets]
+ lazy val router: Router = {
+ // add the prefix string in local scope for the Routes constructor
+ val prefix: String = "/"
+ wire[Routes]
+ }
+
+ def onStart(): Future[Unit] = {
+ applicationLifecycle.addStopHook { () =>
+ env.onStop()
+ }
+ env
+ .onStart()
+ }
+
+ def corsFilter: CORSFilter = {
+ new CORSFilter(CORSConfig.fromConfiguration(env.configuration))
+ }
+
+ /*def redirectHttpsFilter: RedirectHttpsFilter = {
+ RedirectHttpsConfigurationProvider
+ new RedirectHttpsFilter(RedirectHttpsConfiguration.(env.configuration))
+ }*/
+
+}
diff --git a/app/fr/maif/izanami/datastores/ApiKeyDatastore.scala b/app/fr/maif/izanami/datastores/ApiKeyDatastore.scala
new file mode 100644
index 000000000..4f94236d8
--- /dev/null
+++ b/app/fr/maif/izanami/datastores/ApiKeyDatastore.scala
@@ -0,0 +1,387 @@
+package fr.maif.izanami.datastores
+
+import fr.maif.izanami.datastores.apiKeyImplicites.ApiKeyRow
+import fr.maif.izanami.env.Env
+import fr.maif.izanami.env.PostgresqlErrors.{FOREIGN_KEY_VIOLATION, RELATION_DOES_NOT_EXISTS}
+import fr.maif.izanami.env.pgimplicits.EnhancedRow
+import fr.maif.izanami.errors._
+import fr.maif.izanami.models.{ApiKey, ApiKeyProject, ApiKeyWithCompleteRights}
+import fr.maif.izanami.utils.Datastore
+import fr.maif.izanami.utils.syntax.implicits.BetterSyntax
+import fr.maif.izanami.web.ImportController.{Fail, ImportConflictStrategy}
+import io.vertx.pgclient.PgException
+import io.vertx.sqlclient.{Row, SqlConnection}
+
+import java.util.UUID
+import scala.List
+import scala.concurrent.Future
+
+class ApiKeyDatastore(val env: Env) extends Datastore {
+ def createApiKey(
+ apiKey: ApiKey,
+ user: String
+ ): Future[Either[IzanamiError, ApiKey]] = {
+ createApiKeys(apiKey.tenant, apiKeys = Seq(apiKey), user=user, conflictStrategy = Fail, conn= None)
+ .map(e => e.map(_.head).left.map(_.head))
+ }
+
+ def findLegacyKeyTenant(clientId: String): Future[Option[String]] = {
+ env.postgresql.queryOne(
+ s"""SELECT tenant FROM izanami.key_tenant WHERE client_id = $$1""",
+ List(clientId)
+ ){r => r.optString("tenant")}
+ }
+
+ def createApiKeys(
+ tenant: String,
+ apiKeys: Seq[ApiKey],
+ user: String,
+ conflictStrategy: ImportConflictStrategy,
+ conn: Option[SqlConnection]
+ ): Future[Either[Seq[IzanamiError], Seq[ApiKey]]] = {
+ // TODO handle conflict strategy
+
+ def callback(connection: SqlConnection): Future[Either[Seq[IzanamiError], Seq[ApiKey]]] = {
+ env.postgresql
+ .queryAll(
+ s"""insert into apikeys (name, clientid, clientsecret, description, enabled, legacy, admin)
+ |values (unnest($$1::text[]), unnest($$2::text[]), unnest($$3::text[]), unnest($$4::text[]), unnest($$5::boolean[]), unnest($$6::boolean[]), unnest($$7::boolean[])) returning *""".stripMargin,
+ List(
+ apiKeys.map(_.name).toArray,
+ apiKeys.map(_.clientId).toArray,
+ apiKeys.map(key => key.clientSecret).toArray,
+ apiKeys.map(_.description).toArray,
+ apiKeys.map(k => java.lang.Boolean.valueOf(k.enabled)).toArray,
+ apiKeys.map(k => java.lang.Boolean.valueOf(k.legacy)).toArray,
+ apiKeys.map(k => java.lang.Boolean.valueOf(k.admin)).toArray
+ ),
+ conn = Some(connection),
+ schemas=Set(tenant)
+ ) { row => {
+ val requestKey = apiKeys.find(k => k.name == row.getString("name")).get
+ row.optApiKey(requestKey.tenant).map(key => key.copy(clientSecret = requestKey.clientSecret))
+ }
+ }
+ .flatMap(_ => {
+ val futures: Seq[Future[Either[IzanamiError, ApiKey]]] = apiKeys.filter(key => key.projects.nonEmpty)
+ .map(apiKey =>
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO apikeys_projects (apikey, project)
+ |SELECT $$1, unnest($$2::TEXT[])
+ |RETURNING *
+ |""".stripMargin,
+ List(apiKey.name, apiKey.projects.toArray),
+ conn = Some(connection),
+ schemas=Set(tenant)
+ ) { _ => Some(apiKey) }
+ .map {
+ _.toRight(InternalServerError())
+ }
+ .recover {
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION =>
+ Left(OneProjectDoesNotExists(apiKey.projects))
+ case ex =>
+ logger.error("Failed to update project mapping table", ex)
+ Left(InternalServerError())
+ }
+ )
+ Future.sequence(futures)
+ })
+ .flatMap(eitherKey => {
+ val errors = eitherKey.toList.filter(_.isLeft)
+ .map(_.swap.toOption).flatMap(_.toList)
+ errors match {
+ case Nil => {
+ env.postgresql
+ .queryAll(
+ s"""
+ |INSERT INTO users_keys_rights(username, apikey, level)
+ |VALUES (unnest($$1::text[]), unnest($$2::text[]), 'ADMIN')
+ |RETURNING apikey
+ |""".stripMargin,
+ List(Array.fill(apiKeys.size)(user), apiKeys.map(_.name).toArray),
+ conn = Some(connection),
+ schemas = Set(tenant)
+ ) { r => apiKeys.find(k => k.name == r.getString("apikey")) }
+ .map(l => Right(l))
+ }
+ case _ => Left(errors).future
+ }
+ }).flatMap(either => {
+ // FIXME remove this filter to add a legacy flag
+ val clientIds = either.getOrElse(List()).map(_.clientId).filter(clientId => !clientId.contains("_"))
+ if(clientIds.isEmpty) {
+ either.future
+ } else {
+ env.postgresql.queryOne(
+ s"""
+ |INSERT INTO izanami.key_tenant (client_id, tenant) VALUES (unnest($$1::TEXT[]), $$2)
+ |RETURNING tenant
+ |""".stripMargin,
+ List(clientIds.toArray, tenant),
+ conn=Some(connection)
+ ){_ => Some(())}
+ .map(o => o.toRight(Seq(InternalServerError())))
+ .map(e => e.flatMap(_ => either))
+ }
+ })
+ }
+
+ if (apiKeys.isEmpty) {
+ Future.successful(Right(Seq()))
+ } else {
+ conn.map(c => callback(c)).getOrElse(env.postgresql.executeInTransaction(c => callback(c)))
+ }
+ }
+
+ def readApiKeys(tenant: String, username: String): Future[List[ApiKey]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT
+ |a.clientid,
+ |a.name,
+ |a.description,
+ |a.enabled,
+ |a.legacy,
+ |a.admin,
+ |a.clientsecret,
+ |COALESCE(json_agg(ap.project) FILTER (WHERE ap.project IS NOT NULL), '[]') AS projects
+ |FROM apikeys a
+ |LEFT JOIN apikeys_projects ap
+ |ON ap.apikey = a.name
+ |WHERE EXISTS (SELECT u.username FROM izanami.users u WHERE u.username=$$1 AND u.admin=TRUE)
+ |OR EXISTS(SELECT * FROM izanami.users_tenants_rights utr WHERE utr.username=$$1 AND (utr.level='ADMIN'))
+ |OR a.name=ANY(SELECT akr.apikey FROM users_keys_rights akr WHERE akr.username=$$1)
+ |GROUP BY a.name
+ |""".stripMargin,
+ List(username),
+ schemas = Set(tenant)
+ ) { r => r.optApiKeyWithSubObjects(tenant) }
+ }
+
+ def readApiKey(tenant: String, name: String): Future[Option[ApiKey]] = {
+ env.postgresql.queryOne(
+ s"""
+ |SELECT
+ |a.clientid,
+ |a.name,
+ |a.description,
+ |a.enabled,
+ |a.legacy,
+ |a.admin,
+ |a.clientsecret,
+ |COALESCE(json_agg(ap.project) FILTER (WHERE ap.project IS NOT NULL), '[]') AS projects
+ |FROM apikeys a
+ |LEFT JOIN apikeys_projects ap
+ |ON ap.apikey = a.name
+ |WHERE a.name = $$1
+ |GROUP BY a.name
+ |""".stripMargin,
+ List(name),
+ schemas = Set(tenant)
+ ) { r => r.optApiKeyWithSubObjects(tenant) }
+ }
+
+ def deleteApiKey(tenant: String, name: String): Future[Either[IzanamiError, String]] = {
+ env.postgresql.executeInTransaction(conn => {
+ env.postgresql
+ .queryOne(
+ s"""
+ DELETE FROM apikeys WHERE name=$$1 RETURNING clientid
+ |""".stripMargin,
+ List(name),
+ schemas = Set(tenant),
+ conn=Some(conn)
+ ) { row => row.optString("clientid") }
+ .map(o => o.toRight(KeyNotFound(name)))
+ .flatMap {
+ case Left(value) => Left(value).future
+ case Right(clientId) =>
+ env.postgresql.queryRaw(
+ s"DELETE FROM izanami.key_tenant WHERE client_id=$$1",
+ List(clientId),
+ conn=Some(conn)
+ ){_ => Right(clientId)}
+ }
+ })
+ }
+
+ def updateApiKey(tenant: String, oldName: String, newKey: ApiKey): Future[Either[IzanamiError, Unit]] = {
+ env.postgresql.executeInTransaction(
+ conn => {
+ env.postgresql
+ .queryRaw(
+ s"""
+ |DELETE FROM apikeys_projects WHERE apikey = $$1
+ |""".stripMargin,
+ List(oldName),
+ conn = Some(conn)
+ ) { _ => Right(()) }
+ .flatMap(_ => {
+ env.postgresql
+ .queryOne(
+ s"""
+ UPDATE apikeys
+ |SET name=$$1,
+ |description=$$2,
+ |enabled=$$4,
+ |admin=$$5
+ |WHERE name=$$3
+ |RETURNING name
+ |""".stripMargin,
+ List(newKey.name, newKey.description, oldName, java.lang.Boolean.valueOf(newKey.enabled), java.lang.Boolean.valueOf(newKey.admin)),
+ conn = Some(conn)
+ ) { row => row.optString("name") }
+ .map(o => o.toRight(KeyNotFound(oldName)))
+ })
+ .flatMap(_ => {
+ if (newKey.projects.nonEmpty) {
+ env.postgresql.queryRaw(
+ s"""
+ |INSERT INTO apikeys_projects (apikey, project)
+ |SELECT $$1, unnest($$2::text[])
+ |""".stripMargin,
+ List(newKey.name, newKey.projects.toArray),
+ conn = Some(conn)
+ ) { _ => Right(()) }
+ } else {
+ Future.successful(Right(()))
+ }
+ })
+ },
+ schemas = Set(tenant)
+ )
+ }
+
+ def readAndCheckApiKey(
+ clientId: String,
+ clientSecret: String
+ ): Future[Either[IzanamiError, ApiKeyWithCompleteRights]] = {
+ val futureMaybeTenant = ApiKey.extractTenant(clientId) match {
+ case s@Some(tenant) => Future.successful(s)
+ case None => findLegacyKeyTenant(clientId)
+ }
+
+ futureMaybeTenant.flatMap {
+ case None => Future.successful(Left(ApiKeyDoesNotExist(clientId)))
+ case Some(tenant) => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |SELECT
+ |a.clientid,
+ |a.clientsecret,
+ |a.name,
+ |a.description,
+ |a.enabled,
+ |a.legacy,
+ |a.admin,
+ |COALESCE(json_agg(json_build_object('id', p.id, 'name', p.name)) FILTER (WHERE p.id IS NOT NULL), '[]') AS projects
+ |FROM apikeys a
+ |LEFT JOIN apikeys_projects ap ON ap.apikey = a.name
+ |LEFT JOIN projects p ON p.name=ap.project
+ |WHERE a.clientid=$$1
+ |AND a.enabled=true
+ |GROUP BY a.name
+ |""".stripMargin,
+ List(clientId),
+ schemas = Set(tenant)
+ ) { r => {
+ val projects = r
+ .optJsArray("projects")
+ .map(arr =>
+ arr.value
+ .map(v => {
+ for (
+ name <- (v \ "name").asOpt[String];
+ id <- (v \ "id").asOpt[UUID]
+ ) yield ApiKeyProject(name, id)
+ })
+ .toSet
+ )
+ .getOrElse(Set())
+ .filter(_.isDefined)
+ .map(_.get)
+ for (
+ _ <- r.optBoolean("enabled").filter(_ == true);
+ clientSecret <- r.optString("clientsecret");
+ clientid <- r.optString("clientid");
+ enabled <- r.optBoolean("enabled");
+ name <- r.optString("name");
+ legacy <- r.optBoolean("legacy");
+ admin <- r.optBoolean("admin")
+ )
+ yield ApiKeyWithCompleteRights(
+ clientId = clientid,
+ clientSecret=clientSecret,
+ tenant = tenant,
+ name = name,
+ projects = projects,
+ enabled = enabled,
+ legacy=legacy,
+ admin=admin
+ )
+ }
+ }
+ .map(o => o.toRight(KeyNotFound(clientId)))
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case _ => Left(InternalServerError())
+ }
+ }
+ }
+ }
+}
+
+object apiKeyImplicites {
+ implicit class ApiKeyRow(val row: Row) extends AnyVal {
+ def optApiKey(tenant: String): Option[ApiKey] = {
+ for (
+ clientid <- row.optString("clientid");
+ clientsecret <- row.optString("clientsecret");
+ name <- row.optString("name");
+ description <- row.optString("description");
+ enabled <- row.optBoolean("enabled");
+ legacy <- row.optBoolean("legacy");
+ admin <- row.optBoolean("admin")
+ )
+ yield ApiKey(
+ clientId = clientid,
+ clientSecret = clientsecret,
+ tenant = tenant,
+ name = name,
+ description = description,
+ enabled = enabled,
+ legacy = legacy,
+ admin = admin
+ )
+ }
+
+ def optApiKeyWithSubObjects(tenant: String): Option[ApiKey] = {
+ val projects = row.optJsArray("projects").map(arr => arr.value.map(v => v.as[String]).toSet).getOrElse(Set())
+
+ for (
+ clientid <- row.optString("clientid");
+ name <- row.optString("name");
+ description <- row.optString("description");
+ enabled <- row.optBoolean("enabled");
+ legacy <- row.optBoolean("legacy");
+ admin <- row.optBoolean("admin");
+ clientSecret <- row.optString("clientsecret")
+ )
+ yield ApiKey(
+ clientId = clientid,
+ tenant = tenant,
+ name = name,
+ projects = projects,
+ description = description,
+ enabled = enabled,
+ legacy = legacy,
+ admin=admin,
+ clientSecret=clientSecret
+ )
+ }
+ }
+}
diff --git a/app/fr/maif/izanami/datastores/ConfigurationDatastore.scala b/app/fr/maif/izanami/datastores/ConfigurationDatastore.scala
new file mode 100644
index 000000000..2684a19aa
--- /dev/null
+++ b/app/fr/maif/izanami/datastores/ConfigurationDatastore.scala
@@ -0,0 +1,248 @@
+package fr.maif.izanami.datastores
+
+import fr.maif.izanami.datastores.ConfigurationDatastore.{parseDbMailer, parseInvitationMode}
+import fr.maif.izanami.datastores.configurationImplicits.{ConfigurationRow, MailerConfigurationRow}
+import fr.maif.izanami.env.Env
+import fr.maif.izanami.env.pgimplicits.EnhancedRow
+import fr.maif.izanami.errors.{ConfigurationReadError, InternalServerError, IzanamiError}
+import fr.maif.izanami.mail.MailerTypes.MailerType
+import fr.maif.izanami.mail._
+import fr.maif.izanami.models.InvitationMode.InvitationMode
+import fr.maif.izanami.models.IzanamiConfiguration.{SMTPConfigurationReads, SMTPConfigurationWrites, mailGunConfigurationReads, mailJetConfigurationReads}
+import fr.maif.izanami.models.{FullIzanamiConfiguration, InvitationMode, IzanamiConfiguration, OIDCConfiguration}
+import fr.maif.izanami.utils.Datastore
+import io.otoroshi.wasm4s.scaladsl.WasmoSettings
+import io.vertx.sqlclient.Row
+import play.api.libs.json.{JsObject, Json}
+
+import java.time.ZoneOffset
+import java.util.UUID
+import scala.concurrent.Future
+
+class ConfigurationDatastore(val env: Env) extends Datastore {
+
+ def readId(): Future[UUID] = {
+ env.postgresql.queryOne(s"""SELECT izanami_id FROM izanami.configuration"""){r => r.optUUID("izanami_id")}
+ .map(_.get)
+
+ }
+ def readWasmConfiguration(): Option[WasmoSettings] = {
+ for(
+ url <- env.configuration.getOptional[String]("app.wasmo.url");
+ clientId <- env.configuration.getOptional[String]("app.wasmo.client-id");
+ clientSecret <- env.configuration.getOptional[String]("app.wasmo.client-secret")
+ ) yield WasmoSettings(url, clientId, clientSecret = clientSecret)
+ }
+
+ def readOIDCConfiguration(): Option[OIDCConfiguration] = {
+ for(
+ clientId <- env.configuration.getOptional[String]("app.openid.client-id");
+ clientSecret <- env.configuration.getOptional[String]("app.openid.client-secret");
+ authorizeUrl <- env.configuration.getOptional[String]("app.openid.authorize-url");
+ tokenUrl <- env.configuration.getOptional[String]("app.openid.token-url");
+ redirectUrl <- env.configuration.getOptional[String]("app.openid.redirect-url")
+ ) yield OIDCConfiguration(clientId=clientId, clientSecret=clientSecret, authorizeUrl=authorizeUrl, tokenUrl=tokenUrl, redirectUrl=redirectUrl)
+ }
+
+ def readConfiguration(): Future[Either[IzanamiError, IzanamiConfiguration]] = {
+ env.postgresql
+ .queryOne("SELECT mailer, invitation_mode, origin_email, anonymous_reporting, anonymous_reporting_date from izanami.configuration") { row =>
+ {
+ row.optConfiguration()
+ }
+ }
+ .map(o => {
+ o.toRight(ConfigurationReadError())
+ })
+ }
+
+ def readFullConfiguration(): Future[Either[IzanamiError, FullIzanamiConfiguration]] = {
+ env.postgresql
+ .queryOne(s"""
+ |SELECT c.mailer, c.invitation_mode, c.origin_email, c.anonymous_reporting, m.configuration, m.name
+ |FROM izanami.configuration c, izanami.mailers m
+ |WHERE m.name = c.mailer
+ |""".stripMargin) { row =>
+ {
+ for (
+ mailProviderConfig <- row.optMailerConfiguration();
+ invitationMode <- row.optString("invitation_mode");
+ anonymousReporting <- row.optBoolean("anonymous_reporting")
+ )
+ yield FullIzanamiConfiguration(
+ invitationMode = parseInvitationMode(invitationMode),
+ mailConfiguration = mailProviderConfig,
+ originEmail = row.optString("origin_email"),
+ anonymousReporting=anonymousReporting,
+ anonymousReportingLastAsked=row.optOffsetDatetime("anonymous_reporting_date").map(_.toInstant)
+ )
+ }
+ }
+ .map(o => {
+ o.toRight(ConfigurationReadError())
+ })
+ .recover {
+ case _ => {
+ Left(InternalServerError())
+ }
+ }
+ }
+
+ def updateConfiguration(newConfig: IzanamiConfiguration): Future[Option[IzanamiConfiguration]] = {
+ env.postgresql.queryOne(
+ s"""
+ |UPDATE izanami.configuration
+ |SET mailer=$$1, invitation_mode=$$2, origin_email=$$3, anonymous_reporting=$$4, anonymous_reporting_date=$$5
+ |RETURNING *
+ |""".stripMargin,
+ List(newConfig.mailer.toString.toUpperCase, newConfig.invitationMode.toString.toUpperCase, newConfig.originEmail.orNull, java.lang.Boolean.valueOf(newConfig.anonymousReporting), newConfig.anonymousReportingLastAsked.map(_.atOffset(ZoneOffset.UTC)).orNull )
+ ) { row =>
+ row.optConfiguration()
+ }
+ }
+
+ def readMailerConfiguration(mailerType: MailerType): Future[Either[IzanamiError, MailProviderConfiguration]] = {
+ env.postgresql
+ .queryOne(
+ s"""SELECT name, configuration FROM izanami.mailers WHERE name=$$1""",
+ List(mailerType.toString.toUpperCase)
+ ) { row =>
+ row.optMailerConfiguration()
+ }
+ .map(o => {
+ o.toRight(ConfigurationReadError())
+ })
+ }
+
+ def updateMailerConfiguration(
+ mailProviderConfiguration: MailProviderConfiguration
+ ): Future[Either[IzanamiError, MailProviderConfiguration]] = {
+ env.postgresql
+ .queryOne(
+ s"""
+ |UPDATE izanami.mailers
+ |SET configuration=$$1::JSONB
+ |WHERE name=$$2
+ |RETURNING *
+ |""".stripMargin,
+ List(
+ mailProviderConfiguration match {
+ case ConsoleMailProvider => "{}"
+ case MailJetMailProvider(configuration) if configuration.url.isDefined =>
+ Json
+ .obj(
+ "url" -> configuration.url.get,
+ "apiKey" -> configuration.apiKey,
+ "secret" -> configuration.secret
+ )
+ .toString
+ case MailJetMailProvider(configuration) =>
+ Json
+ .obj(
+ "apiKey" -> configuration.apiKey,
+ "secret" -> configuration.secret
+ )
+ .toString
+ case MailGunMailProvider(configuration) if configuration.url.isDefined =>
+ Json
+ .obj(
+ "url" -> configuration.url.get,
+ "apiKey" -> configuration.apiKey,
+ "region" -> configuration.region
+ )
+ .toString
+ case MailGunMailProvider(configuration) =>
+ Json
+ .obj(
+ "apiKey" -> configuration.apiKey,
+ "region" -> configuration.region
+ )
+ .toString
+ case SMTPMailProvider(configuration) =>
+ Json.toJson(configuration).toString
+ },
+ mailProviderConfiguration.mailerType.toString.toUpperCase
+ )
+ ) { row =>
+ row.optMailerConfiguration()
+ }
+ .map(o => {
+ o.toRight(ConfigurationReadError())
+ })
+ .recover {
+ case _ => {
+ Left(InternalServerError())
+ }
+ }
+ }
+}
+
+object ConfigurationDatastore {
+ def parseDbMailer(dbMailer: String): MailerType = {
+ dbMailer match {
+ case "CONSOLE" => MailerTypes.Console
+ case "MAILJET" => MailerTypes.MailJet
+ case "MAILGUN" => MailerTypes.MailGun
+ case "SMTP" => MailerTypes.SMTP
+ case _ => throw new RuntimeException(s"Failed to read Mailer (readed ${dbMailer})")
+ }
+ }
+
+ def parseInvitationMode(mode: String): InvitationMode = {
+ mode match {
+ case "MAIL" => InvitationMode.Mail
+ case "RESPONSE" => InvitationMode.Response
+ case _ => throw new RuntimeException(s"Failed to read Invitation mode (readed ${mode})")
+ }
+ }
+}
+
+object configurationImplicits {
+ implicit class ConfigurationRow(val row: Row) extends AnyVal {
+ def optConfiguration(): Option[IzanamiConfiguration] = {
+ for (
+ mailerStr <- row.optString("mailer");
+ invitationModeStr <- row.optString("invitation_mode");
+ anonymousReporting <- row.optBoolean("anonymous_reporting")
+ )
+ yield IzanamiConfiguration(
+ parseDbMailer(mailerStr),
+ parseInvitationMode(invitationModeStr),
+ originEmail = row.optString("origin_email"),
+ anonymousReporting=anonymousReporting,
+ anonymousReportingLastAsked = row.optOffsetDatetime("anonymous_reporting_date").map(_.toInstant)
+ )
+ }
+ }
+
+ implicit class MailerConfigurationRow(val row: Row) extends AnyVal {
+ def optMailerConfiguration(): Option[MailProviderConfiguration] = {
+ for (
+ name <- row.optString("name");
+ configuration <- row.optJsObject("configuration")
+ ) yield parseDbMailer(name) match {
+ case MailerTypes.MailJet => {
+ MailJetMailProvider(
+ configuration
+ .asOpt[MailJetConfiguration]
+ .getOrElse(MailJetConfiguration(apiKey = null, secret = null, url = None))
+ )
+ }
+ case MailerTypes.MailGun => {
+ MailGunMailProvider(
+ configuration
+ .asOpt[MailGunConfiguration]
+ .getOrElse(MailGunConfiguration(apiKey = null, url = None))
+ )
+ }
+ case MailerTypes.SMTP => {
+ SMTPMailProvider(
+ configuration.asOpt[SMTPConfiguration]
+ .getOrElse(SMTPConfiguration(null, None, None, None, false, false, false))
+ )
+ }
+ case MailerTypes.Console => ConsoleMailProvider
+ }
+ }
+ }
+}
diff --git a/app/fr/maif/izanami/datastores/FeatureContextDatastore.scala b/app/fr/maif/izanami/datastores/FeatureContextDatastore.scala
new file mode 100644
index 000000000..4a7770a64
--- /dev/null
+++ b/app/fr/maif/izanami/datastores/FeatureContextDatastore.scala
@@ -0,0 +1,529 @@
+package fr.maif.izanami.datastores
+
+import fr.maif.izanami.datastores.FeatureContextDatastore.FeatureContextRow
+import fr.maif.izanami.env.Env
+import fr.maif.izanami.env.PostgresqlErrors.{FOREIGN_KEY_VIOLATION, RELATION_DOES_NOT_EXISTS, UNIQUE_VIOLATION}
+import fr.maif.izanami.env.pgimplicits.EnhancedRow
+import fr.maif.izanami.errors._
+import fr.maif.izanami.models.Feature.{activationConditionRead, activationConditionWrite}
+import fr.maif.izanami.models.FeatureContext.generateSubContextId
+import fr.maif.izanami.models._
+import fr.maif.izanami.utils.Datastore
+import fr.maif.izanami.utils.syntax.implicits.BetterSyntax
+import fr.maif.izanami.wasm.WasmConfig
+import io.otoroshi.wasm4s.scaladsl.WasmSourceKind
+import io.vertx.core.json.JsonArray
+import io.vertx.pgclient.PgException
+import io.vertx.sqlclient.Row
+import play.api.libs.json.Json
+
+import java.util.Objects
+import scala.concurrent.Future
+
+class FeatureContextDatastore(val env: Env) extends Datastore {
+ def deleteGlobalFeatureContext(tenant: String, path: Seq[String]): Future[Either[IzanamiError, Unit]] = {
+ val ctxName = path.last
+ val parentPart = path.init
+ env.postgresql.executeInTransaction(conn => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |DELETE FROM global_feature_contexts
+ |WHERE id=$$1
+ |RETURNING *
+ |""".stripMargin,
+ List(generateSubContextId(tenant, path)),
+ schemas = Set(tenant),
+ conn=Some(conn)
+ ) { r => Some(()) }
+ .map(_.toRight(FeatureContextDoesNotExist(path.mkString("/"))))
+ .flatMap {
+ case Left(value) => Left(value).future
+ case Right(value) => env.postgresql.queryRaw(
+ s"""DELETE FROM feature_context_name_unicity_check_table WHERE parent = $$1 AND context=$$2""",
+ List(if(parentPart.isEmpty) "" else generateSubContextId(tenant, parentPart), ctxName),
+ conn=Some(conn)
+ ){r => Some(())}
+ .map(_ => Right(()))
+ }
+ })
+ }
+
+ def createGlobalFeatureContext(
+ tenant: String,
+ parents: Seq[String],
+ featureContext: FeatureContext
+ ): Future[Either[IzanamiError, FeatureContext]] = {
+ val id = generateSubContextId(tenant, featureContext.name, parents)
+ val parentId = if (parents.isEmpty) null else generateSubContextId(tenant, parents)
+
+ env.postgresql.executeInTransaction(conn => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO global_feature_contexts (id, name, parent)
+ |VALUES ($$1, $$2, $$3)
+ |RETURNING *
+ |""".stripMargin,
+ List(id, featureContext.name, parentId),
+ schemas = Set(tenant),
+ conn = Some(conn)
+ ) { row => row.optFeatureContext(global = true) }
+ .map(o => o.toRight(InternalServerError()))
+ .flatMap {
+ case Left(value) => Left(value).future
+ case Right(ctx) => env.postgresql.queryOne(
+ s"""
+ |INSERT INTO feature_context_name_unicity_check_table (parent, context) VALUES ($$1, $$2) RETURNING context
+ |""".stripMargin,
+ List(if(Objects.isNull(parentId)) "" else parentId, featureContext.name),
+ conn = Some(conn)
+ ) { r => Some(ctx) }
+ .map(o => o.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == UNIQUE_VIOLATION =>
+ Left(ConflictWithSameNameLocalContext(name = featureContext.name, parentCtx = parents.mkString("/")))
+ case _ =>
+ Left(InternalServerError())
+ }
+ }
+ })
+
+ }
+
+ // TODO merge with createFeatureSubContext ?
+ def createFeatureContext(
+ tenant: String,
+ project: String,
+ featureContext: FeatureContext
+ ): Future[Either[IzanamiError, FeatureContext]] = {
+ val id = generateSubContextId(project, featureContext.name)
+ env.postgresql.executeInTransaction(conn => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO feature_contexts (id, name, project)
+ |VALUES ($$1, $$2, $$3)
+ |RETURNING *
+ |""".stripMargin,
+ List(id, featureContext.name, project),
+ schemas = Set(tenant),
+ conn=Some(conn)
+ ) { row => row.optFeatureContext(global = false) }
+ .map(o => o.toRight(InternalServerError()))
+ .flatMap {
+ case Left(value) => Left(value).future
+ case Right(ctx) => {
+ env.postgresql.queryOne(
+ s"""
+ |INSERT INTO feature_context_name_unicity_check_table (parent, context) VALUES ($$1, $$2) RETURNING context
+ |""".stripMargin,
+ List("", featureContext.name),
+ conn = Some(conn)
+ ) { _ => Some(ctx) }
+ .map(o => o.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == UNIQUE_VIOLATION =>
+ Left(ConflictWithSameNameGlobalContext(name = featureContext.name))
+ case _ =>
+ Left(InternalServerError())
+ }
+ }
+ }
+
+
+ })
+
+ }
+
+ def createFeatureSubContext(
+ tenant: String,
+ project: String,
+ parents: Seq[String],
+ name: String
+ ): Future[Either[IzanamiError, FeatureContext]] = {
+ if(parents.isEmpty) {
+ createFeatureContext(tenant, project, FeatureContext(id=null, name, global=true))
+ } else {
+ val id = generateSubContextId(project, name, parents)
+ val isLocal = env.postgresql
+ .queryOne(
+ s"""SELECT id FROM feature_contexts WHERE id=$$1""",
+ List(generateSubContextId(project, parents)),
+ schemas = Set(tenant)
+ ) { r =>
+ Some(())
+ }
+ .map(o => o.fold(false)(_ => true))
+
+ isLocal.flatMap(local => {
+ val parentId =
+ if (parents.isEmpty) null
+ else if (local) generateSubContextId(project, parents)
+ else generateSubContextId(tenant, parents)
+ env.postgresql.executeInTransaction(conn => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO feature_contexts (id, name, project, ${if (local) "parent" else "global_parent"})
+ |VALUES ($$1, $$2, $$3, $$4)
+ |RETURNING *
+ |""".stripMargin,
+ List(id, name, project, parentId),
+ conn = Some(conn)
+ ) { row => row.optFeatureContext(global = false) }
+ .map(o => o.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION =>
+ Left(FeatureContextDoesNotExist(parents.mkString("/")))
+ case ex =>
+ logger.error("Failed to user", ex)
+ Left(InternalServerError())
+ }
+ .flatMap {
+ case Left(error) => Left(error).future
+ case Right(ctx) if !local => {
+ env.postgresql.queryOne(
+ s"""
+ |INSERT INTO feature_context_name_unicity_check_table (parent, context) VALUES ($$1, $$2) RETURNING context
+ |""".stripMargin,
+ List(parentId, name),
+ conn=Some(conn)
+ ){_ => Some(ctx) }
+ .map(o => o.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == UNIQUE_VIOLATION =>
+ Left(ConflictWithSameNameGlobalContext(name=name, parentCtx=parents.mkString("/")))
+ case _ =>
+ Left(InternalServerError())
+ }
+ }
+ case Right(ctx) => Right(ctx).future
+ }
+ }, schemas = Set(tenant))
+ })
+ }
+ }
+
+ def readStrategyForContext(
+ tenant: String,
+ featureContext: Seq[String],
+ feature: AbstractFeature
+ ): Future[Option[ContextualFeatureStrategy]] = {
+ val possibleContextPaths = featureContext.foldLeft(Seq(): Seq[Seq[String]])((acc, next) => {
+ val newElement = acc.lastOption.map(last => last.appended(next)).getOrElse(Seq(next))
+ acc.appended(newElement)
+ })
+
+ val possibleContextIds = possibleContextPaths.map(path => {
+ generateSubContextId(feature.project, path.last, path.dropRight(1))
+ }).concat(possibleContextPaths.map(path => {
+ generateSubContextId(tenant, path.last, path.dropRight(1))
+ }))
+
+ env.postgresql.queryOne(
+ s"""
+ |SELECT gf.conditions, gf.enabled, ws.config
+ |FROM feature_contexts_strategies gf
+ |LEFT OUTER JOIN wasm_script_configurations ws ON gf.script_config=ws.id
+ |WHERE gf.project = $$1
+ |AND gf.feature = $$2
+ |AND gf.context=ANY($$3)
+ |ORDER BY length(gf.context) desc
+ |limit 1
+ |""".stripMargin,
+ List(feature.project, feature.name, possibleContextIds.toArray),
+ schemas=Set(tenant)
+ ) { row =>
+ {
+ row.optStrategy(feature.name)
+ }
+ }
+ }
+
+ def readGlobalFeatureContexts(tenant: String): Future[Seq[FeatureContext]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT c.name, c.parent, c.id, NULL as project, COALESCE(
+ | json_agg(json_build_object('feature', s.feature, 'enabled', s.enabled, 'conditions', s.conditions, 'id', f.id, 'project', f.project, 'description', f.description , 'wasm', w.config)) FILTER (WHERE s.feature IS NOT NULL) , '[]'
+ |) as overloads
+ |FROM global_feature_contexts c
+ |LEFT JOIN feature_contexts_strategies s ON s.global_context=c.id
+ |LEFT JOIN features f ON f.name=s.feature
+ |LEFT JOIN wasm_script_configurations w ON w.id=s.script_config
+ |GROUP BY (c.name, c.parent, c.id)
+ |""".stripMargin,
+ List(),
+ schemas=Set(tenant)
+ ) { row => row.optFeatureContext(global=true) }
+ }
+
+ def readAllLocalFeatureContexts(tenant: String): Future[Seq[FeatureContext]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT name, parent, id, true as global, null as project
+ |FROM global_feature_contexts
+ |UNION ALL
+ |SELECT name, parent, id, false as global, project
+ |FROM feature_contexts
+ |""".stripMargin,
+ schemas = Set(tenant))
+ {r =>
+ for(
+ id <- r.optString("id");
+ name <- r.optString("name");
+ global <- r.optBoolean("global")
+ ) yield FeatureContext(id, name, r.optString("parent").orNull, global=global, project=r.optString("project"))
+ }
+ }
+
+ def readFeatureContexts(tenant: String, project: String): Future[Seq[FeatureContext]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT c.name, COALESCE(c.parent, c.global_parent) as parent, c.id, c.project, COALESCE(
+ | json_agg(json_build_object('feature', s.feature, 'enabled', s.enabled, 'conditions', s.conditions, 'id', f.id, 'description', f.description, 'project', f.project, 'wasm', w.config)) FILTER (WHERE s.feature IS NOT NULL) , '[]'
+ |) as overloads
+ |FROM feature_contexts c
+ |LEFT JOIN feature_contexts_strategies s ON s.context=c.id
+ |LEFT JOIN features f ON f.name=s.feature
+ |LEFT JOIN wasm_script_configurations w ON w.id=s.script_config
+ |WHERE c.project=$$1
+ |GROUP BY (c.name, parent, c.id, c.project)
+ |UNION ALL
+ |SELECT c.name, c.parent, c.id, NULL as project, COALESCE(
+ | json_agg(json_build_object('feature', s.feature, 'enabled', s.enabled, 'conditions', s.conditions, 'id', f.id, 'description', f.description, 'project', f.project, 'wasm', w.config)) FILTER (WHERE s.feature IS NOT NULL) , '[]'
+ |) as overloads
+ |FROM global_feature_contexts c
+ |LEFT JOIN feature_contexts_strategies s ON s.global_context=c.id
+ |LEFT JOIN features f ON f.name=s.feature
+ |LEFT JOIN wasm_script_configurations w ON w.id=s.script_config
+ |GROUP BY (c.name, c.parent, c.id)
+ |""".stripMargin,
+ List(project),
+ schemas=Set(tenant)
+ ) { row => row.optFeatureContext(global=row.optString("project").isEmpty) }
+ }
+
+ def deleteContext(tenant: String, project: String, path: Seq[String]): Future[Either[IzanamiError, Unit]] = {
+ val ctxName = path.last
+ val parentPart = path.init
+ env.postgresql.executeInTransaction(conn => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |DELETE FROM feature_contexts
+ |WHERE id=$$1
+ |RETURNING *
+ |""".stripMargin,
+ List(generateSubContextId(project, path)),
+ schemas = Set(tenant),
+ conn=Some(conn)
+ ) { r => Some(()) }
+ .map(_.toRight(FeatureContextDoesNotExist(path.mkString("/"))))
+ .flatMap {
+ case Left(value) => Left(value).future
+ case Right(value) => {
+ env.postgresql.queryRaw(
+ s"""DELETE FROM feature_context_name_unicity_check_table WHERE parent = $$1 AND context=$$2""",
+ List(if (parentPart.isEmpty) "" else generateSubContextId(project, parentPart), ctxName),
+ conn = Some(conn)
+ ){_ => Some(())}
+ .map(_ => Right(()))
+ }
+ }
+ })
+ }
+
+ def deleteFeatureStrategy(
+ tenant: String,
+ project: String,
+ path: Seq[String],
+ feature: String
+ ): Future[Either[IzanamiError, Unit]] = {
+ val isLocal = env.postgresql
+ .queryOne(
+ s"""SELECT id FROM feature_contexts WHERE id=$$1""",
+ List(generateSubContextId(project, path)),
+ schemas=Set(tenant)
+ ) { r =>
+ Some(())
+ }
+ .map(o => o.fold(false)(_ => true))
+ isLocal.flatMap(local =>
+ env.postgresql
+ .queryOne(
+ s"""
+ |DELETE FROM feature_contexts_strategies
+ |WHERE project=$$1 AND context=$$2 AND feature=$$3
+ |RETURNING feature
+ |""".stripMargin,
+ List(project, if(local)generateSubContextId(project, path) else generateSubContextId(tenant, path), feature),
+ schemas=Set(tenant)
+ ) { r => Some(()) }
+ .map(_.toRight(FeatureOverloadDoesNotExist(project, path.mkString("/"), feature)))
+ )
+ }
+
+ def updateFeatureStrategy(
+ tenant: String,
+ project: String,
+ path: Seq[String],
+ feature: String,
+ strategy: ContextualFeatureStrategy
+ ): Future[Either[IzanamiError, Unit]] = {
+ // TODO factorize this
+ val isLocal = env.postgresql
+ .queryOne(
+ s"""SELECT id FROM feature_contexts WHERE id=$$1""",
+ List(generateSubContextId(project, path)),
+ schemas=Set(tenant)
+ ) { r =>
+ Some(())
+ }
+ .map(o => o.fold(false)(_ => true))
+ isLocal.flatMap(local =>
+ strategy match {
+ case ClassicalFeatureStrategy(enabled, conditions, _) =>
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO feature_contexts_strategies (project, ${if (local) "local_context"
+ else "global_context"}, conditions, enabled, feature) VALUES($$1,$$2,$$3,$$4,$$5)
+ |ON CONFLICT(project, context, feature) DO UPDATE
+ |SET conditions=EXCLUDED.conditions, enabled=EXCLUDED.enabled, script_config=NULL
+ |RETURNING 1
+ |""".stripMargin,
+ List(
+ project,
+ if (local) generateSubContextId(project, path.last, path.dropRight(1))
+ else generateSubContextId(tenant, path.last, path.dropRight(1)),
+ new JsonArray(Json.toJson(conditions).toString()),
+ java.lang.Boolean.valueOf(enabled),
+ feature
+ ),
+ schemas=Set(tenant)
+ ) { _ => Some(()) }
+ .map(u => u.toRight(ProjectOrFeatureDoesNotExists(project, feature)))
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION =>
+ Left(FeatureContextDoesNotExist(path.mkString("/")))
+ case _ => Left(InternalServerError())
+ }
+ case WasmFeatureStrategy(enabled, wasmConfig, feature) =>
+ env.postgresql.executeInTransaction(conn => {
+ val maybeWasmScriptQuery = if (wasmConfig.source.kind != WasmSourceKind.Local) {
+ env.datastores.features.createWasmScriptIfNeeded(tenant, wasmConfig, Some(conn))
+ } else {
+ Right(wasmConfig.name).future
+ }
+ maybeWasmScriptQuery
+ .flatMap {
+ case Left(err) => Left(err).future
+ case Right(id) => {
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO feature_contexts_strategies (project, ${if (local) "local_context"
+ else "global_context"}, script_config, enabled, feature) VALUES($$1,$$2,$$3,$$4,$$5)
+ |ON CONFLICT(project, context, feature) DO UPDATE
+ |SET script_config=EXCLUDED.script_config, enabled=EXCLUDED.enabled, conditions=NULL
+ |RETURNING 1
+ |""".stripMargin,
+ List(
+ project,
+ if (local) generateSubContextId(project, path.last, path.dropRight(1))
+ else generateSubContextId(tenant, path.last, path.dropRight(1)),
+ id,
+ java.lang.Boolean.valueOf(enabled),
+ feature
+ ),
+ schemas=Set(tenant),
+ conn=Some(conn)
+ ) { _ => Some(()) }
+ .map(o => o.toRight(InternalServerError()))
+ }
+ }
+ }, schemas = Set(tenant))
+ }
+ )
+
+ }
+}
+
+object FeatureContextDatastore {
+ implicit class FeatureContextRow(val row: Row) extends AnyVal {
+ def optFeatureContext(global: Boolean): Option[FeatureContext] = {
+
+ val features = row
+ .optJsArray("overloads")
+ .toSeq
+ .flatMap(array =>
+ array.value.flatMap(jsObject => {
+ val maybeConditions = (jsObject \ "conditions").asOpt[Set[ActivationCondition]]
+ val maybeScriptConfig = (jsObject \ "wasm").asOpt(WasmConfig.format)
+
+ for (
+ name <- (jsObject \ "feature").asOpt[String];
+ enabled <- (jsObject \ "enabled").asOpt[Boolean];
+ id <- (jsObject \ "id").asOpt[String];
+ description <- (jsObject \ "description").asOpt[String];
+ project <- (jsObject \ "project").asOpt[String]
+ )
+ yield {
+ (maybeScriptConfig, maybeConditions) match {
+ case (Some(wasmConfig), _) =>
+ Some(WasmFeature(
+ name = name,
+ enabled = enabled,
+ id = id,
+ project = project,
+ wasmConfig = wasmConfig,
+ description=description
+ ))
+ case (None, Some(conditions)) =>
+ Some(Feature(
+ name = name,
+ enabled = enabled,
+ id = id,
+ project = project,
+ conditions = conditions,
+ description=description
+ ))
+ case _ => None
+ }
+ }.toSeq
+ })
+ )
+ .flatMap(o => o.toSeq)
+ Some(
+ FeatureContext(
+ id = row.getString("id"),
+ name = row.getString("name"),
+ parent = row.getString("parent"),
+ project=if(global) None else row.optString("project"),
+ overloads = features,
+ global= global
+ )
+ )
+ }
+
+ def optStrategy(feature: String): Option[ContextualFeatureStrategy] = {
+ val maybeConditions = row
+ .optJsArray("conditions")
+ .map(arr => arr.value.map(v => v.as[ActivationCondition]).toSet)
+ .getOrElse(Set.empty)
+ val maybeConfig = row.optJsObject("config").flatMap(obj => obj.asOpt(WasmConfig.format))
+
+ row
+ .optBoolean("enabled")
+ .map(enabled => {
+ (maybeConfig, maybeConditions) match {
+ case (Some(config), _) => WasmFeatureStrategy(enabled, config, feature)
+ case (_, conditions) => ClassicalFeatureStrategy(enabled, conditions, feature)
+ }
+ })
+ }
+ }
+
+}
diff --git a/app/fr/maif/izanami/datastores/FeaturesDatastore.scala b/app/fr/maif/izanami/datastores/FeaturesDatastore.scala
new file mode 100644
index 000000000..01c2967ea
--- /dev/null
+++ b/app/fr/maif/izanami/datastores/FeaturesDatastore.scala
@@ -0,0 +1,1418 @@
+package fr.maif.izanami.datastores
+
+import fr.maif.izanami.datastores.featureImplicits.FeatureRow
+import fr.maif.izanami.env.Env
+import fr.maif.izanami.env.PostgresqlErrors.{
+ FOREIGN_KEY_VIOLATION,
+ NOT_NULL_VIOLATION,
+ RELATION_DOES_NOT_EXISTS,
+ UNIQUE_VIOLATION
+}
+import fr.maif.izanami.env.pgimplicits.EnhancedRow
+import fr.maif.izanami.errors._
+import fr.maif.izanami.models.Feature.{
+ activationConditionRead,
+ activationConditionWrite,
+ legacyActivationConditionRead,
+ legacyCompatibleConditionWrites
+}
+import fr.maif.izanami.models._
+import fr.maif.izanami.utils.Datastore
+import fr.maif.izanami.utils.syntax.implicits.{BetterJsValue, BetterListEither, BetterSyntax}
+import fr.maif.izanami.v1.V1FeatureEvents
+import fr.maif.izanami.wasm.{WasmConfig, WasmConfigWithFeatures, WasmScriptAssociatedFeatures}
+import fr.maif.izanami.web.ImportController.{Fail, ImportConflictStrategy, MergeOverwrite, Skip}
+import io.otoroshi.wasm4s.scaladsl.WasmSourceKind
+import io.vertx.core.json.{JsonArray, JsonObject}
+import io.vertx.core.shareddata.ClusterSerializable
+import io.vertx.pgclient.PgException
+import io.vertx.sqlclient.{Row, SqlConnection}
+import org.postgresql.xml.LegacyInsecurePGXmlFactoryFactory
+import play.api.libs.json.{JsObject, JsValue, Json}
+
+import java.lang
+import java.util.UUID
+import scala.collection.immutable
+import scala.collection.mutable.ArrayBuffer
+import scala.concurrent.Future
+import scala.reflect.ClassTag
+
+sealed trait EventType
+
+case object FeatureCreated extends EventType {
+ override def toString = "FEATURE_CREATED"
+}
+case object FeatureDeleted extends EventType {
+ override def toString = "FEATURE_DELETED"
+}
+case object FeatureUpdated extends EventType {
+ override def toString = "FEATURE_UPDATED"
+}
+
+class FeaturesDatastore(val env: Env) extends Datastore {
+
+ def emitEvent(
+ tenant: String,
+ id: String,
+ eventType: EventType,
+ sourceProject: String,
+ targetProject: Option[String] = None,
+ conn: SqlConnection
+ ): Future[Unit] = {
+ val payload = Json
+ .obj(
+ "id" -> id,
+ "type" -> eventType.toString,
+ "project" -> sourceProject
+ )
+ .applyOnWithOpt(targetProject)((json, project) => json ++ Json.obj("newProject" -> project))
+ env.postgresql
+ .queryOne(
+ s"""SELECT pg_notify($$1, $$2)""",
+ List(s"$tenant-features", payload.toString),
+ conn = Some(conn)
+ ) { r => Some(()) }
+ .map(_ => ())
+ }
+
+ def findFeatureMatching(
+ tenant: String,
+ pattern: String,
+ clientId: String,
+ count: Int,
+ page: Int
+ ): Future[(Int, Seq[AbstractFeature])] = {
+ val countQuery = env.postgresql.queryOne(
+ s"""
+ |select count(f.id) as count
+ |from features f
+ |left join apikeys a on a.clientid=$$1
+ |left join apikeys_projects ap on (ap.project=f.project and ap.apikey=a.name)
+ |where f.id LIKE $$2
+ |and (f.conditions is null or f.conditions is json object)
+ |and (ap.project is not null or a.admin=true)
+ |""".stripMargin,
+ List(clientId, pattern.replaceAll("\\*", "%")),
+ schemas = Set(tenant)
+ ) { r => r.optInt("count") }
+
+ val dataQuery = env.postgresql.queryAll(
+ s"""select f.*, s.config AS wasm, COALESCE(json_agg(ft.tag) FILTER (WHERE ft.tag IS NOT NULL), '[]') AS tags
+ |from features f
+ |left join features_tags ft
+ |on ft.feature = f.id
+ |left join wasm_script_configurations s
+ |on s.id = f.script_config
+ |left join apikeys a on a.clientid=$$1
+ |left join apikeys_projects ap on (ap.project=f.project and ap.apikey=a.name)
+ |where f.id LIKE $$2
+ |and (f.conditions is null or f.conditions is json object)
+ |and (ap.project is not null or a.admin=true)
+ |group by f.id, wasm
+ |order by f.id
+ |limit $$3
+ |offset $$4""".stripMargin,
+ List(clientId, pattern.replaceAll("\\*", "%"), Integer.valueOf(count), Integer.valueOf((page - 1) * count)),
+ schemas = Set(tenant)
+ ) { r => r.optFeature() }
+
+ for (
+ count <- countQuery;
+ features <- dataQuery
+ ) yield {
+ (count.getOrElse(features.size), features)
+ }
+ }
+
+ def applyPatch(tenant: String, operations: Seq[FeaturePatch]): Future[Unit] = {
+ env.postgresql.executeInTransaction(
+ conn => {
+ val eventualId: Future[Unit] = Future
+ .sequence(operations.map {
+ case EnabledFeaturePatch(value, id) => {
+ env.postgresql
+ .queryOne(
+ s"""UPDATE features SET enabled=$$1 WHERE id=$$2 RETURNING id, name, project, enabled""",
+ List(java.lang.Boolean.valueOf(value), id),
+ conn = Some(conn)
+ ) { r =>
+ for (
+ id <- r.optString("id");
+ name <- r.optString("name");
+ project <- r.optString("project");
+ enabled <- r.optBoolean("enabled")
+ ) yield (id, name, project, enabled)
+ }
+ .flatMap {
+ case Some((id, name, project, enabled)) =>
+ emitEvent(
+ tenant,
+ id = id,
+ eventType = FeatureUpdated,
+ sourceProject = project,
+ conn = conn
+ )
+ case None => Future.successful(())
+ }
+ }
+ case RemoveFeaturePatch(id) => {
+ env.postgresql
+ .queryOne(
+ s"""DELETE FROM features WHERE id=$$1 RETURNING id, name, project, enabled""",
+ List(id),
+ conn = Some(conn)
+ ) { r =>
+ for (
+ id <- r.optString("id");
+ name <- r.optString("name");
+ project <- r.optString("project");
+ enabled <- r.optBoolean("enabled")
+ ) yield (id, name, project, enabled)
+ }
+ .flatMap {
+ case Some((id, name, project, enabled)) =>
+ emitEvent(
+ tenant,
+ id = id,
+ eventType = FeatureDeleted,
+ sourceProject = project,
+ conn = conn
+ )
+ case None => Future.successful(())
+ }
+ }
+ })
+ .map(_ => ())
+ eventualId
+ },
+ schemas = Set(tenant)
+ )
+ }
+
+ def findByIdForKey(
+ tenant: String,
+ id: String,
+ contexts: Seq[String],
+ clientId: String,
+ clientSecret: String
+ ): Future[Option[AbstractFeature]] = {
+ val possibleContextPaths = contexts
+ .foldLeft(Seq(): Seq[Seq[String]])((acc, next) => {
+ val newElement = acc.lastOption.map(last => last.appended(next)).getOrElse(Seq(next))
+ acc.appended(newElement)
+ })
+ .map(_.mkString("_"))
+ val needContexts = contexts.nonEmpty
+ val params = if (needContexts) List(clientId, id, possibleContextPaths.toArray) else List(clientId, id)
+
+ env.postgresql
+ .queryAll(
+ s"""
+ |SELECT
+ | k.clientsecret,
+ | ${if (needContexts) s"fcs.context_path," else "null as context_path,"}
+ | json_build_object(
+ | 'name', f.name,
+ | 'project', f.project,
+ | 'description', f.description,
+ | 'id', f.id)::jsonb ||
+ | ${if (needContexts) s"""(CASE
+ | WHEN fcs.enabled IS NOT NULL THEN
+ | json_build_object(
+ | 'enabled', fcs.enabled,
+ | 'config', ow.config,
+ | 'conditions', fcs.conditions
+ | )::jsonb
+ | ELSE""" else ""}
+ | json_build_object(
+ | 'enabled', f.enabled,
+ | 'config', w.config,
+ | 'conditions', f.conditions
+ | )::jsonb
+ | ${if (needContexts) s"END)" else ""} as feature
+ |FROM features f
+ |${if (needContexts)
+ s"LEFT JOIN feature_contexts_strategies fcs ON fcs.feature=f.name AND fcs.context_path = ANY($$3) LEFT JOIN wasm_script_configurations ow ON fcs.script_config=ow.id"
+ else ""}
+ |INNER JOIN apikeys k ON (k.clientid=$$1 AND k.enabled=true)
+ |LEFT JOIN wasm_script_configurations w ON w.id=f.script_config
+ |LEFT JOIN apikeys_projects kp ON (kp.apikey=k.name AND kp.project=f.project)
+ |WHERE f.id=$$2
+ |AND (kp.apikey IS NOT NULL OR k.admin=TRUE)
+ |""".stripMargin,
+ params,
+ schemas = Set(tenant)
+ ) { r =>
+ {
+ for (
+ _ <- r.optString("clientsecret")
+ .filter(hashed => clientSecret == hashed); // TODO put this check in the above query
+ jsonFeature <- r.optJsObject("feature");
+ js <- (jsonFeature \ "config")
+ .asOpt[JsValue]
+ .map(js => jsonFeature.as[JsObject] + ("wasmConfig" -> js))
+ .orElse(Some(jsonFeature));
+ feature <- Feature.readFeature(js).asOpt
+ ) yield (r.optString("context_path"), feature)
+ }
+ }
+ .map(ls =>
+ ls.sortWith((f1, f2) => {
+ (f1, f2) match {
+ case ((None, _), _) => false
+ case (_, (None, _)) => true
+ case ((Some(ctx1), _), (Some(ctx2), _)) if ctx1.length > ctx2.length => true
+ case _ => false
+ }
+ }).headOption
+ .map(t => t._2)
+ )
+ }
+
+ def searchFeature(tenant: String, tags: Set[String]): Future[Seq[AbstractFeature]] = {
+ val hasTags = tags.nonEmpty
+ env.postgresql
+ .queryOne(
+ s"""
+ |select COALESCE(
+ | json_agg(row_to_json(f.*)::jsonb
+ | || (json_build_object('tags', (
+ | array(
+ | SELECT ft.tag
+ | FROM features_tags ft
+ | WHERE ft.feature = f.id
+ | GROUP BY ft.tag
+ | )
+ | ), 'wasmConfig', (
+ | select w.config FROM wasm_script_configurations w where w.id = f.script_config
+ | )))::jsonb)
+ | FILTER (WHERE f.id IS NOT NULL), '[]'
+ |) as "features"
+ |from features f${if (hasTags) {
+ s""", features_tags ft
+ |WHERE ft.feature = f.id
+ |AND ft.tag = ANY($$1)"""
+ } else ""}
+ |""".stripMargin,
+ if (hasTags) List(tags.toArray) else List(),
+ schemas = Set(tenant)
+ ) { r =>
+ r.optJsArray("features")
+ .map(arr => arr.value.toSeq.map(js => Feature.readFeature(js).asOpt).flatMap(_.toSeq))
+ }
+ .map(o => o.getOrElse(Seq()))
+ }
+
+ def readScriptConfig(tenant: String, path: String): Future[Option[WasmConfig]] = {
+ env.postgresql
+ .queryOne(
+ s"""
+ |SELECT config
+ |FROM wasm_script_configurations
+ |WHERE config #>> '{source,path}' = $$1
+ |""".stripMargin,
+ List(path),
+ schemas = Set(tenant)
+ ) { row => { row.optJsObject("config") } }
+ .map(o => o.map(jsObj => jsObj.as[WasmConfig](WasmConfig.format)))
+ }
+
+ def findFeaturesProjects(tenant: String, ids: Set[String]): Future[Seq[String]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT DISTINCT project FROM features WHERE id=ANY($$1)
+ |""".stripMargin,
+ List(ids.toArray),
+ schemas = Set(tenant)
+ ) { r => r.optString("project") }
+ }
+
+ def findById(tenant: String, id: String): Future[Either[IzanamiError, Option[AbstractFeature]]] = {
+ env.postgresql
+ .queryOne(
+ s"""select f.*, s.config AS wasm, COALESCE(json_agg(ft.tag) FILTER (WHERE ft.tag IS NOT NULL), '[]') AS tags
+ |from features f
+ |left join features_tags ft
+ |on ft.feature = f.id
+ |left join wasm_script_configurations s
+ |on s.id = f.script_config
+ |where f.id = $$1
+ |group by f.id, wasm""".stripMargin,
+ List(id),
+ schemas = Set(tenant)
+ ) { row => row.optFeature() }
+ .map(o => Right(o))
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case _ => Left(InternalServerError())
+ }
+ }
+
+ def findByIdForKeyWithoutCheck(
+ tenant: String,
+ id: String,
+ clientId: String
+ ): Future[Either[IzanamiError, Option[AbstractFeature]]] = {
+ env.postgresql
+ .queryOne(
+ s"""select (ap.project IS NOT NULL OR k.admin=TRUE) AS authorized, f.*, s.config AS wasm, COALESCE(json_agg(ft.tag) FILTER (WHERE ft.tag IS NOT NULL), '[]') AS tags
+ |from features f
+ |left join features_tags ft
+ |on ft.feature = f.id
+ |left join wasm_script_configurations s
+ |on s.id = f.script_config
+ |inner join apikeys k
+ |on k.clientid=$$2
+ |left join apikeys_projects ap
+ |on (ap.apikey=k.name AND ap.project=f.project)
+ |where f.id = $$1
+ |group by f.id, k.admin, wasm, ap.project""".stripMargin,
+ List(id, clientId),
+ schemas = Set(tenant)
+ ) { row =>
+ {
+ row
+ .optBoolean("authorized")
+ .map(authorized => {
+ if (authorized) {
+ row.optFeature().toRight(InternalServerError())
+ } else {
+ Left(NotEnoughRights())
+ }
+ })
+ }
+ }
+ .map {
+ case Some(Right(feature)) => Right(Some(feature))
+ case Some(Left(error)) => Left(error)
+ case None => Right(None)
+ }
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case _ => Left(InternalServerError())
+ }
+ }
+
+ case class FeatureWithOverloads(feature: AbstractFeature, overloads: Map[String, ContextualFeatureStrategy])
+
+ def doFindByRequestForKey(
+ tenant: String,
+ request: FeatureRequest,
+ clientId: String,
+ clientSecret: String,
+ conditions: Boolean
+ ): Future[Either[IzanamiError, Map[UUID, Map[String, Iterable[(Option[String], AbstractFeature)]]]]] = {
+ val possibleContextPaths = request.context
+ .foldLeft(Seq(): Seq[Seq[String]])((acc, next) => {
+ val newElement = acc.lastOption.map(last => last.appended(next)).getOrElse(Seq(next))
+ acc.appended(newElement)
+ })
+ .map(_.mkString("_"))
+
+ val needTags = request.allTagsIn.nonEmpty || request.noTagIn.nonEmpty || request.oneTagIn.nonEmpty;
+ val needContexts = request.context.nonEmpty || conditions
+
+ val params = if (needContexts && !conditions) {
+ List(clientId, clientSecret, request.projects.toArray, request.features.toArray, possibleContextPaths.toArray)
+ } else {
+ List(clientId, clientSecret, request.projects.toArray, request.features.toArray)
+ }
+
+ env.postgresql
+ .queryAll(
+ s"""
+ |SELECT
+ | f.id,
+ | p.id as pid,
+ | f.enabled,
+ | f.name,
+ | f.project,
+ | f.conditions,
+ | f.description,
+ | f.script_config,
+ | f.metadata,
+ | w.config as wasm
+ | ${if (needContexts) """,
+ | COALESCE(json_object_agg(fcs.context_path, json_build_object(
+ | 'id', f.id,
+ | 'name', f.name,
+ | 'project', f.project,
+ | 'description', f.description,
+ | 'enabled', fcs.enabled,
+ | 'conditions', fcs.conditions,
+ | 'context', fcs.context,
+ | 'wasmConfig', ow.config,
+ | 'context_path', fcs.context_path)) FILTER(WHERE fcs.enabled IS NOT NULL), '{}'::json) AS overloads
+ | """ else ""}
+ | ${if (needTags) ",COALESCE(json_agg(t.id) FILTER(WHERE t.id IS NOT NULL), '[]') as tags" else ""}
+ | FROM projects p
+ | LEFT JOIN features f on f.project = p.name
+ | ${if (needTags)"""
+ | LEFT JOIN features_tags ft ON f.id=ft.feature
+ | LEFT JOIN tags t ON t.name=ft.tag""" else ""}
+ | ${if (needContexts)s"""
+ | LEFT JOIN feature_contexts_strategies fcs ON fcs.feature=f.name ${if (!conditions)s"AND fcs.context_path = ANY($$5)" else ""}
+ | LEFT JOIN wasm_script_configurations ow ON fcs.script_config=ow.id""".stripMargin else ""}
+ | LEFT JOIN wasm_script_configurations w ON w.id=f.script_config
+ | INNER JOIN apikeys k ON (k.clientid=$$1 AND k.clientsecret=$$2 AND k.enabled=true)
+ | LEFT JOIN apikeys_projects kp ON (kp.apikey=k.name AND kp.project=p.name)
+ | WHERE (f.project = p.name OR f.name IS NULL)
+ | AND (kp.apikey IS NOT NULL OR k.admin=TRUE)
+ | AND (p.id=ANY($$3) OR f.id=ANY($$4))
+ | GROUP BY f.id, pid, w.config
+ |""".stripMargin,
+ params,
+ schemas = Set(tenant)
+ ) {r => {
+ r.optFeature().filter(f => {
+ if(needTags) {
+ val tags = f.tags.map(t => UUID.fromString(t))
+ val specificFeatureRequest = request.features.contains(f.id)
+ val allTagsInOk = request.allTagsIn.subsetOf(tags)
+ val oneTagInOk = request.oneTagIn.isEmpty || request.oneTagIn.exists(u => tags.contains(u))
+ val noTagsInOk = !request.noTagIn.exists(u => tags.contains(u))
+
+ specificFeatureRequest || (allTagsInOk && oneTagInOk && noTagsInOk)
+ } else {
+ true
+ }
+ }).flatMap(f => {
+ if(needContexts) {
+ r.optJsObject("overloads")
+ .map(jsObject => {
+ val objByContext = jsObject.as[Map[String, JsObject]]
+ val overloadByPath: Map[Option[String], AbstractFeature] = objByContext.map { case (ctx, jsObject) => (ctx, Feature.readFeature(jsObject).asOpt) }.filter {
+ case (_, None) => false
+ case _ => true
+ }.map { case (ctx, optionF) => (Some(ctx), optionF.get) }
+
+ (r.optUUID("pid").get, (f.id, overloadByPath + (None -> f)))
+ })
+ } else {
+ Some((r.optUUID("pid").get, (f.id, Map(None -> f))))
+ }
+ })
+ }}.map(l => {
+ val featureByProjects = l.groupBy(t => t._1).map { case (k, v) => (k, v.map(t => t._2).toMap) }
+ Right(featureByProjects)
+ })
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(InvalidCredentials())
+ case _ => Left(InternalServerError())
+ }
+ }
+
+ def findByRequestForKey(
+ tenant: String,
+ request: FeatureRequest,
+ clientId: String,
+ clientSecret: String
+ ): Future[Either[IzanamiError, Map[UUID, Seq[AbstractFeature]]]] = {
+ doFindByRequestForKey(
+ tenant,
+ request,
+ clientId,
+ clientSecret,
+ conditions = false
+ ).map {
+ case Left(err) => Left(err)
+ case Right(l) => {
+ Right(l.map {
+ case (projectId, featuresById) => {
+ (
+ projectId,
+ featuresById.map {
+ case (id, featuresWithContext) => {
+ featuresWithContext.toSeq
+ .sortWith {
+ case ((firstContext, feature), (secondContext, feature2)) => {
+ (firstContext, secondContext) match {
+ case (None, _) => false
+ case (_, None) => true
+ case (Some(ctx1), Some(ctx2)) if ctx1.length > ctx2.length => true
+ case _ => false
+ }
+ }
+ }
+ .head
+ ._2
+ }
+ }.toSeq
+ )
+ }
+ })
+ }
+ }
+ }
+
+ def findByRequestV2(
+ tenant: String,
+ request: FeatureRequest,
+ contexts: Seq[String],
+ user: String
+ ): Future[Map[UUID, Seq[AbstractFeature]]] = {
+ val possibleContextPaths = contexts
+ .foldLeft(Seq(): Seq[Seq[String]])((acc, next) => {
+ val newElement = acc.lastOption.map(last => last.appended(next)).getOrElse(Seq(next))
+ acc.appended(newElement)
+ })
+ .map(seq => seq.mkString("_"))
+
+ env.postgresql
+ .queryAll(
+ s"""
+ |WITH filtered_features AS (
+ | SELECT
+ | f.id,
+ | p.id as pid,
+ | f.enabled,
+ | f.name,
+ | f.project,
+ | f.conditions,
+ | f.script_config,
+ | f.description,
+ | w.config,
+ | fcs.enabled as overload_enabled,
+ | fcs.conditions as overload_conditions,
+ | fcs.context as overload_context,
+ | ow.config as overload_config,
+ | fcs.context_path,
+ | COALESCE(json_agg(t.id) FILTER(WHERE t.id IS NOT NULL), '[]'::json) as tags
+ | FROM
+ | izanami.sessions s
+ | JOIN izanami.users u ON s.username=u.username
+ | LEFT JOIN izanami.users_tenants_rights utr ON utr.username=u.username
+ | LEFT JOIN users_projects_rights upr ON upr.username=s.username,
+ | projects p
+ | LEFT JOIN features f on f.project = p.name
+ | LEFT JOIN features_tags ft ON f.id=ft.feature
+ | LEFT JOIN tags t ON t.name=ft.tag
+ | LEFT JOIN feature_contexts_strategies fcs ON fcs.feature=f.name AND fcs.context_path = ANY($$4)
+ | LEFT JOIN wasm_script_configurations ow ON fcs.script_config=ow.id
+ | LEFT JOIN wasm_script_configurations w ON w.id=f.script_config
+ | WHERE s.username=$$1
+ | AND (f.project = p.name OR f.name IS NULL)
+ | AND (
+ | (upr.project=p.name AND upr.username=s.username)
+ | OR (u.admin OR utr.level = 'ADMIN')
+ | )
+ | AND (p.id=ANY($$2) OR f.id=ANY($$3))
+ | GROUP BY f.id, pid, w.config, ow.config, fcs.enabled, fcs.conditions, fcs.context, fcs.context_path
+ |) SELECT filtered_features.pid AS project_id,
+ | COALESCE(json_agg(json_build_object(
+ | 'name', filtered_features.name,
+ | 'project', filtered_features.project,
+ | 'tags', filtered_features.tags,
+ | 'context', filtered_features.context_path,
+ | 'description', filtered_features.description,
+ | 'id', filtered_features.id)::jsonb ||
+ | (CASE
+ | WHEN filtered_features.overload_enabled IS NOT NULL THEN
+ | json_build_object(
+ | 'enabled', filtered_features.overload_enabled,
+ | 'config', filtered_features.overload_config,
+ | 'conditions', filtered_features.overload_conditions
+ | )::jsonb
+ | ELSE
+ | json_build_object(
+ | 'enabled', filtered_features.enabled,
+ | 'config', filtered_features.config,
+ | 'conditions', filtered_features.conditions
+ | )::jsonb
+ | END)
+ | ) FILTER(WHERE filtered_features.name IS NOT NULL), '[]'::json) as features
+ |FROM filtered_features
+ |GROUP BY filtered_features.pid;
+ |""".stripMargin,
+ List(
+ user,
+ request.projects.toArray,
+ request.features.toArray,
+ possibleContextPaths.toArray
+ ),
+ schemas = Set(tenant)
+ ) { r =>
+ {
+ r.optUUID("project_id")
+ .map(p => {
+ val tuple: (UUID, Seq[AbstractFeature]) = (
+ p,
+ r.optJsArray("features")
+ .toSeq
+ .flatMap(maybeArray => maybeArray.value)
+ .groupBy(jsObj => (jsObj \ "id").as[String])
+ .values
+ .map(featureDuplicates =>
+ featureDuplicates
+ .sortWith((first, second) => {
+ def contextSize(jsValue: JsValue): Int =
+ (jsValue \ "context").asOpt[String].map(_.split("_")).map(_.length).getOrElse(0)
+ val firstContextSize = contextSize(first)
+ val secondContextSize = contextSize(second)
+
+ if (firstContextSize == 0) true
+ else if (secondContextSize == 0) false
+ else if (firstContextSize < secondContextSize) false
+ else true
+ })
+ .head
+ )
+ .flatMap(f => {
+ Feature
+ .readFeature(
+ (f \ "config").asOpt[JsValue].map(js => f.as[JsObject] + ("wasmConfig" -> js)).getOrElse(f)
+ )
+ .asOpt
+ .toSeq
+ })
+ .filter(f =>
+ request.features.contains(f.id) || request.allTagsIn.subsetOf(f.tags.map(UUID.fromString))
+ )
+ .filter(f =>
+ request.features.contains(f.id) || request.oneTagIn.isEmpty || request.oneTagIn
+ .exists(u => f.tags.contains(u.toString))
+ )
+ .filter(f =>
+ request.features.contains(f.id) || !request.noTagIn.exists(u => f.tags.contains(u.toString))
+ )
+ .toSeq
+ )
+ tuple
+ })
+ }
+ }
+ .map(_.toMap)
+ }
+
+ def createFeaturesAndProjects(
+ tenant: String,
+ features: Iterable[AbstractFeature],
+ conflictStrategy: ImportConflictStrategy,
+ user: String,
+ conn: Option[SqlConnection]
+ ): Future[Either[List[IzanamiError], Unit]] = {
+ // TODO return seq[Error] instead of a single one
+ if (features.isEmpty) {
+ Future.successful(Right(()))
+ } else {
+ def callback(conn: SqlConnection): Future[Either[List[IzanamiError], Unit]] = {
+ env.datastores.projects
+ .createProjects(tenant, features.map(_.project).toSet, conflictStrategy, user, conn = conn.some)
+ .flatMap {
+ case Left(error) => Future.successful(Left(List(error)))
+ case _ => createBulk(tenant, features, conflictStrategy, conn)
+ }
+ }
+
+ conn.map(callback).getOrElse(env.postgresql.executeInTransaction(conn => callback(conn)))
+ }
+ }
+
+ def createBulk(
+ tenant: String,
+ features: Iterable[AbstractFeature],
+ conflictStrategy: ImportConflictStrategy,
+ conn: SqlConnection
+ ): Future[Either[List[IzanamiError], Unit]] = {
+ def insertFeatures[T <: ClusterSerializable](
+ params: (
+ Array[String],
+ Array[String],
+ Array[String],
+ Array[java.lang.Boolean],
+ Array[T],
+ Array[Object],
+ Array[String]
+ )
+ ): Future[Either[InternalServerError, List[(String, String)]]] = {
+ env.postgresql
+ .queryAll(
+ s"""INSERT INTO features (id, name, project, enabled, conditions, metadata, description)
+ |VALUES (unnest($$1::text[]), unnest($$2::text[]), unnest($$3::text[]), unnest($$4::boolean[]), unnest($$5::jsonb[]), unnest($$6::jsonb[]), unnest($$7::text[]))
+ ${conflictStrategy match {
+ case Fail => ""
+ case Skip => " ON CONFLICT DO NOTHING"
+ case MergeOverwrite =>
+ """ ON CONFLICT (name, project) DO UPDATE SET id=excluded.id, name=excluded.name, project=excluded.project, enabled=excluded.enabled, conditions=excluded.conditions, metadata=excluded.metadata, description=excluded.description, script_config=null
+ |""".stripMargin
+ }}
+ returning id, project""".stripMargin,
+ params.productIterator.toList.map(a => a.asInstanceOf[AnyRef]),
+ conn = Some(conn),
+ schemas = Set(tenant)
+ ) { row =>
+ for (
+ id <- row.optString("id");
+ project <- row.optString("project")
+ ) yield (id, project)
+ }
+ .map(ls => Right(ls))
+ .recover { case ex =>
+ logger.error("Failed to insert feature", ex)
+ Left(InternalServerError())
+ }
+
+ }
+
+ val wasmConfigs = features
+ .map {
+ case Feature(_, _, _, _, _, _, _, _) => None
+ case WasmFeature(_, _, _, _, wasmConfig, _, _, _) => Some(wasmConfig)
+ case s: SingleConditionFeature => None
+ }
+ .flatMap(o => o.toList)
+
+ def unzip7[A: ClassTag, B: ClassTag, C: ClassTag, D: ClassTag, E: ClassTag, F: ClassTag, G: ClassTag](
+ l: Iterable[(A, B, C, D, E, F, G)]
+ ): (Array[A], Array[B], Array[C], Array[D], Array[E], Array[F], Array[G]) = {
+ l.foldLeft(Tuple7(Array[A](), Array[B](), Array[C](), Array[D](), Array[E](), Array[F](), Array[G]())) {
+ case (res, (e1, e2, e3, e4, e5, e6, e7)) =>
+ (
+ res._1.appended(e1),
+ res._2.appended(e2),
+ res._3.appended(e3),
+ res._4.appended(e4),
+ res._5.appended(e5),
+ res._6.appended(e6),
+ res._7.appended(e7)
+ )
+ }
+ }
+
+ val (modernFeatures, wasmFeatures, legacyFeatures): (
+ ArrayBuffer[Feature],
+ ArrayBuffer[WasmFeature],
+ ArrayBuffer[SingleConditionFeature]
+ ) = (ArrayBuffer(), ArrayBuffer(), ArrayBuffer())
+ features.foreach {
+ case f @ Feature(_, _, _, _, _, _, _, _) =>
+ modernFeatures.addOne(f)
+ case wf @ WasmFeature(_, _, _, _, _, _, _, _) =>
+ wasmFeatures.addOne(wf)
+ case s: SingleConditionFeature =>
+ legacyFeatures.addOne(s)
+ }
+
+ val legacyFeatureParams = unzip7(legacyFeatures.map {
+ case SingleConditionFeature(id, name, project, conditions, enabled, tags, metadata, description) =>
+ (
+ Option(id).getOrElse(UUID.randomUUID().toString),
+ name,
+ project,
+ java.lang.Boolean.valueOf(enabled),
+ new JsonObject(Json.toJson(conditions).toString()),
+ metadata.vertxJsValue,
+ description
+ )
+ })
+
+ val modernFeatureParams = unzip7(
+ modernFeatures.map { case Feature(id, name, project, conditions, enabled, tags, metadata, description) =>
+ (
+ Option(id).getOrElse(UUID.randomUUID().toString),
+ name,
+ project,
+ java.lang.Boolean.valueOf(enabled),
+ new JsonArray(Json.toJson(conditions).toString()),
+ metadata.vertxJsValue,
+ description
+ )
+ }
+ )
+
+ val wasmFeatureParams = unzip7(
+ wasmFeatures.map { case WasmFeature(id, name, project, enabled, wasmConfig, tags, metadata, description) =>
+ (
+ Option(id).getOrElse(UUID.randomUUID().toString),
+ name,
+ project,
+ java.lang.Boolean.valueOf(enabled),
+ wasmConfig.name,
+ metadata.vertxJsValue,
+ description
+ )
+ }
+ )
+
+ createWasmScripts(tenant, wasmConfigs.toList, conflictStrategy, conn.some)
+ .flatMap {
+ case Left(err) => Left(List(err)).future
+ case Right(_) => {
+ Future
+ .sequence(
+ List(
+ insertFeatures(modernFeatureParams),
+ insertFeatures(legacyFeatureParams),
+ env.postgresql
+ .queryAll(
+ s"""INSERT INTO features (id, name, project, enabled, script_config, metadata, description)
+ |VALUES (unnest($$1::TEXT[]), unnest($$2::TEXT[]), unnest($$3::TEXT[]), unnest($$4::BOOLEAN[]), unnest($$5::TEXT[]), unnest($$6::JSONB[]), unnest($$7::TEXT[]))
+ |returning id, project""".stripMargin,
+ wasmFeatureParams.productIterator.toList.map(a => a.asInstanceOf[AnyRef]),
+ conn = conn.some,
+ schemas = Set(tenant)
+ ) { row =>
+ for (
+ id <- row.optString("id");
+ project <- row.optString("project")
+ ) yield (id, project)
+ }
+ .map(ls => Right(ls))
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS =>
+ Left(TenantDoesNotExists(tenant))
+ case ex =>
+ logger.error("Failed to insert feature", ex)
+ Left(InternalServerError())
+ }
+ )
+ )
+ .map(eithers => eithers.toEitherList.map(l => l.flatten))
+ }
+ }
+ .flatMap {
+ case Left(errors) => Future.successful(Left(errors))
+ case Right(ids) =>
+ Future
+ .sequence(features.map(f => insertIntoFeatureTags(tenant, f.id, f.tags, conn.some)))
+ .map(eithers => eithers.toEitherList.map(_ => ids))
+ }
+ .flatMap {
+ case Left(errors) => Future.successful(Left(errors))
+ case Right(ids) => {
+ Future
+ .sequence(ids.map { case (id, project) =>
+ emitEvent(tenant, id = id, eventType = FeatureCreated, sourceProject = project, conn = conn)
+ })
+ .map(_ => Right(()))
+ }
+ }
+ }
+
+ def create(tenant: String, project: String, feature: AbstractFeature): Future[Either[IzanamiError, String]] = {
+ env.postgresql.executeInTransaction(
+ implicit conn => doCreate(tenant, project, feature, conn),
+ schemas = Set(tenant)
+ )
+ }
+
+ private def doCreate(
+ tenant: String,
+ project: String,
+ feature: AbstractFeature,
+ conn: SqlConnection
+ ): Future[Either[IzanamiError, String]] = {
+ (feature match {
+ case Feature(_, _, _, _, _, _, _, _) => Future(Right(()))
+ case WasmFeature(_, _, _, _, wasmConfig, _, _, _) =>
+ createWasmScriptIfNeeded(tenant, wasmConfig, conn = Some(conn))
+ case s: SingleConditionFeature => Future(Right(()))
+ }).flatMap {
+ case Left(err) => Left(err).future
+ case Right(_) => {
+ insertFeature(tenant, project, feature)(conn)
+ .flatMap(eitherId => {
+ eitherId.fold(
+ err => Future.successful(Left(err)),
+ id => insertIntoFeatureTags(tenant, id, feature.tags, Some(conn)).map(either => either.map(_ => id))
+ )
+ })
+ }
+ }
+ }
+
+ def readLocalScripts(tenant: String): Future[Seq[WasmConfig]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT config FROM wasm_script_configurations
+ |""".stripMargin,
+ List(),
+ schemas = Set(tenant)
+ ) { r => r.optJsObject("config").map(js => js.as(WasmConfig.format)) }
+ }
+
+ def deleteLocalScript(tenant: String, name: String): Future[Either[IzanamiError, Unit]] = {
+ env.postgresql
+ .queryOne(
+ s"""
+ |DELETE FROM wasm_script_configurations WHERE id=$$1
+ |""".stripMargin,
+ List(name),
+ schemas = Set(tenant)
+ ) { r => Some(()) }
+ .map(_ => Right(()))
+ .recover {
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION => Left(FeatureDependsOnThisScript())
+ }
+ }
+
+ def readLocalScriptsWithAssociatedFeatures(tenant: String): Future[Seq[WasmConfigWithFeatures]] = {
+ env.postgresql.queryAll(
+ s"""
+ |SELECT c.config, json_agg(json_build_object('id', features.id, 'name', features.name, 'project', features.project)) as features
+ |FROM wasm_script_configurations c
+ |LEFT JOIN features ON features.script_config=c.id
+ |GROUP BY c.config
+ |""".stripMargin,
+ List(),
+ schemas = Set(tenant)
+ ) { r =>
+ {
+ r.optJsObject("config")
+ .map(js => js.as(WasmConfig.format))
+ .flatMap(config => {
+ r.optJsArray("features")
+ .map(arr => {
+ val features = arr.value
+ .map(jsValue => {
+ for {
+ name <- (jsValue \ "name").asOpt[String]
+ id <- (jsValue \ "id").asOpt[String]
+ project <- (jsValue \ "project").asOpt[String]
+ } yield WasmScriptAssociatedFeatures(name = name, project = project, id = id)
+ })
+ .filter(o => o.isDefined)
+ .map(o => o.get)
+ .toSeq
+
+ WasmConfigWithFeatures(wasmConfig = config, features = features)
+ })
+ })
+ }
+ }
+ }
+
+ def readAllLocalScripts(): Future[Seq[WasmConfig]] = {
+ env.datastores.tenants
+ .readTenants()
+ .flatMap(tenants => {
+ Future.sequence(tenants.map(tenant => {
+ env.postgresql.queryOne(
+ s"""
+ |SELECT config FROM "${tenant.name}".wasm_script_configurations
+ |""".stripMargin,
+ List()
+ ) { r => r.optJsObject("config").map(js => js.as(WasmConfig.format)) }
+ }))
+ })
+ .map(os => os.filter(o => o.isDefined).map(o => o.get))
+ }
+
+ def createWasmScriptIfNeeded(
+ tenant: String,
+ wasmConfig: WasmConfig,
+ conn: Option[SqlConnection]
+ ): Future[Either[IzanamiError, String]] = {
+ wasmConfig.source.kind match {
+ case WasmSourceKind.Unknown => throw new RuntimeException("Unknown wasm script")
+ case WasmSourceKind.Local => Right(wasmConfig.source.path).future
+ case _ =>
+ env.postgresql
+ .queryOne(
+ s"""INSERT INTO wasm_script_configurations (id, config) VALUES ($$1,$$2) RETURNING id""",
+ List(wasmConfig.name, Json.toJson(wasmConfig)(WasmConfig.format).vertxJsValue),
+ conn = conn,
+ schemas = Set(tenant)
+ ) { row => row.optString("id") }
+ .map(o => o.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION =>
+ Left(WasmScriptAlreadyExists(wasmConfig.source.path))
+ }
+ .flatMap(either => {
+ // TODO this should be elsewhere
+ wasmConfig.source.getWasm()(env.wasmIntegration.context, env.executionContext).map(_ => either)
+ })
+ }
+ }
+
+ def createWasmScripts(
+ tenant: String,
+ wasmConfigs: List[WasmConfig],
+ conflictStrategy: ImportConflictStrategy,
+ conn: Option[SqlConnection]
+ ): Future[Either[IzanamiError, Set[String]]] = {
+
+ if (wasmConfigs.isEmpty) {
+ Future.successful(Right(Set()))
+ } else {
+
+ val (ids, scripts) = wasmConfigs
+ .filter(w => w.source.kind != WasmSourceKind.Local && w.source.kind != WasmSourceKind.Unknown)
+ .map(w => (w.name, Json.toJson(w)(WasmConfig.format).vertxJsValue))
+ .unzip
+
+ val localScriptIds = wasmConfigs.filter(w => w.source.kind == WasmSourceKind.Local).map(w => w.name)
+
+ env.postgresql
+ .queryRaw(
+ s"""
+ |INSERT INTO wasm_script_configurations(id, config)
+ |VALUES (unnest($$1::TEXT[]), unnest($$2::JSONB[]))
+ |${conflictStrategy match {
+ case Fail => ""
+ case MergeOverwrite =>
+ """
+ |ON CONFLICT(id) DO UPDATE SET config = excluded.config
+ |""".stripMargin
+ case Skip => " ON CONFLICT(id) DO NOTHING "
+ }}
+ |returning id
+ |""".stripMargin,
+ List(ids.toArray, scripts.toArray),
+ schemas = Set(tenant),
+ conn = conn
+ ) { rs => rs.flatMap(_.optString("id")).toSet }
+ .map(ids => {
+ ids.foreach(id =>
+ wasmConfigs.find(w => w.name == id).get.source.getWasm()(env.wasmIntegration.context, env.executionContext)
+ )
+ Right(ids.concat(localScriptIds))
+ })
+ .recover {
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION =>
+ Left(WasmScriptAlreadyExists("")) // TODO specify script name
+ }
+ }
+ }
+
+ def updateWasmScript(
+ tenant: String,
+ script: String,
+ wasmConfig: WasmConfig
+ ): Future[Unit] = {
+ env.postgresql
+ .queryOne(
+ s"""UPDATE wasm_script_configurations SET id=$$1, config=$$2 WHERE id=$$3 RETURNING id""",
+ List(
+ wasmConfig.name,
+ wasmConfig.json.vertxJsValue,
+ script
+ ),
+ schemas = Set(tenant)
+ ) { row => row.optString("id") }
+ .map(o => ())
+ }
+
+ private def insertFeature(
+ tenant: String,
+ project: String,
+ feature: AbstractFeature,
+ importConflictStrategy: ImportConflictStrategy = Fail
+ )(implicit
+ conn: SqlConnection
+ ): Future[Either[IzanamiError, String]] = {
+ val (request, params) = feature match {
+ case SingleConditionFeature(id, name, project, conditions, enabled, _, metadata, description) =>
+ (
+ s"""INSERT INTO features (id, name, project, enabled, conditions, metadata, description)
+ |VALUES ($$1, $$2, $$3, $$4, $$5, $$6, $$7)
+ |returning id""".stripMargin,
+ List(
+ Option(id).getOrElse(UUID.randomUUID().toString),
+ name,
+ project,
+ java.lang.Boolean.valueOf(enabled),
+ new JsonObject(Json.toJson(conditions).toString()),
+ metadata.vertxJsValue,
+ description
+ )
+ )
+ case Feature(id, name, project, conditions, enabled, _, metadata, description) =>
+ (
+ s"""INSERT INTO features (id, name, project, enabled, conditions, metadata, description)
+ |VALUES ($$1, $$2, $$3, $$4, $$5, $$6, $$7)
+ |returning id""".stripMargin,
+ List(
+ Option(id).getOrElse(UUID.randomUUID().toString),
+ name,
+ project,
+ java.lang.Boolean.valueOf(enabled),
+ new JsonArray(Json.toJson(conditions).toString()),
+ metadata.vertxJsValue,
+ description
+ )
+ )
+ case WasmFeature(id, name, project, enabled, config, _, metadata, description) =>
+ (
+ s"""INSERT INTO features (id, name, project, enabled, script_config, metadata, description)
+ |VALUES ($$1, $$2, $$3, $$4, $$5, $$6, $$7)
+ |returning id""".stripMargin,
+ List(
+ Option(id).getOrElse(UUID.randomUUID().toString),
+ name,
+ project,
+ java.lang.Boolean.valueOf(enabled),
+ config.name,
+ metadata.vertxJsValue,
+ description
+ )
+ )
+ }
+
+ env.postgresql
+ .queryOne(
+ request,
+ params,
+ conn = Some(conn),
+ schemas = Set(tenant)
+ ) { row => row.optString("id") }
+ .map(_.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION => Left(ProjectDoesNotExists(project))
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case ex =>
+ logger.error("Failed to insert feature", ex)
+ Left(InternalServerError())
+ }
+ .flatMap {
+ case Left(error) => Future.successful(Left(error))
+ case Right(id) =>
+ emitEvent(tenant, id = id, eventType = FeatureCreated, sourceProject = project, conn = conn).map(_ =>
+ Right(id)
+ )
+ }
+ }
+
+ def update(tenant: String, id: String, feature: AbstractFeature): Future[Either[IzanamiError, String]] = {
+ // TODO allow updating metadata
+ env.postgresql.executeInTransaction(
+ conn => {
+ val (request, params) = feature match {
+ case SingleConditionFeature(id, name, project, conditions, enabled, tags, metadata, description) =>
+ (
+ s"""update features
+ |SET name=$$1, enabled=$$2, conditions=$$3, script_config=NULL, description=$$5, project=$$6 WHERE id=$$4 returning id""".stripMargin,
+ List(
+ name,
+ java.lang.Boolean.valueOf(enabled),
+ new JsonObject(Json.toJson(conditions).toString()),
+ id,
+ description,
+ project
+ )
+ )
+ case Feature(_, name, project, conditions, enabled, _, _, description) =>
+ (
+ s"""update features
+ |SET name=$$1, enabled=$$2, conditions=$$3, script_config=NULL, description=$$5, project=$$6 WHERE id=$$4 returning id""".stripMargin,
+ List(
+ name,
+ java.lang.Boolean.valueOf(enabled),
+ new JsonArray(Json.toJson(conditions).toString()),
+ id,
+ description,
+ project
+ )
+ )
+ case WasmFeature(_, name, project, enabled, wasmConfig, _, _, description) =>
+ (
+ s"""update features
+ |SET name=$$1, enabled=$$2, script_config=$$4, conditions=NULL, description=$$5, project=$$6 WHERE id=$$3 returning id""".stripMargin,
+ List(
+ name,
+ java.lang.Boolean.valueOf(enabled),
+ id,
+ wasmConfig.name,
+ description,
+ project
+ )
+ )
+ }
+
+ (feature match {
+ case feat @ WasmFeature(_, _, _, _, wasmConfig, _, _, _) if wasmConfig.source.kind != WasmSourceKind.Local =>
+ createWasmScriptIfNeeded(tenant, wasmConfig, Some(conn))
+ case _ => Future(())
+ })
+ .flatMap(_ =>
+ env.postgresql.queryRaw(
+ s"""
+ |DELETE FROM feature_contexts_strategies fc USING features f
+ |WHERE fc.feature=f.name
+ |AND fc.project=f.project
+ |AND f.id=$$1
+ |AND f.project != $$2
+ |AND fc.local_context IS NOT NULL
+ |""".stripMargin,
+ List(id, feature.project),
+ conn = Some(conn)
+ ) { _ => Some(()) }
+ )
+ .flatMap(_ =>
+ env.postgresql
+ .queryOne(
+ request,
+ params,
+ conn = Some(conn)
+ ) { row => row.optString("id") }
+ .map(maybeId => maybeId.toRight(InternalServerError()))
+ .recover {
+ case f: PgException if f.getSqlState == NOT_NULL_VIOLATION => Left(MissingFeatureFields())
+ case _ => Left(InternalServerError())
+ }
+ .flatMap(either => {
+ either.fold(
+ err => Future.successful(Left(err)),
+ id => {
+ env.postgresql
+ .queryOne(
+ s"""delete from features_tags where feature=$$1""",
+ List(id),
+ conn = Some(conn)
+ ) { _ => Some(id) }
+ .flatMap(_ =>
+ insertIntoFeatureTags(tenant, id, feature.tags, Some(conn)).map(either => either.map(_ => id))
+ )
+ }
+ )
+ })
+ )
+ .flatMap {
+ case l @ Left(_) => Future.successful(l)
+ case r @ Right(id) =>
+ emitEvent(
+ tenant,
+ id = id,
+ eventType = FeatureUpdated,
+ sourceProject = feature.project,
+ conn = conn
+ ).map(_ => r)
+ }
+ },
+ schemas = Set(tenant)
+ )
+ }
+
+ def insertIntoFeatureTags(
+ tenant: String,
+ id: String,
+ tags: Set[String],
+ conn: Option[SqlConnection]
+ ): Future[Either[IzanamiError, Unit]] = {
+ if (tags.isEmpty) {
+ Future.successful(Right(()))
+ } else {
+ env.postgresql
+ .queryOne(
+ s"""
+ |INSERT INTO features_tags (feature, tag)
+ |VALUES ($$1, unnest($$2::TEXT[])) returning *""".stripMargin,
+ List(id, tags.toArray),
+ conn = conn,
+ schemas = Set(tenant)
+ ) { _ => Some(()) }
+ .map { _.toRight(InternalServerError()) }
+ .recover {
+ case f: PgException if f.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case f: PgException if f.getSqlState == FOREIGN_KEY_VIOLATION =>
+ Left(TagDoesNotExists(tags.map(t => t).mkString(",")))
+ case ex =>
+ logger.error("Failed to update feature/tag mapping table", ex)
+ Left(InternalServerError())
+ }
+ }
+ }
+
+ def delete(tenant: String, id: String): Future[Either[IzanamiError, String]] = {
+ env.postgresql.executeInTransaction(conn =>
+ env.postgresql
+ .queryOne(
+ s"""DELETE FROM features WHERE id=$$1 returning id, project""",
+ List(id),
+ schemas = Set(tenant),
+ conn = Some(conn)
+ ) { row =>
+ for (
+ id <- row.optString("id");
+ project <- row.optString("project")
+ ) yield (id, project)
+ }
+ .map { _.toRight(InternalServerError()) }
+ .recover {
+ case ex: PgException if ex.getSqlState == RELATION_DOES_NOT_EXISTS => Left(TenantDoesNotExists(tenant))
+ case _ => Left(InternalServerError())
+ }
+ .flatMap {
+ case l @ Left(err) => Future.successful(Left(err))
+ case Right((id, project)) =>
+ emitEvent(tenant, id = id, eventType = FeatureDeleted, sourceProject = project, conn = conn).map(_ =>
+ Right(id)
+ )
+ }
+ )
+ }
+}
+
+object featureImplicits {
+ implicit class FeatureRow(val row: Row) extends AnyVal {
+
+ def optFeature(): Option[AbstractFeature] = {
+ val tags =
+ row.optJsArray("tags").map(array => array.value.map(v => v.as[String]).toSet).getOrElse(Set())
+
+ val maybeClassicalConditions = row
+ .optJsArray("contextual_conditions")
+ .orElse(row.optJsArray("conditions"))
+ .map(arr => arr.value.map(v => v.as[ActivationCondition]).toSet)
+
+ lazy val maybeLegacyConditions = row
+ .optJsObject("contextual_conditions")
+ .orElse(row.optJsObject("conditions"))
+ .map(v => v.as[LegacyCompatibleCondition])
+
+ lazy val maybeWasmConfig = row
+ .optJsObject("contextual_wasm")
+ .orElse(row.optJsObject("wasm"))
+ .map(jsObject => jsObject.as[WasmConfig](WasmConfig.format))
+
+ for (
+ name <- row.optString("name");
+ id <- row.optString("id");
+ description <- row.optString("description");
+ project <- row.optString("project");
+ enabled <- row.optBoolean("contextual_enabled").orElse(row.optBoolean("enabled"));
+ metadata <- row.optJsObject("metadata")
+ )
+ yield (maybeClassicalConditions, maybeLegacyConditions, maybeWasmConfig) match {
+ case (Some(classicalConditions), _, _) => {
+ Feature(
+ id = id,
+ name = name,
+ project = project,
+ enabled = enabled,
+ conditions = classicalConditions,
+ metadata = metadata,
+ tags = tags,
+ description = description
+ )
+ }
+ case (_, Some(legacyCompatibleCondition), _) => {
+ SingleConditionFeature(
+ id = id,
+ name = name,
+ project = project,
+ enabled = enabled,
+ condition = legacyCompatibleCondition,
+ metadata = metadata,
+ tags = tags,
+ description = description
+ )
+ }
+ case (_, _, Some(wasmConfig)) => {
+ WasmFeature(
+ id = id,
+ name = name,
+ project = project,
+ enabled = enabled,
+ wasmConfig = wasmConfig,
+ metadata = metadata,
+ tags = tags,
+ description = description
+ )
+ }
+ case _ => throw new RuntimeException("Failed to read feature " + id)
+ }
+ }
+ }
+}
diff --git a/app/fr/maif/izanami/datastores/HashUtils.scala b/app/fr/maif/izanami/datastores/HashUtils.scala
new file mode 100644
index 000000000..0e628d01d
--- /dev/null
+++ b/app/fr/maif/izanami/datastores/HashUtils.scala
@@ -0,0 +1,24 @@
+package fr.maif.izanami.datastores
+
+import org.apache.commons.codec.binary.Hex
+import org.mindrot.jbcrypt.BCrypt._
+
+import java.security.MessageDigest
+
+object HashUtils {
+ def bcryptHash(input: String): String = {
+ hashpw(input, gensalt())
+ }
+
+ def bcryptCheck(input: String, hashed: String): Boolean = {
+ checkpw(input, hashed)
+ }
+
+ def sha512(toHash: String): Array[Byte] =
+ MessageDigest.getInstance("SHA-512").digest(toHash.getBytes)
+
+ def hexSha512(toHash: String): String =
+ Hex encodeHexString MessageDigest
+ .getInstance("SHA-512")
+ .digest(toHash.getBytes)
+}
diff --git a/app/fr/maif/izanami/datastores/ProjectsDatastore.scala b/app/fr/maif/izanami/datastores/ProjectsDatastore.scala
new file mode 100644
index 000000000..fdd9d1fa5
--- /dev/null
+++ b/app/fr/maif/izanami/datastores/ProjectsDatastore.scala
@@ -0,0 +1,259 @@
+package fr.maif.izanami.datastores
+
+import fr.maif.izanami.datastores.projectImplicits.ProjectRow
+import fr.maif.izanami.env.Env
+import fr.maif.izanami.env.PostgresqlErrors.{RELATION_DOES_NOT_EXISTS, UNIQUE_VIOLATION}
+import fr.maif.izanami.env.pgimplicits.EnhancedRow
+import fr.maif.izanami.errors._
+import fr.maif.izanami.models.{Feature, Project, ProjectCreationRequest, RightLevels}
+import fr.maif.izanami.utils.Datastore
+import fr.maif.izanami.utils.syntax.implicits.BetterSyntax
+import fr.maif.izanami.web.ImportController
+import fr.maif.izanami.web.ImportController.{Fail, ImportConflictStrategy, MergeOverwrite, Skip}
+import io.vertx.pgclient.PgException
+import io.vertx.sqlclient.{Row, SqlConnection}
+
+import java.util.regex.Pattern
+import scala.concurrent.Future
+
+class ProjectsDatastore(val env: Env) extends Datastore {
+
+ def createProjects(
+ tenant: String,
+ names: Set[String],
+ conflictStrategy: ImportConflictStrategy,
+ user: String,
+ conn: Option[SqlConnection] = None
+ ): Future[Either[IzanamiError, Unit]] = {
+ env.postgresql.queryRaw(
+ s"""
+ |INSERT INTO projects(name, description) VALUES(unnest($$1::text[]), '')
+ |${
+ conflictStrategy match {
+ case Fail => ""
+ case MergeOverwrite => """
+ | ON CONFLICT(name) DO UPDATE SET description = excluded.description
+ |""".stripMargin
+ case Skip => " ON CONFLICT(name) DO NOTHING "
+ }}
+ |RETURNING name
+ |""".stripMargin,
+ List(names.toArray),
+ schemas = Set(tenant),
+ conn=conn
+ ){_ => Some(())}
+ .map(o => {
+ o.toRight(InternalServerError())
+ })
+ .flatMap {
+ case Left(err) => Left(err).future
+ case Right(value) => env.postgresql.queryRaw(
+ s"""INSERT INTO users_projects_rights (username, project, level)
+ |VALUES ($$1, unnest($$2::TEXT[]), $$3)
+ |ON CONFLICT(username, project) DO NOTHING
+ |RETURNING 1
+ |""".stripMargin,
+ List(user, names.toArray, RightLevels.Admin.toString.toUpperCase),
+ conn = conn
+ ) { _ => Some(value) }
+ .map(o => {
+ o.toRight(InternalServerError())
+ })
+ }
+ .recover{
+ case f: PgException if f.getSqlState == UNIQUE_VIOLATION => {
+ val regexp = Pattern.compile("Key \\(name\\)=\\((?There's nothing here!
+