Initial commit

2024-02-15 00:17:51 +03:30
commit 4b0396466d
111 changed files with 6296 additions and 0 deletions
@@ -0,0 +1,146 @@
+from sqlalchemy import or_, and_, desc, asc
+from sqlalchemy.sql.elements import BooleanClauseList, BinaryExpression, UnaryExpression
+
+from .AbstractEngine import AbstractEngineClass
+from ..utils.Models import FilterItem, FilterScope
+
+
+class MsSqlEngine(AbstractEngineClass):
+
+    def set_joins(self):
+        pass
+
+    filters = {}
+    rows = []
+    sort = None
+
+    async def exe(self):
+        _f = self.set_filters()
+        if not self.custom_entities:
+            query = self.query_class.query(self.model)
+        else:
+            query = self.query_class.query(*self.custom_entities)
+        if self.joins:
+            for j in self.joins:
+                if isinstance(j, list):
+                    query = query.join(*j)
+                else:
+                    query = query.join(j)
+
+        if self.options:
+            query = query.options(*self.options)
+        tmp = query.filter(_f).order_by(self.set_sort())
+        self.rows = tmp.limit(self.input.get_limit()).offset(self.input.skip()).all()
+        return self.rows, tmp.count(), tmp
+
+    def query_generator(self):
+        if not self.input.has_filter():
+            return None
+        filters = self.input.filters()
+        query = self.generate_scope_filter(filters, general=True)
+        return query
+
+    def set_sort(self):
+        if self.input.o.field:
+            self.sort = asc(getattr(self.model, self.input.o.field)) if self.input.o.direction == 'asc' else desc(
+                getattr(self.model, self.input.o.field))
+            return self.sort
+        elif isinstance(self.default_sort_by, UnaryExpression):
+            return self.default_sort_by
+        else:
+            return True
+
+    def set_filters(self):
+        filters = []
+        query = self.query_generator()
+        if isinstance(query, BooleanClauseList) or isinstance(query, BinaryExpression):
+            filters.append(query)
+        if self.input.has_text_search():
+            items = []
+            _search_cols = self.input.get_search_cols() if (
+                    self.input.get_search_cols() and len(self.input.get_search_cols())) else self.search_cols
+            if _search_cols:
+                for col in _search_cols:
+                    has_join = len(col.split('.')) > 1
+                    if has_join:
+                        pass
+                    else:
+                        items.append(
+                            getattr(self.model, col).ilike("%{search}%".format(search=self.input.get_text_search())))
+                filters.append(or_(*items))
+        if self.input.extra_filter:
+            for f in self.input.extra_filter:
+                filters.append(f)
+        if not filters:
+            return True
+        self.filters = and_(*filters)
+        return self.filters
+
+    @staticmethod
+    def get_expression_filter(col=None, op: str = '', val: str = '') -> dict:
+        _op = MsSqlEngine.get_operator(op)
+        return getattr(col, op)(val)
+
+    @staticmethod
+    def get_operator(op: str):
+        ops = {
+            "eq": "__eq__",
+            "n_eq": "__ne__",
+            "gt": "__gt__",
+            "gte": "__ge__",
+            "lte": "__lte__",
+            "lt": "__lt__",
+            "like": "ilike",
+            "n_like": "notlike",
+            "in": "in_",
+            "n_in": "not_in",
+            "bet": "between",
+            "n_bet": "not_between",
+            "sw": "startswith",
+            "ew": "endswith",
+            'n_ew': 'not_endswith',
+            'n_sw': 'not_startswith',
+            'exi': 'exi',
+            "n_exi": "n_exi",
+        }
+        return ops[op] if op in ops else '__eq__'
+
+    @staticmethod
+    def get_and_or(op):
+        return or_ if op == 'or' else and_
+
+    def count(self):
+        pass
+
+    def filter_item_generator(self, item: FilterItem):
+        has_join = len(item.col.split('.')) > 1
+        if has_join:
+
+            pass
+        else:
+            return getattr(getattr(self.model, item.col), self.get_operator(item.op))(item.val)
+
+    def generate_scope_filter(self, filters: list, general=False):
+        if len(filters) == 1:
+            _o = filters[0]
+            if isinstance(_o, FilterItem):
+                return self.filter_item_generator(filters[0])
+            elif isinstance(_o, FilterScope):
+                return self.generate_scope_filter(_o.items)
+            else:
+                return _o
+        else:
+            _a = filters.pop(0)
+            _a = (self.filter_item_generator(_a) if isinstance(_a,
+                                                               FilterItem) else _a) if not general else (
+                self.generate_scope_filter(_a.items) if isinstance(_a, FilterScope) else _a)
+
+            _b = filters.pop(0)
+
+            _op = MsSqlEngine.get_and_or(_b.cr if not general else _b.op)
+            _b = (self.filter_item_generator(_b) if isinstance(_b,
+                                                               FilterItem) else _b) if not general else (
+                self.generate_scope_filter(_b.items) if isinstance(_b, FilterScope) else _b)
+
+            filters = [_op(_a, _b)] + filters
+            return self.generate_scope_filter(filters, general)