backo 0.0.1__py3-none-any.whl

backo/__init__.py

@@ -0,0 +1,25 @@
+"""
+Module backo.
+export all classes
+"""
+
+from .item import Item
+from .db_yml_connector import DBYmlConnector
+from .db_mongo_connector import DBMongoConnector
+from .current_user import current_user
+from .error import Error, ErrorType
+from .backoffice import Backoffice
+from .collection import Collection
+from .view import View
+from .log import Logger, log_system
+from .reference import Ref, RefsList, FillStrategy, DeleteStrategy
+from .meta_data_handler import GenericMetaDataHandler, StandardMetaDataHandler
+from .status import StatusType
+from .action import Action
+from .request_decorators import (
+    check_json,
+    check_method,
+    return_http_error,
+    error_to_http_handler,
+)
+from .api_toolbox import multidict_to_filter

backo/action.py

@@ -0,0 +1,89 @@
+"""
+Module providing the action
+"""
+
+# pylint: disable=wrong-import-position, no-member, import-error, protected-access, wrong-import-order, attribute-defined-outside-init
+
+
+import sys
+
+sys.path.insert(1, "../../stricto")
+from stricto import Dict
+
+from .log import log_system
+from .error import Error, ErrorType
+from .item import Item
+
+log = log_system.get_or_create_logger("action")
+
+
+class Action(Dict):  # pylint: disable=too-many-instance-attributes
+    """
+    An action
+    """
+
+    def __init__(self, schema: dict, on_trig, **kwargs):
+        """
+        available arguments
+        """
+        self.backoffice = None
+        self.name = None
+        self.collection = None
+        self.on_trig = on_trig
+
+        # Add default right
+        if "can_execute" not in kwargs:
+            kwargs["can_execute"] = True
+        if "can_see" not in kwargs:
+            kwargs["can_see"] = True
+        kwargs["can_read"] = True
+        kwargs["can_modify"] = True
+        kwargs["exists"] = True
+
+        Dict.__init__(self, schema, **kwargs)
+
+    def check_params(self, param_name, o: Item) -> bool:
+        """
+        Check if can execute the action
+        """
+        p = self._params.get(param_name, False)
+        if not callable(p):
+            return bool(p)
+        return bool(p(self.backoffice, self.collection, self, o))
+
+    def can_see(self, o: Item) -> bool:
+        """
+        Check if this action exists for running
+        """
+        return self._rights.has_right("see", self, o)
+
+    def can_execute(self, o: Item) -> bool:
+        """
+        Check if can execute the action
+        object can be a Dict, a array of Dict, or None, depends ont the target for this actopn
+        """
+        return self._rights.has_right("execute", self, o)
+
+    def go(self, o: Item) -> None:
+        """
+        Launch the action
+
+        objeoct is the object (if exists)
+        """
+
+        if not self.can_see(o):
+            log.error("Try to launch non available action %r", self.name)
+            raise Error(
+                ErrorType.ACTION_NOT_AVAILABLE,
+                f"action {self.name} not available",
+            )
+
+        if not self.can_execute(o):
+            log.error("Try to execute forbidden action %r", self.name)
+            raise Error(
+                ErrorType.ACTION_FORBIDDEN,
+                f"action {self.name} forbidden",
+            )
+
+        log.debug("Execute action %r", self.name)
+        return self.on_trig(self, o)

backo/api_toolbox.py

