arpakitlib 1.8.39__tar.gz → 1.8.41__tar.gz

{arpakitlib-1.8.39 → arpakitlib-1.8.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.8.39
+Version: 1.8.41
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company

arpakitlib-1.8.41/arpakitlib/_arpakit_project_template_v_5/arpakitlib_project_template_info.json

@@ -0,0 +1,4 @@
+{
+  "arpakitlib_project_template_version": "5",
+  "arpakitlib_project_template_subversion": "9"
+}

arpakitlib-1.8.41/arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_settings.py

@@ -0,0 +1,42 @@
+import fastapi.requests
+from fastapi import APIRouter
+
+from project.api.authorize import APIAuthorizeData, api_authorize, require_api_key_dbm_api_authorize_middleware, \
+    require_user_token_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.api.schema.out.common.raw_data import RawDataCommonSO
+from project.core.settings import get_cached_settings
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class GetSettingsRouteSO(BaseRouteSO, RawDataCommonSO):
+    pass
+
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get settings",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=GetSettingsRouteSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthorizeData = fastapi.Depends(api_authorize(middlewares=[
+            require_api_key_dbm_api_authorize_middleware(
+                require_active=True
+            ),
+            require_user_token_dbm_api_authorize_middleware(
+                require_active_user_token=True,
+                require_user_roles=[UserDBM.Roles.admin]
+            )
+        ]))
+):
+    return GetSettingsRouteSO(
+        data=get_cached_settings().model_dump(mode="json")
+    )

{arpakitlib-1.8.39 → arpakitlib-1.8.41}/arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/main_router.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter
 from project.api.router.admin import get_auth_data, get_arpakitlib_project_template_info, raise_fake_error, \
     reinit_sqlalchemy_db, get_story_log, init_sqlalchemy_db, get_sqlalchemy_db_table_name_to_amount, \
     get_operation_allowed_statuses, get_operation, create_operation, get_operation_allowed_types, get_log_file, \
-    clear_log_file, check_sqlalchemy_db
+    clear_log_file, check_sqlalchemy_db, get_settings
 
 main_admin_api_router = APIRouter()
 
@@ -76,3 +76,8 @@ main_admin_api_router.include_router(
     router=check_sqlalchemy_db.api_router,
     prefix="/check_sqlalchemy_db"
 )
+
+main_admin_api_router.include_router(
+    router=get_settings.api_router,
+    prefix="/get_settings"
+)

arpakitlib-1.8.41/arpakitlib/_arpakit_project_template_v_5/project/sandbox/sandbox_1.py

@@ -0,0 +1,16 @@
+import asyncio
+
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+def __sandbox():
+    print(UserDBM.Roles.admin)
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

{arpakitlib-1.8.39 → arpakitlib-1.8.41}/arpakitlib/_arpakit_project_template_v_5/project/sqladmin_/admin_authorize.py

@@ -1,14 +1,15 @@
 import logging
 
 import fastapi
+import sqlalchemy
 from sqladmin.authentication import AuthenticationBackend
 
-from arpakitlib.ar_str_util import make_none_if_blank
+from arpakitlib.ar_str_util import make_none_if_blank, strip_if_not_none
 from project.core.settings import get_cached_settings
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import UserTokenDBM, UserDBM
 
-SQLADMIN_AUTH_KEY = "sqladmin_auth_key"
+SQLADMIN_AUTHORIZE_KEY = "sqladmin_authorize_key"
 
 
 class SQLAdminAuth(AuthenticationBackend):
@@ -19,15 +20,8 @@ class SQLAdminAuth(AuthenticationBackend):
     async def login(self, request: fastapi.Request) -> bool:
         form = await request.form()
 
-        username = form.get("username")
-        if username:
-            username = username.strip()
-        username = make_none_if_blank(username)
-
-        password = form.get("password")
-        if password:
-            password = password.strip()
-        password = make_none_if_blank(password)
+        username = make_none_if_blank(strip_if_not_none(form.get("username")))
+        password = make_none_if_blank(strip_if_not_none(form.get("password")))
 
         if (
                 get_cached_settings().sqladmin_authorize_keys is not None
@@ -43,23 +37,46 @@ class SQLAdminAuth(AuthenticationBackend):
                     )
             ):
                 if is_username_correct is True:
-                    request.session.update({SQLADMIN_AUTH_KEY: username})
+                    request.session.update({SQLADMIN_AUTHORIZE_KEY: username})
                 elif is_password_correct is True:
-                    request.session.update({SQLADMIN_AUTH_KEY: password})
+                    request.session.update({SQLADMIN_AUTHORIZE_KEY: password})
                 return True
 
         if get_cached_sqlalchemy_db() is not None and (username is not None or password is not None):
             with get_cached_sqlalchemy_db().new_session() as session:
