Attributes system

src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeClasses.kt

@@ -2,6 +2,7 @@ package com.ex_dock.ex_dock.database.scope
 
 import io.vertx.core.json.JsonObject
 
+@Deprecated("Scope() is deprecated, use JsonObject instead")
 data class Scope(
   var scopeId: String?,
   var websiteName: String,

src/main/kotlin/com/ex_dock/ex_dock/database/scope/ScopeJdbcVerticle.kt

@@ -1,152 +1,51 @@
 package com.ex_dock.ex_dock.database.scope
 
+import com.ex_dock.ex_dock.MainVerticle
 import com.ex_dock.ex_dock.database.connection.getConnection
-import com.ex_dock.ex_dock.frontend.cache.setCacheFlag
-import com.ex_dock.ex_dock.helper.replyListMessage
-import com.ex_dock.ex_dock.helper.replySingleMessage
+import com.ex_dock.ex_dock.global.cachedScopes
+import com.ex_dock.ex_dock.helper.messages.errorResponse
 import io.vertx.core.Future
 import io.vertx.core.VerticleBase
-import io.vertx.core.eventbus.DeliveryOptions
 import io.vertx.core.eventbus.EventBus
 import io.vertx.core.json.JsonObject
 import io.vertx.ext.mongo.MongoClient
 
 class ScopeJdbcVerticle:  VerticleBase() {
   private lateinit var client: MongoClient
   private lateinit var eventBus: EventBus
-  private val fullScopeDeliveryOptions: DeliveryOptions = DeliveryOptions().setCodecName("ScopeCodec")
 
   companion object {
-    private const val CACHE_ADDRESS = "scopes"
+    const val CACHE_ADDRESS = "scopes"
   }
 
   override fun start(): Future<*>? {
     client = vertx.getConnection()
     eventBus = vertx.eventBus()
 
     // Initialize all eventbus connections for basic scopes
-    getAllScopes()
-    getScopeById()
-    getScopesByWebsiteName()
-    getScopesByStoreViewName()
-    createScope()
-    editScope()
+    eventBus.getAllScopes(client)
+    eventBus.getScopeById(client)
+    eventBus.getScopesByWebsiteId(client)
+    eventBus.createWebsite(client)
+    eventBus.createStoreView(client)
     deleteScope()
 
     return Future.succeededFuture<Unit>()
   }
 
-  private fun getAllScopes() {
-    val getAllScopesConsumer = eventBus.consumer<String>("process.scope.getAllScopes")
-    getAllScopesConsumer.handler { message ->
-      val query = JsonObject()
-
-      client.find("scopes", query).replyListMessage(message)
-    }
-  }
-
-  private fun getScopeById() {
-    val getScopeByWebsiteIdConsumer = eventBus.consumer<String>("process.scope.getScopeByWebsiteId")
-    getScopeByWebsiteIdConsumer.handler { message ->
-      val websiteId = message.body()
-      val query = JsonObject()
-        .put("_id", websiteId)
-
-      client.find("scopes", query).replySingleMessage(message)
-    }
-  }
-
-  private fun getScopesByWebsiteName() {
-    val getScopesByWebsiteNameConsumer = eventBus.consumer<String>("process.scope.getScopesByWebsiteName")
-    getScopesByWebsiteNameConsumer.handler { message ->
-      val websiteName = message.body()
-      val query = JsonObject()
-        .put("website_name", websiteName)
-
-      client.find("scopes", query).replyListMessage(message)
-    }
-  }
-
-  private fun getScopesByStoreViewName() {
-    val getScopesByStoreViewNameConsumer = eventBus.consumer<String>("process.scope.getScopesByStoreViewName")
-    getScopesByStoreViewNameConsumer.handler { message ->
-      val storeViewName = message.body()
-      val query = JsonObject()
-        .put("store_view_name", storeViewName)
-
-      client.find("scopes", query).replyListMessage(message)
-    }
-  }
-
-  private fun createScope() {
-    val createScopeConsumer = eventBus.consumer<Scope>("process.scope.createScope")
-    createScopeConsumer.handler { message ->
-      println("Received createScope message in ScopeJdbcVerticle")
-      val scope = message.body()
-      val document = scope.toDocument()
-
-      val rowsFuture = client.save("scopes", document)
-
-      rowsFuture.onFailure { res ->
-        println("Failed to execute query: $res")
-        message.fail(500, "Failed to execute query: $res")
-      }
-
-      rowsFuture.onSuccess { res ->
-        val lastInsertID: String? = res
-        if (lastInsertID != null) {
-          scope.scopeId = lastInsertID
-        }
-
-        setCacheFlag(eventBus, CACHE_ADDRESS)
-        message.reply(scope, fullScopeDeliveryOptions)
-      }
-    }
-  }
-
-  private fun editScope() {
-    val editScopeConsumer = eventBus.consumer<Scope>("process.scope.editScope")
-    editScopeConsumer.handler { message ->
-      val body = message.body()
-      if (body.scopeId == null) {
-        message.fail(400, "No scope ID provided")
-        return@handler
-      }
-      val document = body.toDocument()
-      val rowsFuture = client.save("scopes", document)
-
-      rowsFuture.onFailure { res ->
-        println("Failed to execute query: $res")
-        message.fail(500, "Failed to execute query: $res")
-      }
-
-      rowsFuture.onSuccess { res ->
-        val lastInsertID: String? = res
-        if (lastInsertID != null) {
-          body.scopeId = lastInsertID
-        }
-
-        setCacheFlag(eventBus, CACHE_ADDRESS)
-        message.reply(body, fullScopeDeliveryOptions)
-      }
-    }
-  }
+  // TODO: create editScope functions
 
   private fun deleteScope() {
-    val deleteScopeConsumer = eventBus.consumer<String>("process.scope.deleteScope")
-    deleteScopeConsumer.handler { message ->
+    // TODO: remove all data associated with the scope
+    eventBus.consumer<String>("process.scope.deleteScope").handler { message ->
       val scopeId = message.body()
       val query = JsonObject()
         .put("_id", scopeId)
 
-      val rowsFuture = client.removeDocument("scopes", query)
-
-      rowsFuture.onFailure { res ->
-        println("Failed to execute query: $res")
-        message.fail(500, "Failed to execute query: $res")
-      }
-
-      rowsFuture.onSuccess { res ->
+      client.removeDocument("scopes", query).onFailure { err ->
+        message.errorResponse(500, "Failed to execute query: $err")
+      }.onSuccess { _ ->
+        cachedScopes.remove(scopeId)
         message.reply("Scope deleted successfully")
       }
     }

src/main/kotlin/com/ex_dock/ex_dock/database/scope/createScopes.kt

@@ -0,0 +1,98 @@
+package com.ex_dock.ex_dock.database.scope
+
+import com.ex_dock.ex_dock.global.cachedScopes
+import com.ex_dock.ex_dock.helper.messages.errorResponse
+import io.vertx.core.eventbus.EventBus
+import io.vertx.core.json.JsonObject
+import io.vertx.ext.mongo.MongoClient
+import org.bson.types.ObjectId
+
+internal fun EventBus.createWebsite(client: MongoClient) {
+  this.localConsumer<JsonObject>("process.scope.create.website").handler { message ->
+    val data = message.body()
+
+    val keyString = data.getString("scopeKey") ?: return@handler message.fail(400, "The key of the website (scope) is required.")
+    val key = ObjectId(keyString)
+    val name =
+      data.getString("scopeName") ?: return@handler message.fail(400, "The name of the website (scope) is required.")
+
+    client.findOne(
+      ScopeJdbcVerticle.CACHE_ADDRESS,
+      JsonObject().put("_id", key),
+      JsonObject().put("_id", 1),
+    ).onFailure { err ->
+      message.errorResponse(400, err)
+    }.onSuccess { res ->
+      if (res != null) return@onSuccess message.fail(
+        409,
+        "This function is for creating websites (scope), not editing them."
+      )
+
+      val document = JsonObject().put("_id", key).put("scopeName", name).put("scopeType", "website")
+
+      client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
+        message.errorResponse(err)
+      }.onSuccess { res ->
+        cachedScopes.put(keyString, document)
+        message.reply(res ?: key)
+      }
+    }
+  }
+}
+
+internal fun EventBus.createStoreView(client: MongoClient) {
+  this.localConsumer<JsonObject>("process.scope.create.store-view").handler { message ->
+    val data = message.body()
+
+    val name =
+      data.getString("name") ?: return@handler message.fail(400, "The name of the store-view (scope) is required.")
+    val keyString = data.getString("key") ?: return@handler message.fail(400, "The key of the store-view (scope) is required.")
+    val key = ObjectId(keyString)
+    val websiteId = data.getString("websiteId") ?: return@handler message.fail(
+      400,
+      "The websiteId of the parent website (scope) is required."
+    )
+
+    client.findOne(
+      ScopeJdbcVerticle.CACHE_ADDRESS,
+      JsonObject().put("_id", key),
+      JsonObject().put("_id", 1),
+    ).onFailure { err ->
+      message.errorResponse(400, err)
+    }.onSuccess { res ->
+      if (res != null) return@onSuccess message.fail(
+        409,
+        "This function is for creating store-views (scope), not editing them."
+      )
+
+      val searchWebsiteQuery = JsonObject().put("scopeType", "website").put("_id", websiteId)
+      client.find(ScopeJdbcVerticle.CACHE_ADDRESS, searchWebsiteQuery).onFailure { err ->
+        message.errorResponse(err)
+      }.onSuccess { res ->
+        if (res.isEmpty()) return@onSuccess message.fail(
+          400,
+          "The websiteId of the parent website (scope) does not exist"
+        )
+
+        client.find(ScopeJdbcVerticle.CACHE_ADDRESS, JsonObject().put("_id", key)).onFailure { err ->
+          message.errorResponse(err)
+        }.onSuccess { res ->
+          if (res.isNotEmpty()) return@onSuccess message.fail(
+            400,
+            "The key of the store-view (scope) already exists for a scope"
+          )
+
+          val document = JsonObject().put("_id", key).put("scopeName", name).put("scopeType", "store-view")
+            .put("websiteId", websiteId)
+
+          client.insert(ScopeJdbcVerticle.CACHE_ADDRESS, document).onFailure { err ->
+            message.errorResponse(err)
+          }.onSuccess { res ->
+            cachedScopes.put(keyString, document)
+            message.reply(res ?: key)
+          }
+        }
+      }
+    }
+  }
+}

src/main/kotlin/com/ex_dock/ex_dock/database/scope/getScopes.kt

@@ -0,0 +1,45 @@
+package com.ex_dock.ex_dock.database.scope
+
+import com.ex_dock.ex_dock.global.cachedScopes
+import com.ex_dock.ex_dock.helper.replyListMessage
+import com.ex_dock.ex_dock.helper.replySingleMessage
+import io.vertx.core.eventbus.EventBus
+import io.vertx.core.json.JsonObject
+import io.vertx.ext.mongo.MongoClient
+
+
+internal fun EventBus.getAllScopes(client: MongoClient) {
+  this.consumer<String>("process.scope.getAllScopes").handler { message ->
+    val query = JsonObject()
+
+    client.find("scopes", query).onSuccess { res ->
+      val newCachedScopes = JsonObject()
+      for (scope in res) newCachedScopes.put(scope.getString("_id"), scope)
+      cachedScopes = newCachedScopes
+    }.replyListMessage(message)
+  }
+}
+
+internal fun EventBus.getScopeById(client: MongoClient) {
+  this.consumer<String>("process.scope.getScopeById").handler { message ->
+    val websiteId = message.body()
+    val query = JsonObject()
+      .put("_id", websiteId)
+
+    client.find("scopes", query).onSuccess { res ->
+      cachedScopes.put(websiteId, res.first())
+    }.replySingleMessage(message)
+  }
+}
+
+internal fun EventBus.getScopesByWebsiteId(client: MongoClient) {
+  this.consumer<String>("process.scope.getScopesByWebsiteId").handler { message ->
+    val websiteName = message.body()
+    val query = JsonObject()
+      .put("websiteId", websiteName)
+
+    client.find("scopes", query).onSuccess { res ->
+      for (scope in res) cachedScopes.put(scope.getString("_id"), scope)
+    }.replyListMessage(message)
+  }
+}

src/main/kotlin/com/ex_dock/ex_dock/global/scopes.kt

@@ -0,0 +1,5 @@
+package com.ex_dock.ex_dock.global
+
+import io.vertx.core.json.JsonObject
+
+var cachedScopes: JsonObject = JsonObject()

src/main/kotlin/com/ex_dock/ex_dock/helper/attributes/AttributeConfiguration.kt

@@ -0,0 +1,19 @@
+package com.ex_dock.ex_dock.helper.attributes
+
+import com.ex_dock.ex_dock.helper.scopes.ScopeLevel
+import io.vertx.core.json.JsonObject
+
+data class AttributeConfiguration(
+  val attributeKey: String,
+  val attributeName: String,
+  val attributeDataType: String,
+  val scopeLevel: ScopeLevel,
+) {
+  fun toDocument(): JsonObject {
+    return JsonObject()
+      .put("_id", attributeKey)
+      .put("attributeName", attributeName)
+      .put("attributeType", attributeDataType)
+      .put("attributeScopeLevel", scopeLevel.name)
+  }
+}