evyos-center-server/wag-managment-api-service-version-4
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

updated docs

Browse Source
This commit is contained in:
berkay
2025-01-22 21:46:11 +03:00
parent 87e5f5ab06
commit 1ba2694a9d
50 changed files with 3342 additions and 401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
Services/Redis/Actions/actions.py
View File

@@ -1,9 +1,9 @@
import json
import arrow
from typing import Optional, List, Dict, Union
from AllConfigs.main import MainConfig
from Services.Redis.conn import redis_cli
from Services.Redis.Models.base import RedisRow
from Services.Redis.Models.response import RedisResponse
@@ -21,6 +21,24 @@ class RedisActions:
for unit, multiplier in time_multipliers.items()
)
@classmethod
def set_expiry_time(cls, expiry_seconds: int) -> Dict[str, int]:
"""Convert total seconds back into a dictionary of time units."""
time_multipliers = {"days": 86400, "hours": 3600, "minutes": 60, "seconds": 1}
result = {}
for unit, multiplier in time_multipliers.items():
if expiry_seconds >= multiplier:
result[unit], expiry_seconds = divmod(expiry_seconds, multiplier)
return result
@classmethod
def resolve_expires_at(cls, redis_row: RedisRow) -> str:
"""Resolve expiry time for Redis key."""
expiry_time = redis_cli.ttl(redis_row.redis_key)
if expiry_time == -1:
return "Key has no expiry time."
return arrow.now().shift(seconds=expiry_time).format(MainConfig.DATETIME_FORMAT)
@classmethod
def delete_key(cls, key: Union[Optional[str], Optional[bytes]]):
try:
@@ -41,7 +59,7 @@ class RedisActions:
cls, list_keys: List[Union[Optional[str], Optional[bytes]]]
) -> RedisResponse:
try:
regex = RedisRow.regex(list_keys=list_keys)
regex = RedisRow().regex(list_keys=list_keys)
json_get = redis_cli.scan_iter(match=regex)
for row in list(json_get):
@@ -100,14 +118,6 @@ class RedisActions:
error=str(e),
)
@classmethod
def resolve_expires_at(cls, redis_row: RedisRow) -> str:
"""Resolve expiry time for Redis key."""
expiry_time = redis_cli.ttl(redis_row.redis_key)
if expiry_time == -1:
return "Key has no expiry time."
return arrow.now().shift(seconds=expiry_time).format(MainConfig.DATETIME_FORMAT)
@classmethod
def get_json(
cls, list_keys: List[Union[Optional[str], Optional[bytes]]]
@@ -120,8 +130,14 @@ class RedisActions:
for row in list(json_get):
redis_row = RedisRow()
redis_row.set_key(key=row)
redis_row.expires_at = cls.resolve_expires_at(redis_row=redis_row)
redis_value = redis_cli.get(redis_row.redis_key)
redis_value = redis_cli.get(row)
redis_value_expire = redis_cli.ttl(row)
redis_row.expires_at = cls.set_expiry_time(
expiry_seconds=int(redis_value_expire)
)
redis_row.expires_at_string = cls.resolve_expires_at(
redis_row=redis_row
)
redis_row.feed(redis_value)
list_of_rows.append(redis_row)
if list_of_rows:

104
Services/Redis/Models/base.py
View File

@@ -10,7 +10,7 @@ This module provides a class for managing Redis key-value operations with suppor
import json
from typing import Union, Dict, List, Optional, Any, ClassVar
from datetime import datetime
from Services.Redis.conn import redis_cli
class RedisKeyError(Exception):
@@ -44,23 +44,21 @@ class RedisRow:
key: ClassVar[Union[str, bytes]]
value: ClassVar[Any]
delimiter: ClassVar[str] = ":"
delimiter: str = ":"
expires_at: Optional[dict] = {"seconds": 60 * 60 * 30}
expires_at_string: Optional[str]
@classmethod
def get_expiry_time(cls) -> int | None:
def get_expiry_time(self) -> int | None:
"""Calculate expiry time in seconds from kwargs."""
time_multipliers = {"days": 86400, "hours": 3600, "minutes": 60, "seconds": 1}
if cls.expires_at:
if self.expires_at:
return sum(
int(cls.expires_at.get(unit, 0)) * multiplier
int(self.expires_at.get(unit, 0)) * multiplier
for unit, multiplier in time_multipliers.items()
)
return
@classmethod
def merge(cls, set_values: List[Union[str, bytes]]) -> None:
def merge(self, set_values: List[Union[str, bytes]]) -> None:
"""
Merge list of values into a single delimited key.
@@ -83,7 +81,7 @@ class RedisRow:
value = value.decode()
merged.append(str(value))
cls.key = cls.delimiter.join(merged).encode()
self.key = self.delimiter.join(merged).encode()
@classmethod
def regex(cls, list_keys: List[Union[str, bytes, None]]) -> str:
@@ -120,12 +118,11 @@ class RedisRow:
# Add wildcard if first key was None
if list_keys[0] is None:
pattern = f"*{cls.delimiter}{pattern}"
if "*" not in pattern:
if "*" not in pattern and any([list_key is None for list_key in list_keys]):
pattern = f"{pattern}:*"
return pattern
@classmethod
def parse(cls) -> List[str]:
def parse(self) -> List[str]:
"""
Parse the key into its component parts.
@@ -137,14 +134,13 @@ class RedisRow:
>>> RedisRow.parse()
['users', '123', 'profile']
"""
if not cls.key:
if not self.key:
return []
key_str = cls.key.decode() if isinstance(cls.key, bytes) else cls.key
return key_str.split(cls.delimiter)
key_str = self.key.decode() if isinstance(self.key, bytes) else self.key
return key_str.split(self.delimiter)
@classmethod
def feed(cls, value: Union[bytes, Dict, List, str]) -> None:
def feed(self, value: Union[bytes, Dict, List, str]) -> None:
"""
Convert and store value in JSON format.
@@ -161,18 +157,17 @@ class RedisRow:
"""
try:
if isinstance(value, (dict, list)):
cls.value = json.dumps(value)
self.value = json.dumps(value)
elif isinstance(value, bytes):
cls.value = json.dumps(json.loads(value.decode()))
self.value = json.dumps(json.loads(value.decode()))
elif isinstance(value, str):
cls.value = value
self.value = value
else:
raise RedisValueError(f"Unsupported value type: {type(value)}")
except json.JSONDecodeError as e:
raise RedisValueError(f"Invalid JSON format: {str(e)}")
@classmethod
def modify(cls, add_dict: Dict) -> None:
def modify(self, add_dict: Dict) -> None:
"""
Modify existing data by merging with new dictionary.
@@ -187,15 +182,17 @@ class RedisRow:
"""
if not isinstance(add_dict, dict):
raise RedisValueError("modify() requires a dictionary argument")
current_data = cls.data if cls.data else {}
current_data = self.row if self.row else {}
if not isinstance(current_data, dict):
raise RedisValueError("Cannot modify non-dictionary data")
current_data = {
**current_data,
**add_dict,
}
self.feed(current_data)
self.save()
cls.feed({**current_data, **add_dict})
@classmethod
def save(cls):
def save(self):
"""
Save the data to Redis with optional expiration.
@@ -204,29 +201,28 @@ class RedisRow:
RedisValueError: If value is not set
"""
import arrow
from Services.Redis.conn import redis_cli
if not cls.key:
if not self.key:
raise RedisKeyError("Cannot save data without a key")
if not cls.value:
if not self.value:
raise RedisValueError("Cannot save empty data")
if cls.expires_at:
redis_cli.setex(name=cls.redis_key, time=cls.expires_at, value=cls.value)
cls.expires_at_string = str(
if self.expires_at:
redis_cli.setex(
name=self.redis_key, time=self.get_expiry_time(), value=self.value
)
self.expires_at_string = str(
arrow.now()
.shift(seconds=cls.get_expiry_time())
.shift(seconds=self.get_expiry_time())
.format("YYYY-MM-DD HH:mm:ss")
)
return cls.value
return self.value
redis_cli.set(name=self.redis_key, value=self.value)
self.expires_at = None
self.expires_at_string = None
return self.value
redis_cli.set(name=cls.redis_key, value=cls.value)
cls.expires_at = None
cls.expires_at_string = None
return cls.value
@classmethod
def remove(cls, key: str) -> None:
def remove(self, key: str) -> None:
"""
Remove a key from the stored dictionary.
@@ -237,16 +233,24 @@ class RedisRow:
KeyError: If key doesn't exist
RedisValueError: If stored value is not a dictionary
"""
current_data = cls.data
current_data = self.row
if not isinstance(current_data, dict):
raise RedisValueError("Cannot remove key from non-dictionary data")
try:
current_data.pop(key)
cls.feed(current_data)
self.feed(current_data)
self.save()
except KeyError:
raise KeyError(f"Key '{key}' not found in stored data")
def delete(self) -> None:
"""Delete the key from Redis."""
try:
redis_cli.delete(self.redis_key)
except Exception as e:
print(f"Error deleting key: {str(e)}")
@property
def keys(self) -> str:
"""
@@ -257,8 +261,7 @@ class RedisRow:
"""
return self.key.decode() if isinstance(self.key, bytes) else self.key
@classmethod
def set_key(cls, key: Union[str, bytes]) -> None:
def set_key(self, key: Union[str, bytes]) -> None:
"""
Set key ensuring bytes format.
@@ -267,7 +270,7 @@ class RedisRow:
"""
if not key:
raise RedisKeyError("Cannot set empty key")
cls.key = key if isinstance(key, bytes) else str(key).encode()
self.key = key if isinstance(key, bytes) else str(key).encode()
@property
def redis_key(self) -> bytes:
@@ -280,7 +283,7 @@ class RedisRow:
return self.key if isinstance(self.key, bytes) else str(self.key).encode()
@property
def data(self) -> Union[Dict, List]:
def row(self) -> Union[Dict, List]:
"""
Get stored value as Python object.
@@ -290,6 +293,7 @@ class RedisRow:
try:
return json.loads(self.value)
except json.JSONDecodeError as e:
# return self.value
raise RedisValueError(f"Invalid JSON format in stored value: {str(e)}")
@property
@@ -302,5 +306,5 @@ class RedisRow:
"""
return {
"keys": self.keys,
"value": self.data,
"value": self.row,
}

25
Services/Redis/Models/response.py
View File

@@ -20,6 +20,8 @@ class RedisResponse:
self.data_type = "dict"
elif isinstance(data, list):
self.data_type = "list"
elif isinstance(data, RedisRow):
self.data_type = "row"
elif data is None:
self.data_type = None
self.error = error
@@ -30,12 +32,16 @@ class RedisResponse:
"status": self.status,
"message": self.message,
"count": self.count,
"dataType": self.data_type,
"dataType": getattr(self, "data_type", None),
}
if isinstance(data, RedisRow):
return {"data": {data.keys: data.data}, **main_dict}
dict_return = {data.keys: data.row}
dict_return.update(dict(main_dict))
return dict_return
elif isinstance(data, list):
return {"data": {row.keys: row.data for row in data}, **main_dict}
dict_return = {row.keys: row.data for row in data}
dict_return.update(dict(main_dict))
return dict_return
@property
def all(self) -> Union[Optional[List[RedisRow]]]:
@@ -43,11 +49,20 @@ class RedisResponse:
@property
def count(self) -> int:
return len(self.all)
print()
row = self.all
if isinstance(row, list):
return len(row)
elif isinstance(row, RedisRow):
return 1
@property
def first(self) -> Union[RedisRow, None]:
print("self.data", self.data)
if self.data:
return self.data[0]
if isinstance(self.data, list):
return self.data[0]
elif isinstance(self.data, RedisRow):
return self.row
self.status = False
return

101
Services/Redis/howto.py
View File

@@ -1,39 +1,76 @@
import secrets
import uuid
import random
from uuid import uuid4
from Services.Redis import RedisActions, AccessToken
from Services.Redis.Actions.actions import RedisActions
from Services.Redis.Models.row import AccessToken
first_user = AccessToken(
accessToken=secrets.token_urlsafe(90),
userUUID=uuid.uuid4().__str__(),
)
second_user = AccessToken(
accessToken=secrets.token_urlsafe(90),
userUUID=uuid.uuid4().__str__(),
)
json_data = lambda uu_id, access: {
"uu_id": uu_id,
"access_token": access,
"user_type": 1,
"selected_company": None,
"selected_occupant": None,
"reachable_event_list_id": [],
def generate_token(length=32):
letters = "abcdefghijklmnopqrstuvwxyz"
merged_letters = [letter for letter in letters] + [
letter.upper() for letter in letters
]
token_generated = secrets.token_urlsafe(length)
for i in str(token_generated):
if i not in merged_letters:
token_generated = token_generated.replace(
i, random.choice(merged_letters), 1
)
return token_generated
save_json = {
"user": {
"first_name": "John",
"last_name": "Doe",
"email": "johndoe@glu.com",
"phone": "1234567890",
"address": "1234 Main St",
"details": {
"city": "San Francisco",
"state": "CA",
"zip": "94111",
},
},
"domain": "https://www.example.com",
"info": {
"mac": "oıuıouqqzxöç.işüğ",
"version": "1.0.0",
"type": "web",
"device": "desktop",
},
}
set_response_first_json = json_data(first_user.userUUID, first_user.accessToken)
set_response_second_json = json_data(second_user.userUUID, second_user.accessToken)
set_response_first = RedisActions.set_json(
list_keys=first_user.to_list(),
value=set_response_first_json,
expires={"seconds": 140},
)
set_response_second = RedisActions.set_json(
list_keys=second_user.to_list(),
value=set_response_second_json,
expires={"seconds": 190},
)
# access_object = AccessToken(
# userUUID=str(uuid4()),
# accessToken=generate_token(60)
# )
# redis_object = RedisActions.set_json(
# list_keys=access_object.to_list(),
# value=save_json,
# expires={"seconds": 720}
# )
# quit()
acc_token = "IuDXEzqzCSyOJvrwdjyxqGPOBnleUZjjXWsELJgUglJjyGhINOzAUpdMuzEzoTyOsJRUeEQsgXGUXrer:521a4ba7-898f-4204-a2e5-3226e1aea1e1"
search_keys = [None, set_response_first_json["uu_id"]]
get_response = RedisActions.get_json(list_keys=search_keys)
# print("get_response", [data.expires_at for data in get_response.all])
userUUID = acc_token.split(":")[1]
accessToken = acc_token.split(":")[0]
access_object = AccessToken(userUUID=None, accessToken=accessToken)
print("access_object", access_object.to_list())
redis_object = RedisActions.get_json(
list_keys=access_object.to_list(),
)
# print("type type(redis_object)", type(redis_object))
# print("type redis_object.data", type(redis_object.data))
# print("count", redis_object.count)
# print("data", redis_object.data)
# print("data", redis_object.as_dict())
# print("message", redis_object.message)
redis_row_object = redis_object.first
redis_row_object.modify({"reachable_event_list_id": [i for i in range(50)]})
# redis_row_object.remove("reachable_event_list_id")
# redis_row_object.modify({"reachable_event_list_id": [i for i in range(10)]})
# if redis_row_object:
# print("redis_row_object", redis_row_object.delete())
# print('redis_row_object.as_dict', redis_row_object.as_dict)