@@ -0,0 +1,75 @@
+"""
+The toolbox for api
+A set of functions
+"""
+
+import re
+from werkzeug.datastructures import ImmutableMultiDict
+
+
+def _append_to_filter(filter_as_dict: dict, key, value: list):
+    """
+    adding key to dict with transformation to int or float if we can
+    """
+
+    # Transform string to int or float
+    typed_value = []
+    for v in value:
+        try:
+            vv = int(v)
+        except ValueError:
+            try:
+                vv = float(v)
+            except ValueError:
+                vv = v
+        typed_value.append(vv)
+
+    val = typed_value[0] if len(typed_value) == 1 else typed_value
+
+    match = re.search(r"^([^\.]+)\.(.*)", key)
+    if not match:
+        filter_as_dict[key] = val
+        return
+
+    # a toto.$gt (with an operator)
+    if re.findall(r"^\$", match.group(2)):
+        filter_as_dict[match.group(1)] = (match.group(2), val)
+        return
+
+    sub = filter_as_dict.get(match.group(1), {})
+    if not isinstance(sub, dict):
+        sub = {}
+
+    _append_to_filter(sub, match.group(2), value)
+    filter_as_dict[match.group(1)] = sub
+
+
+def multidict_to_filter(md: ImmutableMultiDict):
+    """
+    Transform a multi dict to filter (query string are immutable dict)
+
+    see match in stricto for definition of a filter
+    see https://tedboy.github.io/flask/generated/generated/werkzeug.ImmutableMultiDict.html
+
+
+    [ ('toto', 'miam'), ('titi.tutu', '23.2') ('tata.$gt', 11)] ->
+    {
+        'toto' : "miam",
+        'titi' : {
+            'tutu' : 23.2
+        },
+        'tata' : ( '$gt', 11 )
+    }
+    """
+
+    filter_as_dict = {}
+    for key in md.keys():
+
+        # ignoring keys starting with _
+        if re.match(r"^_.*", key):
+            continue
+
+        value = md.getlist(key)
+        _append_to_filter(filter_as_dict, key, value)
+
+    return filter_as_dict

backo/backoffice.py

@@ -0,0 +1,100 @@
+"""
+The Backoffice module
+"""
+
+import logging
+from flask import Flask
+
+from .item import Item
+from .transaction import Transaction, OperatorType
+from .collection import Collection
+from .log import log_system
+
+log = log_system.get_or_create_logger("backoffice", logging.DEBUG)
+
+
+class Backoffice:  # pylint: disable=too-many-instance-attributes
+    """
+    The main object, the aplication itself
+    """
+
+    def __init__(self, name: str):
+        """
+        initialize the backoffice with a name
+        """
+        self.name = name
+        self.collections = {}
+        self.transaction_id_reference = 1
+        self.transactions = {}
+
+    def register_collection(self, coll: Collection) -> None:
+        """
+        Register a collection into this backoffice
+        """
+        self.collections[coll.name] = coll
+        coll.backoffice = self
+        setattr(self, coll.name, coll)
+
+    def add_collection(self, coll: Collection) -> None:
+        """
+        Register a collection into the backoffice
+        """
+        return self.register_collection(coll)
+
+    def start_transaction(self) -> int:
+        """
+        Chose an Id and start the transaction structure
+        """
+        self.transaction_id_reference += 1
+        my_id = self.transaction_id_reference
+        self.transactions[my_id] = []
+        return my_id
+
+    def stop_transaction(self, transaction_id: int) -> None:
+        """
+        Close the transaction structure
+        """
+        del self.transactions[transaction_id]
+
+    def record_transaction(
+        self,
+        transaction_id: int,
+        collection: Collection,
+        operation: OperatorType,
+        _id: str,
+        obj: Item,
+    ) -> None:
+        """
+        Append an object to the transaction
+        """
+        if not transaction_id:
+            return
+        self.transactions[transaction_id].append(
+            Transaction(collection, operation, _id, obj)
+        )
+
+    def rollback_transaction(self, transaction_id: int) -> None:
+        """
+        An error occure, rollback objects
+        """
+        log.info(
+            "Rollback transactions %d with %d actions",
+            transaction_id,
+            len(self.transactions[transaction_id]),
+        )
+        while self.transactions[transaction_id]:
+            t = self.transactions[transaction_id].pop()
+            t.rollback(self)
+
+        del self.transactions[transaction_id]
+
+    def add_routes(self, flask_app: Flask, prefix: str = "") -> None:
+        """
+        Add all routes to flask application
+        """
+
+        my_path = f"/{prefix}/{self.name}/" if prefix else f"/{self.name}"
+        log.debug("Adding routes under %s", my_path)
+
+        for collection in self.collections.values():
+            collection.flask_add_routes(flask_app, my_path)

