Merge branch 'main' of https://github.com/zecrypt-io/zecrypt-server into feature/shivil/modules-UI-Fixing

Author: shivilSR4

packages/backend-server/app/api/v1/web/dashboard/services.py

@@ -18,9 +18,7 @@ async def get_dashboard_overview(request, user):
     data = {}
     for key, value in features.items():
         if value.get("enabled"):
-            data[key] = secret_manager.get_project_secrets_count(
-                db, key, project_id
-            )
+            data[key] = secret_manager.get_project_secrets_count(db, key, project_id)
 
     return response_helper(200, "Dashboard overview loaded successfully", data)
 

packages/backend-server/app/api/v1/web/projects/services.py

@@ -6,7 +6,6 @@
     secrets as secrets_manager,
 )
 
-from app.framework.encryption.service import get_project_key
 from app.utils.i8ns import translate
 
 
@@ -133,10 +132,8 @@ def get_tags(db, project_id):
     return response_helper(200, translate("project.tags"), data=unique_tags)
 
 
-def add_project_key(db, user_id, project_id, workspace_id, project_key=None):
-    if not project_key:
-        project_key = get_project_key(db, user_id)
-
+def add_project_key(db, user_id, project_id, workspace_id, project_key):
+   
     project_keys_manager.insert_one(
         db,
         {

packages/backend-server/app/api/v1/web/secrets/services.py

@@ -4,30 +4,23 @@
 from app.utils.i8ns import translate
 from fastapi import BackgroundTasks
 from app.api.v1.web.project_activity.services import add_recent_activity
+from app.framework.valkey import services as valkey_services
 
-background_tasks = BackgroundTasks()
-
-
-async def get_secret_details(db, data_type, doc_id):
-    secret = secrets_manager.find_one(
-        db, {"doc_id": doc_id, "secret_type": data_type}, {"_id": False}
-    )
-
-    if not secret:
-        return response_helper(404, translate(f"{data_type}.not_found"))
-
-    return response_helper(200, translate(f"{data_type}.details"), data=secret)
 
 
 async def get_secrets(request, user, data_type):
     db = user.get("db")
     page = request.query_params.get("page", None)
     limit = request.query_params.get("limit", None)
-
+    project_id = request.path_params.get("project_id")
     query = {
         "secret_type": data_type,
-        "project_id": request.path_params.get("project_id"),
+        "project_id": project_id,
     }
+    if valkey_services.check_secret_exists(project_id, data_type, query):
+        data = valkey_services.get_secret(project_id, data_type, query)
+        return response_helper(200, translate(f"{data_type}.list"), data=data, count=len(data))
+
     if page and limit:
         skip = (page - 1) * limit
         secrets = secrets_manager.find(db, query, skip=skip, limit=limit)
@@ -76,6 +69,7 @@ async def add_secret(request, user, data_type, payload, background_tasks):
         payload.get("doc_id"),
         "create",
     )
+    background_tasks.add_task(valkey_services.delete_secret, project_id, data_type)
     return response_helper(201, translate(f"{data_type}.add"), data=payload)
 
 
@@ -113,6 +107,7 @@ async def update_secret(request, user, data_type, payload, background_tasks):
     background_tasks.add_task(
         add_recent_activity, user, project_id, data_type, doc_id, "update"
     )
+    background_tasks.add_task(valkey_services.delete_secret, project_id, data_type)
     return response_helper(200, translate(f"{data_type}.update"), data=payload)
 
 
@@ -128,4 +123,5 @@ async def delete_secret(request, user, data_type, background_tasks):
     background_tasks.add_task(
         add_recent_activity, user, project_id, data_type, doc_id, "delete"
     )
+    background_tasks.add_task(valkey_services.delete_secret, project_id, data_type)
     return response_helper(200, translate(f"{data_type}.delete"), data={})

packages/backend-server/app/core/config.py

@@ -13,6 +13,8 @@ class Settings(BaseSettings):
     STACK_AUTH_CLIENT_SECRET: str
     TOTP_SECRET: str
 
+    VALKEY_URL: str
+
     class Config:
         case_sensitive = True
         env_file = ".env"

packages/backend-server/app/framework/encryption/service.py

@@ -0,0 +1,89 @@
+import json
+
+import valkey
+
+from app.core.config import settings
+
+valkey_client = valkey.Valkey.from_url(url=settings.VALKEY_URL)
+
+
+
+class ValkeyClient:
+    def __init__(self):
+        """
+        Initialize a new instance of redis client
+        """
+        self.client = valkey_client
+
+   
+    def add_key_to_hash(self, name, key, value):
+        """
+        Add a new key-value pair to a hash
+
+        :param name: The name of the hash.
+        :param key: The key of the item.
+        :param value: The value to be stored.
+        """
+        if self.client.hexists(name, key):
+            self.client.hdel(name, key)
+        self.client.hset(name, key, json.dumps(value, default=str))
+
+    def remove_key_from_hash(self, name, key):
+        """
+        Remove a key-value pair from a hash
+
+        :param name: The name of the hash.
+        :param key: The key of the item to remove.
+        """
+        try:
+            self.client.hdel(name, key)
+        except Exception:
+            pass
+
+
+    def get_from_hash(self, name, key):
+        """
+        Get a value from a hash
+        :param name: The name of the hash.
+        :param key: The key of the item to get.
+        :returns: The value of the item.
+        """
+        try:
+            return json.loads(self.client.hget(name, key))
+        except Exception:
+            return None
+
+    def field_exists_in_hash(self, name, key):
+        """
+        Check if a field exists in a hash
+         :param name: The name of the hash.
+        :param key: The key of the item to get.
+        :returns: True if the field exists, False otherwise.
+        """
+        return self.client.hexists(name, key)
+
+
+    def get_all_keys_from_hash(self, name):
+        """
+        Get all keys from a hash
+        :param name: The name of the hash.
+        :returns: A list of all keys in the hash.
+        """
+        keys = list(self.client.hkeys(name))
+        return [key.decode("utf-8") for key in keys]
+
+   
+
+    def delete_hash(self, hash):
+        try:
+            if isinstance(hash, str):
+                self.client.delete(hash)
+            else:
+                self.client.delete(*hash)
+        except Exception:
+            pass
+
+    def check_hash_exists(self, hash_key):
+        if self.client.exists(hash_key) and self.client.type(hash_key) == b"hash":
+            return True
+        return False

packages/backend-server/app/framework/permission_services/permissions.py

@@ -0,0 +1,29 @@
+from app.framework.valkey.client import ValkeyClient
+from app.utils.utils import generate_query_hash
+
+valkey_client = ValkeyClient()
+
+
+
+def add_secret( project_id, secret_type, query, secret_value):
+    query_hash = generate_query_hash(query)
+    valkey_client.add_key_to_hash(
+        f"{project_id}:{secret_type}", query_hash, secret_value
+    )
+
+
+def get_secret( project_id, secret_type, query):
+    query_hash = generate_query_hash(query)
+    return valkey_client.get_from_hash(
+        f"{project_id}:{secret_type}", query_hash
+    )
+
+
+def delete_secret( project_id, secret_type):
+    valkey_client.delete_hash(f"{project_id}:{secret_type}")
+
+def check_secret_exists( project_id, secret_type, query):
+    query_hash = generate_query_hash(query)
+    return valkey_client.field_exists_in_hash(
+        f"{project_id}:{secret_type}", query_hash
+    )