-                query = session.query(UserTokenDBM)
+                query = session.query(UserTokenDBM).filter(UserTokenDBM.is_active == True)
                 if username is not None:
                     query = query.filter(UserTokenDBM.value == username)
                 elif password is not None:
                     query = query.filter(UserTokenDBM.value == password)
+                else:
+                    raise ValueError("no username and no password")
                 user_token = query.one_or_none()
                 if user_token is not None and user_token.user.compare_roles(UserDBM.Roles.admin):
-                    request.session.update({SQLADMIN_AUTH_KEY: user_token.value})
+                    request.session.update({SQLADMIN_AUTHORIZE_KEY: user_token.value})
                     return True
 
+        if get_cached_sqlalchemy_db() is not None and (username is not None and password is not None):
+            query = session.query(UserDBM)
+            query = query.filter(UserDBM.is_active == True)
+            _or_conditions = [
+                UserDBM.long_id == username,
+                UserDBM.slug == username,
+                UserDBM.email == username,
+            ]
+            if username.isdigit():
+                _or_conditions.append(UserDBM.id == int(username))
+            query = query.filter(sqlalchemy.or_(*_or_conditions))
+            query = query.filter(UserDBM.password == password)
+            user_dbm: UserDBM | None = query.one_or_none()
+            if user_dbm is not None and user_dbm.compare_roles(UserDBM.Roles.admin):
+                new_user_token_dbm = UserTokenDBM(user_id=user_dbm.id)
+                session.add(new_user_token_dbm)
+                session.commit()
+                session.refresh(new_user_token_dbm)
+                request.session.update({SQLADMIN_AUTHORIZE_KEY: new_user_token_dbm.value})
+                return True
+
         return False
 
     async def logout(self, request: fastapi.Request) -> bool:
@@ -67,7 +84,7 @@ class SQLAdminAuth(AuthenticationBackend):
         return True
 
     async def authenticate(self, request: fastapi.Request) -> bool:
-        sqladmin_auth_key = request.session.get(SQLADMIN_AUTH_KEY)
+        sqladmin_auth_key = request.session.get(SQLADMIN_AUTHORIZE_KEY)
         if sqladmin_auth_key:
             sqladmin_auth_key = sqladmin_auth_key.strip()
         sqladmin_auth_key = make_none_if_blank(sqladmin_auth_key)
@@ -82,9 +99,11 @@ class SQLAdminAuth(AuthenticationBackend):
                     UserTokenDBM
                 ).filter(
                     UserTokenDBM.value == sqladmin_auth_key
+                ).filter(
+                    UserTokenDBM.is_active == True
                 )
-                user_token = query.one_or_none()
-                if user_token is not None and user_token.user.compare_roles(UserDBM.Roles.admin):
+                user_token_dbm: UserTokenDBM | None = query.one_or_none()
+                if user_token_dbm is not None and user_token_dbm.user.compare_roles(UserDBM.Roles.admin):
                     return True
 
         return False

{arpakitlib-1.8.39 → arpakitlib-1.8.41}/arpakitlib/_arpakit_project_template_v_5/project/sqladmin_/model_view/user.py

@@ -13,6 +13,7 @@ class UserMV(SimpleMV, model=UserDBM):
         UserDBM.email,
         UserDBM.roles,
         UserDBM.is_active,
+        UserDBM.password,
         UserDBM.tg_id,
         UserDBM.tg_bot_last_action_dt,
         UserDBM.tg_data,

{arpakitlib-1.8.39 → arpakitlib-1.8.41}/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/user.py

@@ -40,6 +40,11 @@ class UserDBM(SimpleDBM):
         server_default="true",
         nullable=False
     )
+    password: Mapped[str | None] = mapped_column(
+        sqlalchemy.TEXT,
+        index=True,
+        nullable=True
+    )
     tg_id: Mapped[int | None] = mapped_column(
         sqlalchemy.BIGINT,
         unique=True,

{arpakitlib-1.8.39 → arpakitlib-1.8.41}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arpakitlib"
-version = "1.8.39"
+version = "1.8.41"
 description = "arpakitlib"
 authors = [
     { name = "arpakit_support", email = "support@arpakit.com" }

arpakitlib-1.8.39/arpakitlib/_arpakit_project_template_v_5/arpakitlib_project_template_info.json

@@ -1,4 +0,0 @@
-{
-  "arpakitlib_project_template_version": "5",
-  "arpakitlib_project_template_subversion": "7"
-}

arpakitlib-1.8.39/arpakitlib/_arpakit_project_template_v_5/project/sandbox/sandbox_1.py

@@ -1,19 +0,0 @@
-import asyncio
-
-import sqlalchemy
-
-from project.sqlalchemy_db_.sqlalchemy_model import SimpleDBM
-
-
-def __sandbox():
-    a = sqlalchemy.inspect(SimpleDBM)
-    print(a)
-
-
-async def __async_sandbox():
-    pass
-
-
-if __name__ == '__main__':
-    __sandbox()
-    asyncio.run(__async_sandbox())