Merge pull request #69 from zecrypt-io/preview

Preview update from main

Author: anandude

packages/backend-server/app/api/v1/web/auth/api.py

@@ -78,6 +78,9 @@ async def get_keys_api(user: UserDetails = Depends(get_current_user)):
 
 @router.post(UPDATE_KEYS)
 async def update_keys_api(
-    request: Request, payload: UpdateKeys, user: UserDetails = Depends(get_current_user)
+    request: Request,
+    payload: UpdateKeys,
+    background_tasks: BackgroundTasks,
+    user: UserDetails = Depends(get_current_user),
 ):
-    return update_keys(db, user, payload.model_dump())
+    return update_keys(db, user, payload.model_dump(), background_tasks)

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

@@ -99,6 +99,7 @@ def create_user(request, db, auth_data, back_ground_tasks):
         "profile_url": auth_data.get("profile_image_url"),
         "language": "en",
         "workspace_ids": [workspace_id],
+        "plan": "free",
         "auth": {
             "has_password": auth_data.get("has_password"),
             "otp_auth_enabled": auth_data.get("otp_auth_enabled"),
@@ -191,6 +192,7 @@ def verify_two_factor_auth(request, db, payload, response, back_ground_tasks):
         "language": "en",
         "token": token,
         "refresh_token": refresh_token,
+        "plan":user.get("plan")
     }
     return response_helper(200, translate("auth.two_factor_auth_verified"), data=data)
 
@@ -205,7 +207,7 @@ def get_keys(db, user_id):
     )
 
 
-def update_keys(db, user, payload):
+def update_keys(db, user, payload, background_tasks):
     data = {
         "user_id": user.get("user_id"),
         "public_key": payload.get("public_key"),
@@ -214,4 +216,6 @@ def update_keys(db, user, payload):
     if user_keys_manager.find_one(db, {"user_id": user.get("user_id")}):
         return response_helper(400, translate("auth.keys_already_exist"))
     user_keys_manager.insert_one(db, data)
+    # background_tasks.add_task(send_welcome_email, db, user)
     return response_helper(200, translate("auth.keys_updated"))
+

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

@@ -133,7 +133,6 @@ def get_tags(db, project_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/route_constants.py

@@ -43,6 +43,10 @@
 NOTES = BASE_URL + "/notes"
 NOTE_DETAILS = BASE_URL + "/notes/{doc_id}"
 
+# ENV
+ENV = BASE_URL + "/env"
+ENV_DETAILS = BASE_URL + "/env/{doc_id}"
+
 # Dashboard
 DASHBOARD_OVERVIEW = "/{workspace_id}/{project_id}/dashboard/overview"
 DASHBOARD_RECENT_ACTIVITY = "/{workspace_id}/{project_id}/dashboard/recent-activity"

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

@@ -10,6 +10,7 @@
 from app.api.v1.web.secrets.ssh_keys import api as ssh_keys_router
 from app.api.v1.web.secrets.notes import api as notes_router
 from app.api.v1.web.secrets.password_history import api as password_history_router
+from app.api.v1.web.secrets.environment import api as env_router
 
 secrets_router = APIRouter()
 
@@ -29,3 +30,4 @@
 secrets_router.include_router(
     password_history_router.router, tags=["Secrets: Password History"]
 )
+secrets_router.include_router(env_router.router, tags=["Secrets: Env"])

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

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Request, Depends, BackgroundTasks
+
+from app.api.v1.web.secrets.environment.schema import UpdateEnv, AddEnv
+from app.api.v1.web.secrets.services import (
+    delete_secret,
+    update_secret,
+    add_secret,
+    get_secrets,
+)
+from app.api.v1.web.auth.schema import UserDetails
+from app.framework.permission_services.service import get_current_user
+from app.api.v1.web.route_constants import ENV_DETAILS, ENV
+from app.utils.constants import SECRET_TYPE_ENV as data_type
+
+router = APIRouter()
+
+
+@router.get(ENV)
+async def get_env_api(
+    request: Request,
+    workspace_id: str,
+    project_id: str,
+    user: UserDetails = Depends(get_current_user),
+):
+    return await get_secrets(request, user, data_type)
+
+
+@router.post(ENV)
+async def create_env_api(
+    request: Request,
+    workspace_id: str,
+    project_id: str,
+    payload: AddEnv,
+    background_tasks: BackgroundTasks,
+    user: UserDetails = Depends(get_current_user),
+):
+    return await add_secret(
+        request, user, data_type, payload.model_dump(), background_tasks
+    )
+
+
+@router.put(ENV_DETAILS)
+async def update_env_api(
+    request: Request,
+    workspace_id: str,
+    project_id: str,
+    doc_id: str,
+    payload: UpdateEnv,
+    background_tasks: BackgroundTasks,
+    user: UserDetails = Depends(get_current_user),
+):
+    return await update_secret(
+        request, user, data_type, payload.model_dump(), background_tasks
+    )
+
+
+@router.delete(ENV_DETAILS)
+async def delete_env_api(
+    request: Request,
+    workspace_id: str,
+    project_id: str,
+    doc_id: str,
+    background_tasks: BackgroundTasks,
+    user: UserDetails = Depends(get_current_user),
+):
+    return await delete_secret(request, user, data_type, background_tasks)

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

@@ -0,0 +1,19 @@
+from typing import Optional, List, Any
+from pydantic import Field
+
+
+from app.framework.mongo_db.base_model import BaseModel
+
+
+class AddEnv(BaseModel):
+    title: str
+    data: Optional[Any] = None
+    notes: Optional[str] = None
+    tags: Optional[List[str]] = Field(default_factory=list)
+
+
+class UpdateEnv(BaseModel):
+    title: Optional[str] = None
+    data: Optional[Any] = None
+    notes: Optional[str] = None
+    tags: Optional[List[str]] = None

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

@@ -2,12 +2,10 @@
 from app.utils.utils import create_uuid, response_helper, filter_payload
 from app.managers import secrets as secrets_manager
 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
 
 
-
 async def get_secrets(request, user, data_type):
     db = user.get("db")
     page = request.query_params.get("page", None)
@@ -19,7 +17,9 @@ async def get_secrets(request, user, data_type):
     }
     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))
+        return response_helper(
+            200, translate(f"{data_type}.list"), data=data, count=len(data)
+        )
 
     if page and limit:
         skip = (page - 1) * limit

packages/backend-server/app/framework/valkey/client.py

@@ -7,15 +7,13 @@
 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
@@ -40,7 +38,6 @@ def remove_key_from_hash(self, name, key):
         except Exception:
             pass
 
-
     def get_from_hash(self, name, key):
         """
         Get a value from a hash
@@ -62,7 +59,6 @@ def field_exists_in_hash(self, name, key):
         """
         return self.client.hexists(name, key)
 
-
     def get_all_keys_from_hash(self, name):
         """
         Get all keys from a hash
@@ -72,8 +68,6 @@ def get_all_keys_from_hash(self, name):
         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):

packages/backend-server/app/framework/valkey/services.py

@@ -4,26 +4,22 @@
 valkey_client = ValkeyClient()
 
 
-
-def add_secret( project_id, secret_type, query, secret_value):
+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):
+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
-    )
+    return valkey_client.get_from_hash(f"{project_id}:{secret_type}", query_hash)
 
 
-def delete_secret( project_id, secret_type):
+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):
+
+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
-    )
+    return valkey_client.field_exists_in_hash(f"{project_id}:{secret_type}", query_hash)