bafser 1.0.2__py3-none-any.whl

bafser/__init__.py

@@ -0,0 +1,48 @@
+# base for flask server by Mixel Te
+
+from .utils.response_msg import response_msg
+from .utils.get_json_values import get_json_values
+
+from .utils.create_file_response import create_file_response
+from .utils.create_folder_for_file import create_folder_for_file
+from .utils.get_datetime_now import get_datetime_now
+from .utils.get_json import get_json
+from .utils.get_json_list_from_req import get_json_list_from_req
+from .utils.get_json_values_from_req import get_json_values_from_req
+from .utils.ip_to_emoji import ip_to_emoji, emoji_to_ip
+from .utils.jsonify_list import jsonify_list
+from .utils.parse_date import parse_date
+from .utils.permission_required import create_permission_required_decorator
+from .utils.permission_required import permission_required, permission_required_any
+from .utils.randstr import randstr
+from .utils.response_not_found import response_not_found
+from .utils.use_db_session import use_db_session
+from .utils.use_userId import use_userId, use_userId_optional
+from .utils.use_user import use_user
+from .utils.use_user_optional import use_user_optional
+
+from .app import AppConfig, create_app
+from .logger import get_logger_frontend, log_frontend_error, get_log_fpath, add_file_logger, ParametrizedLogger
+
+from .db_session import SqlAlchemyBase
+from .table_base import TableBase, IdMixin, ObjMixin
+from .data._tables import TablesBase
+from .data._roles import RolesBase
+from .data.operation import OperationsBase
+from .data.user_role import UserRole
+from .data.user import UserBase
+from .data.log import Log
+from .data.role import Role
+from .data.image import Image
+
+from .scripts.init_db_values import init_db_values
+
+
+class M:
+    DELETE = "DELETE"
+    GET = "GET"
+    HEAD = "HEAD"
+    OPTIONS = "OPTIONS"
+    PATCH = "PATCH"
+    POST = "POST"
+    PUT = "PUT"

bafser/app.py