backo/collection.py

@@ -0,0 +1,415 @@
+"""
+The Collection module
+"""
+
+# pylint: disable=logging-fstring-interpolation
+import json
+import logging
+import re
+import sys
+
+from flask import Flask, request, session
+
+sys.path.insert(1, "../../stricto")
+from stricto import StrictoEncoder, Rights
+
+
+from .item import Item
+from .action import Action
+from .error import Error, ErrorType
+from .log import log_system
+from .request_decorators import error_to_http_handler
+from .api_toolbox import multidict_to_filter
+from .patch import Patch
+
+
+log = log_system.get_or_create_logger("collection", logging.DEBUG)
+
+
+class Collection:
+    """
+    The Collection refer to a "table"
+    """
+
+    def __init__(self, name, model: Item, db_handler, **kwargs):
+        """
+        available arguments
+        """
+        self.db_handler = db_handler
+        self.name = name
+        self.model = model.copy()
+        self.model.__dict__["_collection"] = self
+        self.model.set_db_handler(db_handler)
+
+        # Set rights
+        self._rights = Rights(read=True, create=True, delete=True, modify=True)
+        for key, right in kwargs.items():
+            a = re.findall(r"^can_(.*)$", key)
+            if a:
+                self._rights.add_or_modify_right(a[0], right)
+
+        # For filtering
+        self.refuse_filter = kwargs.pop("refuse_filter", None)
+
+        # For actions (aka some element work with datas)
+        self._actions = {}
+        self.backoffice = None
+
+        # For views
+        self._views = {}
+
+    def set(self, datas: dict | list) -> Item | list:
+        """
+        Set an object or a list of object
+        """
+        if isinstance(datas, dict):
+            o = self.new_item()
+            o.set(datas)
+            return o
+
+        if isinstance(datas, list):
+            l = []
+            for d in datas:
+                l.append(self.set(d))
+        return l
+
+    def define_view(self, name: str, list_of_selector: list) -> None:
+        """
+        add element into views
+        """
+        for selector in list_of_selector:
+            f = self.model.select(selector)
+            if f is None:
+                continue
+            if name not in f._views:
+                f._views.append(name)
+
+    def has_right(self, right_name: str, o: Item = None) -> bool:
+        """
+        Return the right for this collection
+        """
+        return self._rights.has_right(right_name, o)
+
+    def new_item(self):
+        """
+        return an Item
+        """
+        return self.model.copy()
+
+    def new(self):
+        """
+        return an Item
+        """
+        return self.new_item()
+
+    def create(self, obj: dict, **kwargs):
+        """
+        Create and save an item into the DB
+
+        transaction_id : The id of the transaction (used for rollback )
+        m_path : modification path, to avoid loop with references
+        """
+
+        if self._rights.has_right("create", None) is not True:
+            raise Error(
+                ErrorType.UNAUTHORIZED,
+                f"No rights to create in collection {self.name}.",
+            )
+
+        item = self.new_item()
+        item.create(obj, **kwargs)
+        return item
+
+    def get_other_collection(self, name):
+        """
+        Return another collection (ised by Ref and RefsList)
+        """
+        if self.backoffice is None:
+            raise Error(
+                ErrorType.COLLECTION_NOT_REGISTERED,
+                f"collection {self.name} not registered into an backoffice",
+            )
+        return self.backoffice.collections.get(name)
+
+    def register_action(self, name: str, action: Action):
+        """
+        add an action to this collection
+        this action will be related to an object
+        """
+        self._actions[name] = action
+        action.__dict__["backoffice"] = self.backoffice
+        action.__dict__["name"] = name
+        action.__dict__["collection"] = self
+
+    def add_action(self, name: str, action: Action):
+        """
+        add an action to this collection
+        this action will be related to an object
+        """
+        return self.register_action(name, action)
+
+    def drop(self):
+        """
+        Drop all elements
+        """
+        self.db_handler.drop()
+
+    def get_by_id(self, _id):
+        """
+        return an object by Id.
+        """
+
+        if self._rights.has_right("read", None) is not True:
+            raise Error(
+                ErrorType.UNAUTHORIZED,
+                f"No rights to create in collection {self.name}.",
+            )
+
+        obj = self.new_item()
+        obj.load(_id)
+        return obj
+
+    def select(
+        self,
+        db_filter,
+        match_filter=None,
+        view=None,
+        page_size=0,
+        num_of_element_to_skip=0,
+        db_sort_object={"_id": 1},
+    ):
+        """
+        Do a selection
+
+        db_filter : Is a filter related to the database system
+        match_filter : A filter for matching the object, independant
+                       from the db. See match() in stricto
+        view : The view we want (See views in stricto)
+
+        """
+
+        if self._rights.has_right("read", None) is not True:
+            raise Error(
+                ErrorType.UNAUTHORIZED,
+                f"No rights to read the entire collection {self.name}.",
+            )
+
+        # Do the DB selection without pagination
+        db_list = self.db_handler.select(db_filter, {}, 0, 0, db_sort_object)
+        if not isinstance(db_list, list):
+            raise Error(
+                ErrorType.SELECT_ERROR,
+                f"select {self.name} error",
+            )
+        result = {
+            "result": [],
+            "total": 0,
+            "_view": view,
+            "_skip": num_of_element_to_skip,
+            "_page": page_size,
+        }
+
+        # Get the restriction filter
+        # rfilter = (
+        #     self.refuse_filter() if callable(self.refuse_filter) else self.refuse_filter
+        # )
+
+        # Do the selection on the object
+        index = 0
+        log.debug(f"try match {match_filter} for {len(db_list)}")
+        for obj in db_list:
+            obj["_id"] = str(obj["_id"])
+            o = self.new_item()
+            o.set(obj)
+            o.set_status_saved()
+            # Do the post match filtering
+
+            # Ignore all elements matched by the refuse filter
+            if self._rights.has_right("read", o) is not True:
+                continue
+
+            if o.match(match_filter) is True:
+                if index >= num_of_element_to_skip:
+                    if page_size == 0 or (
+                        page_size > 0 and index < (num_of_element_to_skip + page_size)
+                    ):
+                        result["result"].append(o)
+                index += 1
+            else:
+                log.debug(f"Not matchs {match_filter} for {o}")
+
+        result["total"] = index
+        return result
+
+    def flask_add_routes(self, flask_app: Flask, my_path: str = "") -> None:
+        """
+        Add CRUD routes and add axtions routes
+        """
+
+        # read datas
+        if self._rights.get_strict_right("read") is not False:
+            # GET /<_id>
+            log.debug(f"Add routes GET {my_path}/coll/{self.name}/<string:_id>")
+
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}/<string:_id>",
+                f"get_{self.name}",
+                methods=["GET"],
+            )
+            flask_app.view_functions[f"get_{self.name}"] = self.http_get_by_id
+
+            # GET / - The selection
+            log.debug(f"Add routes GET {my_path}/coll/{self.name}")
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}", f"select_{self.name}", methods=["GET"]
+            )
+            flask_app.view_functions[f"select_{self.name}"] = self.filtering
+
+        # POST / Create data
+        if self._rights.get_strict_right("create") is not False:
+            log.debug(f"Add routes POST {my_path}/coll/{self.name}")
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}", f"create_{self.name}", methods=["POST"]
+            )
+            flask_app.view_functions[f"create_{self.name}"] = self.http_create
+
+        # PUT /<_id> Modify Data
+        if self._rights.get_strict_right("modify") is not False:
+            log.debug(f"Add routes PUT {my_path}/coll/{self.name}/<string:_id>")
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}/<string:_id>",
+                f"put_{self.name}",
+                methods=["PUT"],
+            )
+            flask_app.view_functions[f"put_{self.name}"] = self.http_modify
+
+        # PATCH /<_id> Modify Data
+        if self._rights.get_strict_right("modify") is not False:
+            log.debug(f"Add routes PATCH {my_path}/coll/{self.name}/<string:_id>")
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}/<string:_id>",
+                f"patch_one_{self.name}",
+                methods=["PATCH"],
+            )
+            flask_app.view_functions[f"patch_one_{self.name}"] = self.http_patch_one
+
+        # DELETE /<_id> Delete Data
+        if self._rights.get_strict_right("delete") is not False:
+            log.debug(f"Add routes DELETE {my_path}/coll/{self.name}/<string:_id>")
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}/<string:_id>",
+                f"delete_{self.name}",
+                methods=["DELETE"],
+            )
+            flask_app.view_functions[f"delete_{self.name}"] = self.http_delete
+
+        # CHECK /<_id> Check values
+        if self._rights.get_strict_right("read") is not False:
+            log.debug(f"Add routes POST {my_path}/check/{self.name}/<string:_id>")
+            flask_app.add_url_rule(
+                f"{my_path}/coll/{self.name}/<string:_id>",
+                f"delete_{self.name}",
+                methods=["DELETE"],
+            )
+            flask_app.view_functions[f"delete_{self.name}"] = self.http_delete
+
+    @error_to_http_handler
+    def http_get_by_id(self, _id: str):
+        """
+        GET HTTP
+        """
+        query = request.args
+        _view = query.get("_view", "client")
+
+        obj = self.new_item()
+        obj.load(_id)
+
+        log.debug(f"get by _id {_id} in {self.name} in view {_view}")
+        return (json.dumps(obj.get_view(_view), cls=StrictoEncoder), 200)
+
+    @error_to_http_handler
+    def filtering(self):
+        """
+        SELECT HTTP
+        """
+        query = request.args
+        _page = int(query.get("_page", 10))
+        _skip = int(query.get("_skip", 0))
+        _view = query.get("_view", "client")
+
+        match_filter = multidict_to_filter(query)
+
+        log.debug(f"filtering {self.name} with filter={match_filter}")
+
+        result = self.select(None, match_filter, _view, _page, _skip)
+        log.debug(
+            f"select in {self.name} {match_filter} {_view}/{_page} skip {_skip} -> {result}"
+        )
+
+        return (json.dumps(result, cls=StrictoEncoder), 200)
+
+    @error_to_http_handler
+    def http_create(self):
+        """
+        POST HTTP -> creation
+        """
+        query = request.args
+        _view = query.get("_view", "client")
+
+        log.debug(f"post {type(request.json)} {request.json}")
+        obj = self.create(request.json)
+
+        log.debug(f"create {obj._id} in {self.name} in view {_view}")
+        return (json.dumps(obj.get_view(_view), cls=StrictoEncoder), 200)
+
+    @error_to_http_handler
+    def http_modify(self, _id: str):
+        """
+        PUT HTTP -> modification of an object
+        """
+        query = request.args
+        _view = query.get("_view", "client")
+
+        log.debug(f"session {session.keys()}")
+
+        obj = self.new_item()
+        obj.load(_id)
+        obj.set(request.json)
+        obj.save()
+
+        return (json.dumps(obj.get_view(_view), cls=StrictoEncoder), 200)
+
+    @error_to_http_handler
+    def http_delete(self, _id: str):
+        """
+        DELETE HTTP -> deletion
+        """
+
+        obj = self.new_item()
+        obj.load(_id)
+        obj.delete()
+
+        return ("deleted", 200)
+
+    @error_to_http_handler
+    def http_patch_one(self, _id: str):
+        """
+        PATCH HTTP -> patch of an object
+        """
+        query = request.args
+        _view = query.get("_view", "client")
+
+        patch_list = request.json if isinstance(request.json, list) else [request.json]
+
+        obj = self.new_item()
+        obj.load(_id)
+
+        # apply patches
+        for p in patch_list:
+            patch = Patch()
+            patch.set(p)
+            obj.patch(patch.op, patch.path, patch.value)
+
+        obj.save()
+
+        return (json.dumps(obj.get_view(_view), cls=StrictoEncoder), 200)