@@ -0,0 +1,237 @@
+from datetime import datetime, timedelta, timezone
+from typing import Callable, Literal, Union
+import json
+import logging
+import os
+import time
+import traceback
+
+from flask import Flask, Response, abort, g, make_response, redirect, request, send_from_directory
+from flask_jwt_extended import JWTManager, create_access_token, get_jwt, get_jwt_identity, set_access_cookies, verify_jwt_in_request
+from urllib.parse import quote
+
+from bafser.scripts.init_db_values import init_db_values
+
+from . import db_session
+from .logger import get_logger_requests, setLogging
+from .utils import get_json, get_secret_key, get_secret_key_rnd, randstr, register_blueprints, response_msg
+import bfs_config
+
+
+class AppConfig():
+    is_admin_default = False
+    data_folders: list[tuple[str, str]] = []
+    config: list[tuple[str, str]] = []
+
+    def __init__(self,
+                 FRONTEND_FOLDER="build",
+                 IMAGES_FOLDER="images",
+                 JWT_ACCESS_TOKEN_EXPIRES: Union[Literal[False], timedelta] = False,
+                 JWT_ACCESS_TOKEN_REFRESH: Union[Literal[False], timedelta] = timedelta(minutes=30),
+                 CACHE_MAX_AGE=31536000,
+                 MESSAGE_TO_FRONTEND="",
+                 STATIC_FOLDERS: list[str] = ["/static/", "/fonts/"],
+                 DEV_MODE=False,
+                 DELAY_MODE=False,
+                 ):
+        self.FRONTEND_FOLDER = FRONTEND_FOLDER
+        self.IMAGES_FOLDER = IMAGES_FOLDER
+        self.JWT_ACCESS_TOKEN_EXPIRES = JWT_ACCESS_TOKEN_EXPIRES
+        self.JWT_ACCESS_TOKEN_REFRESH = JWT_ACCESS_TOKEN_REFRESH
+        self.CACHE_MAX_AGE = CACHE_MAX_AGE
+        self.MESSAGE_TO_FRONTEND = MESSAGE_TO_FRONTEND
+        self.STATIC_FOLDERS = STATIC_FOLDERS
+        self.DEV_MODE = DEV_MODE
+        self.DELAY_MODE = DELAY_MODE
+        self.add_data_folder("IMAGES_FOLDER", IMAGES_FOLDER)
+        self.add("CACHE_MAX_AGE", CACHE_MAX_AGE)
+
+    def add(self, key: str, value: str):
+        self.config.append((key, value))
+        return self
+
+    def add_data_folder(self, key: str, path: str):
+        self.add(key, path)
+        self.data_folders.append((key, path))
+        return self
+
+    def add_secret_key(self, key: str, path: str):
+        self.add(key, get_secret_key(path))
+        return self
+
+    def add_secret_key_rnd(self, key: str, path: str):
+        self.add(key, get_secret_key_rnd(path))
+        return self
+
+
+def create_app(import_name: str, config: AppConfig):
+    setLogging()
+    logreq = get_logger_requests()
+    app = Flask(import_name, static_folder=None)
+    app.config["JWT_TOKEN_LOCATION"] = ["cookies"]
+    app.config["JWT_SECRET_KEY"] = get_secret_key_rnd(bfs_config.jwt_key_file_path)
+    app.config["JWT_ACCESS_TOKEN_EXPIRES"] = config.JWT_ACCESS_TOKEN_EXPIRES
+    app.config["JWT_COOKIE_CSRF_PROTECT"] = False
+    app.config["JWT_SESSION_COOKIE"] = False
+    for (key, path) in config.config:
+        app.config[key] = path
+
+    jwt_manager = JWTManager(app)
+
+    def run(run_app: bool, init_dev_values: Callable[[], None] = None, port=5000):
+        for (_, path) in config.data_folders:
+            if not os.path.exists(path):
+                os.makedirs(path)
+
+        if config.DEV_MODE:
+            if not os.path.exists(bfs_config.db_dev_path):
+                os.makedirs(os.path.dirname(bfs_config.db_dev_path), exist_ok=True)
+                init_db_values(True)
+                if init_dev_values is not None:
+                    init_dev_values()
+
+        db_session.global_init(config.DEV_MODE)
+
+        if not config.DEV_MODE:
+            check_is_admin_default()
+
+        register_blueprints(app)
+        if run_app:
+            print("Starting")
+            if config.DELAY_MODE:
+                print("Delay for requests is enabled")
+            app.run(debug=True, port=port)
+
+    def check_is_admin_default():
+        from . import UserBase
+        db_sess = db_session.create_session()
+        admin = UserBase.get_by_login(db_sess, "admin", includeDeleted=True)
+        if admin is not None:
+            config.is_admin_default = admin.check_password("admin")
+        db_sess.close()
+
+    @app.before_request
+    def before_request():
+        g.json = get_json(request)
+        g.req_id = randstr(4)
+        try:
+            verify_jwt_in_request()
+            jwt_identity = get_jwt_identity()
+        except Exception:
+            jwt_identity = None
+        if jwt_identity and isinstance(jwt_identity, (list, tuple)) and len(jwt_identity) == 2:
+            g.userId = jwt_identity[0]
+        if request.path.startswith(bfs_config.api_url):
+            try:
+                if g.json[1]:
+                    if "password" in g.json[0]:
+                        password = g.json[0]["password"]
+                        g.json[0]["password"] = "***"
+                        data = json.dumps(g.json[0])[:512]
+                        g.json[0]["password"] = password
+                    else:
+                        data = json.dumps(g.json[0])[:512]
+                    logreq.info("Request;;%(data)s", {"data": data})
+                else:
+                    logreq.info("Request")
+            except Exception as x:
+                logging.error("Request logging error: %s", x)
+
+        if config.DELAY_MODE:
+            time.sleep(0.5)
+        if config.is_admin_default:
+            check_is_admin_default()
+            if config.is_admin_default:
+                # Admin password must be changed
+                return response_msg("Security error")
+
+    @app.after_request
+    def after_request(response: Response):
+        if request.path.startswith(bfs_config.api_url):
+            try:
+                if response.content_type == "application/json":
+                    logreq.info("Response;%s;%s", response.status_code, str(response.data)[:512])
+                else:
+                    logreq.info("Response;%s", response.status_code)
+            except Exception as x:
+                logging.error("Request logging error: %s", x)
+
+        response.set_cookie("MESSAGE_TO_FRONTEND", quote(config.MESSAGE_TO_FRONTEND))
+
+        if config.JWT_ACCESS_TOKEN_REFRESH:
+            try:
+                exp_timestamp = get_jwt()["exp"]
+                now = datetime.now(timezone.utc)
+                target_timestamp = datetime.timestamp(now + config.JWT_ACCESS_TOKEN_REFRESH)
+                if target_timestamp > exp_timestamp:
+                    access_token = create_access_token(identity=get_jwt_identity())
+                    set_access_cookies(response, access_token)
+            except (RuntimeError, KeyError):
+                # Case where there is not a valid JWT
+                pass
+
+        return response
+
+    @app.route("/", defaults={"path": ""})
+    @app.route("/<path:path>")
+    def frontend(path):
+        if request.path.startswith(bfs_config.api_url):
+            abort(404)
+        if path != "" and os.path.exists(config.FRONTEND_FOLDER + "/" + path):
+            res = send_from_directory(config.FRONTEND_FOLDER, path)
+            if any(request.path.startswith(path) for path in config.STATIC_FOLDERS):
+                res.headers.set("Cache-Control", f"public,max-age={config.CACHE_MAX_AGE},immutable")
+            else:
+                res.headers.set("Cache-Control", "no_cache")
+            return res
+        else:
+            res = send_from_directory(config.FRONTEND_FOLDER, "index.html")
+            res.headers.set("Cache-Control", "no_cache")
+            return res
+
+    @app.errorhandler(404)
+    def not_found(error):
+        if request.path.startswith(bfs_config.api_url):
+            return response_msg("Not found", 404)
+        return make_response("Страница не найдена", 404)
+
+    @app.errorhandler(405)
+    def method_not_allowed(error):
+        return response_msg("Method Not Allowed", 405)
+
+    @app.errorhandler(415)
+    def unsupported_media_type(error):
+        return response_msg("Unsupported Media Type", 415)
+
+    @app.errorhandler(403)
+    def no_permission(error):
+        return response_msg("No permission", 403)
+
+    @app.errorhandler(500)
+    @app.errorhandler(Exception)
+    def internal_server_error(error):
+        print(error)
+        logging.error("%s\n%s", error, traceback.format_exc())
+        if request.path.startswith(bfs_config.api_url):
+            return response_msg("Internal Server Error", 500)
+        return make_response("Произошла ошибка", 500)
+
+    @app.errorhandler(401)
+    def unauthorized(error):
+        if request.path.startswith(bfs_config.api_url):
+            return response_msg("Unauthorized", 401)
+        return redirect(bfs_config.login_page_url)
+
+    @jwt_manager.expired_token_loader
+    def expired_token_loader(jwt_header, jwt_data):
+        return response_msg("The JWT has expired", 401)
+
+    @jwt_manager.invalid_token_loader
+    def invalid_token_loader(error):
+        return response_msg("Invalid JWT", 401)
+
+    @jwt_manager.unauthorized_loader
+    def unauthorized_loader(error):
+        return response_msg("Unauthorized", 401)
+
+    return app, run

bafser/bfs_config.example.py

@@ -0,0 +1,16 @@
+db_dev_path = "db/dev.db"
+db_path = "ticketsystem:UR2hqJDbSfQ@ticketsystem.mysql.pythonanywhere-services.com/ticketsystem$default"
+sql_echo = False
+
+log_info_path = "logs/log_info.csv"
+log_requests_path = "logs/log_requests.csv"
+log_errors_path = "logs/log_errors.log"
+log_frontend_path = "logs/log_frontend.log"
+
+jwt_key_file_path = "secret_key_jwt.txt"
+
+login_page_url = "/login"
+api_url = "/api/"
+
+blueprints_folder = "blueprints"
+data_tables_folder = "data"

bafser/cli.py

@@ -0,0 +1,30 @@
+import importlib
+import sys
+
+
+def cli():
+    scripts = [
+        ("add_user_role", "userId roleId [dev]"),
+        ("add_user", "login password name roleId [dev]"),
+        ("change_user_password", "login new_password [dev]"),
+        ("init_db_values", "[dev]"),
+        ("remove_user_role", "userId roleId [dev]"),
+        ("update_roles_permissions", "[dev]"),
+    ]
+
+    if len(sys.argv) < 2 or sys.argv[1] not in map(lambda v: v[0], scripts):
+        ml = max(map(lambda v: len(v[0]), scripts))
+        ml2 = max(map(lambda v: len(v[1]), scripts))
+        l = ml + ml2 + 5
+        t = " Scripts "
+        l2 = (l - len(t))
+        print("-" * (l2 // 2) + t + "-" * (l2 // 2 + l2 % 2))
+        print("\n".join(map(lambda v: f"{' ' * (ml - len(v[0]))} {v[0]} : {v[1]}", scripts)))
+        print("-" * l)
+        return
+
+    importlib.import_module("scripts." + sys.argv[1], "bafser").run(sys.argv[2:])
+
+
+if __name__ == "__main__":
+    cli()

bafser/data/_roles.py

@@ -0,0 +1,39 @@
+from typing import Type, TypedDict
+
+from ..utils.get_all_vars import get_all_fields
+
+
+Roles: "Type[RolesBase]" = None
+
+
+def get_roles():
+    if Roles is None:
+        raise Exception("[BFS] No class inherited from RolesBase")
+    return Roles
+
+
+class RoleDesc(TypedDict):
+    name: str
+    operations: list[tuple[str, str]]
+
+
+TRole = int
+TRoles = dict[TRole, RoleDesc]
+
+
+class RolesBase:
+    admin = 1
+
+    ROLES: TRoles = {}
+
+    def __init_subclass__(cls, **kwargs):
+        global Roles
+        Roles = cls
+        fields = list(get_all_fields(cls()))
+        same = []
+        for i in range(len(fields)):
+            for k in range(i + 1, len(fields)):
+                if fields[i][1] == fields[k][1]:
+                    same.append((fields[i][0], fields[k][0], fields[i][1]))
+        if len(same) > 0:
+            raise Exception(f"[BFS] Same ids for Role: {'; '.join(f'{n1} and {n2} is {v}' for (n1, n2, v) in same)}")

bafser/data/_tables.py

@@ -0,0 +1,5 @@
+class TablesBase:
+    User = "User"
+    Role = "Role"
+    UserRole = "UserRole"
+    Image = "Image"

bafser/data/image.py

@@ -0,0 +1,109 @@
+from datetime import datetime
+from typing import Any, TypedDict, Union
+import base64
+import os
+
+from flask import current_app
+from sqlalchemy import Column, String, orm, ForeignKey, Integer, DateTime
+from sqlalchemy.orm import Session
+
+from .. import SqlAlchemyBase, ObjMixin, UserBase, Log, get_json_values, get_datetime_now, create_file_response
+from ._tables import TablesBase
+
+
+class ImageJson(TypedDict):
+    data: str
+    name: str
+
+
+TError = str
+TFieldName = str
+TValue = Any
+
+
+class Image(SqlAlchemyBase, ObjMixin):
+    __tablename__ = TablesBase.Image
+
+    name = Column(String(128), nullable=False)
+    type = Column(String(16), nullable=False)
+    creationDate = Column(DateTime, nullable=False)
+    deletionDate = Column(DateTime, nullable=True)
+    createdById = Column(Integer, ForeignKey("User.id"), nullable=False)
+
+    creator = orm.relationship("User")
+
+    @classmethod
+    def new(cls, creator: UserBase, json: ImageJson) -> Union[tuple[None, TError], tuple["Image", None]]:
+        (data, name), values_error = get_json_values(json, "data", "name")
+        if values_error:
+            return None, values_error
+
+        data_splited = data.split(',')
+        if len(data_splited) != 2:
+            return None, "img data is not base64"
+
+        img_header, img_data = data_splited
+        img_header_splited = img_header.split(";")
+        if len(img_header_splited) != 2 or img_header_splited[1] != "base64":
+            return None, "img data is not base64"
+
+        img_header_splited_splited = img_header_splited[0].split(":")
+        if len(img_header_splited_splited) != 2:
+            return None, "img data is not base64"
+        mimetype = img_header_splited_splited[1]
+
+        if mimetype not in ["image/png", "image/jpeg", "image/gif"]:
+            return None, "img mimetype is not in [image/png, image/jpeg, image/gif]"
+
+        type = mimetype.split("/")[1]
+
+        db_sess = Session.object_session(creator)
+        now = get_datetime_now()
+        img, add_changes, err = cls._new(creator, json, {"name": name, "type": type, "createdById": creator.id, "creationDate": now})
+        if err:
+            return None, err
+        db_sess.add(img)
+        db_sess.commit()
+
+        path = img.get_path()
+        with open(path, "wb") as f:
+            f.write(base64.b64decode(img_data + '=='))
+
+        Log.added(img, creator, [
+            ("name", img.name),
+            ("type", img.type),
+            ("creationDate", img.creationDate.isoformat()),
+            ("createdById", img.createdById),
+            *add_changes,
+        ], now)
+
+        return img, None
+
+    @staticmethod
+    def _new(creator: UserBase, json: ImageJson, image_kwargs: dict) -> \
+            Union[tuple[None, None, TError], tuple["Image", list[tuple[TFieldName, TValue]], None]]:
+        img = Image(**image_kwargs)
+        return img, [], None
+
+    def create_file_response(self):
+        return create_file_response(self.get_path(), f"image/{self.type}", self.get_filename())
+
+    def delete(self, actor: UserBase, commit=True, now: datetime = None, db_sess: Session = None):
+        now = get_datetime_now() if now is None else now
+        self.deletionDate = now
+        super().delete(actor, commit, now, db_sess)
+
+    def restore(self, actor: UserBase, commit=True, now: datetime = None, db_sess: Session = None):
+        if not os.path.exists(self.get_path()):
+            return False
+        super().restore(actor, commit, now, db_sess)
+        return True
+
+    def get_path(self):
+        return os.path.join(current_app.config["IMAGES_FOLDER"], f"{self.id}.{self.type}")
+
+    def get_filename(self):
+        return self.name + "." + self.type
+
+    def get_dict(self):
+        return self.to_dict(only=("name", "type", "creationDate", "deletionDate", "createdById"))

bafser/data/log.py

@@ -0,0 +1,154 @@
+from datetime import datetime
+from typing import Any, Union
+
+from sqlalchemy import Column, DateTime, orm, Integer, String, JSON
+from sqlalchemy.orm import Session
+
+from .. import SqlAlchemyBase, TableBase, UserBase, IdMixin, get_datetime_now
+
+FieldName = str
+NewValue = Any
+OldValue = Any
+
+
+class Log(SqlAlchemyBase, IdMixin):
+    __tablename__ = "Log"
+
+    date = Column(DateTime, nullable=False)
+    actionCode = Column(String(16), nullable=False)
+    userId = Column(Integer, nullable=False)
+    userName = Column(String(64), nullable=False)
+    tableName = Column(String(16), nullable=False)
+    recordId = Column(Integer, nullable=False)
+    changes = Column(JSON, nullable=False)
+
+    def __repr__(self):
+        return f"<Log> [{self.id}] {self.date} {self.actionCode}"
+
+    def get_dict(self):
+        return self.to_dict(only=("id", "date", "actionCode", "userId", "userName", "tableName", "recordId", "changes"))
+
+    @staticmethod
+    def added(
+        record: TableBase,
+        actor: Union[UserBase, None],
+        changes: list[tuple[FieldName, NewValue]],
+        now: datetime = None,
+        commit=True,
+        db_sess: Session = None,
+    ):
+        if actor is None:
+            actor = UserBase.get_fake_system()
+        db_sess = db_sess if db_sess else Session.object_session(actor)
+        if now is None:
+            now = get_datetime_now()
+        log = Log(
+            date=now,
+            actionCode=Actions.added,
+            userId=actor.id,
+            userName=actor.name,
+            tableName=record.__tablename__,
+            recordId=-1,
+            changes=list(map(lambda v: (v[0], None, v[1]), changes))
+        )
+        db_sess.add(log)
+        if isinstance(record, IdMixin):
+            if record.id is not None:
+                log.recordId = record.id
+            elif commit:
+                db_sess.commit()
+                log.recordId = record.id
+        if commit:
+            db_sess.commit()
+        return log
+
+    @staticmethod
+    def updated(
+        record: TableBase,
+        actor: Union[UserBase, None],
+        changes: list[tuple[FieldName, OldValue, NewValue]],
+        now: datetime = None,
+        commit=True,
+        db_sess: Session = None,
+    ):
+        if actor is None:
+            actor = UserBase.get_fake_system()
+        db_sess = db_sess if db_sess else Session.object_session(actor)
+        if now is None:
+            now = get_datetime_now()
+        log = Log(
+            date=now,
+            actionCode=Actions.updated,
+            userId=actor.id,
+            userName=actor.name,
+            tableName=record.__tablename__,
+            recordId=record.id if isinstance(record, IdMixin) else -1,
+            changes=changes
+        )
+        db_sess.add(log)
+        if commit:
+            db_sess.commit()
+        return log
+
+    @staticmethod
+    def deleted(
+        record: TableBase,
+        actor: Union[UserBase, None],
+        changes: list[tuple[FieldName, OldValue]] = [],
+        now: datetime = None,
+        commit=True,
+        db_sess: Session = None,
+    ):
+        if actor is None:
+            actor = UserBase.get_fake_system()
+        db_sess = db_sess if db_sess else Session.object_session(actor)
+        if now is None:
+            now = get_datetime_now()
+        log = Log(
+            date=now,
+            actionCode=Actions.deleted,
+            userId=actor.id,
+            userName=actor.name,
+            tableName=record.__tablename__,
+            recordId=record.id if isinstance(record, IdMixin) else -1,
+            changes=list(map(lambda v: (v[0], v[1], None), changes))
+        )
+        db_sess.add(log)
+        if commit:
+            db_sess.commit()
+        return log
+
+    @staticmethod
+    def restored(
+        record: TableBase,
+        actor: Union[UserBase, None],
+        changes: list[tuple[FieldName, OldValue, NewValue]] = [],
+        now: datetime = None,
+        commit=True,
+        db_sess: Session = None,
+    ):
+        if actor is None:
+            actor = UserBase.get_fake_system()
+        db_sess = db_sess if db_sess else Session.object_session(actor)
+        if now is None:
+            now = get_datetime_now()
+        log = Log(
+            date=now,
+            actionCode=Actions.restored,
+            userId=actor.id,
+            userName=actor.name,
+            tableName=record.__tablename__,
+            recordId=record.id if isinstance(record, IdMixin) else -1,
+            changes=changes
+        )
+        db_sess.add(log)
+        if commit:
+            db_sess.commit()
+        return log
+
+
+class Actions:
+    added = "added"
+    updated = "updated"
+    deleted = "deleted"
+    restored = "restored"

bafser/data/operation.py

@@ -0,0 +1,38 @@
+from typing import Generator, Type
+
+from sqlalchemy import Column, String
+
+from .. import SqlAlchemyBase
+from ..utils import get_all_values
+
+
+class Operation(SqlAlchemyBase):
+    __tablename__ = "Operation"
+
+    id = Column(String(32), primary_key=True, unique=True)
+    name = Column(String(32), nullable=False)
+
+    def __repr__(self):
+        return f"<Operation> [{self.id}] {self.name}"
+
+    def get_dict(self):
+        return self.to_dict(only=("id", "name"))
+
+
+class OperationsBase:
+    @classmethod
+    def get_all(cls) -> Generator[tuple[str, str], None, None]:
+        return get_all_values(cls())
+
+    def __init_subclass__(cls, **kwargs):
+        global Operations
+        Operations = cls
+
+
+Operations: Type[OperationsBase] = None
+
+
+def get_operations():
+    if Operations is None:
+        raise Exception("[BFS] No class inherited from OperationsBase")
+    return Operations