init

web/commons/models/__init__.py

@@ -0,0 +1,176 @@
+from datetime import datetime
+
+import time
+
+from nc_http.tools.helpers import camelize
+from sqlalchemy.orm.exc import NoResultFound
+
+from commons.models.atomic import Atomic
+
+
+class BaseModel:
+    query = None
+
+    _unique_fields = []
+    _db = None
+
+    __table__ = None
+
+    @classmethod
+    def atomic(cls):
+        return Atomic(db=cls._db)
+
+    @classmethod
+    def get_by_id(cls, id_, session=None):
+        if session:
+            query = session.query(cls)
+        else:
+            query = cls.query
+        result = query.filter((getattr(cls, 'id', None) or cls.__table__.primary_key) == id_).one_or_none()
+        return result
+
+    @classmethod
+    def insert_many(cls, dicts, commit=True, session=None):
+        session = session or cls._db.session()
+        session.bulk_insert_mappings(cls, dicts)
+        if commit:
+            session.commit()
+
+    @classmethod
+    def insert_one(cls, values, commit=True, session=None, return_obj=False):
+        session = session or cls._db.session()
+        if not return_obj:
+            session.bulk_insert_mappings(cls, [values])
+        else:
+            obj = cls()
+            for key, value in values.items():
+                setattr(obj, key, value)
+
+            session.add(obj)
+
+        if commit:
+            session.commit()
+
+        if return_obj:
+            return obj
+
+        return
+
+    @classmethod
+    def update_one(cls, values, commit=True, session=None):
+        session = session or cls._db.session()
+        session.bulk_update_mappings(cls, [values])
+        if commit:
+            session.commit()
+
+    @classmethod
+    def update_many(cls, dicts, commit=True, session=None):
+        session = session or cls._db.session()
+        session.bulk_update_mappings(cls, dicts)
+        if commit:
+            session.commit()
+
+    def to_dict(self, is_camelized=True):
+        _ = {}
+        for column in self.__table__.columns:
+            key = getattr(column, 'quote', None) or column.name
+            if is_camelized:
+                _[camelize(key)] = getattr(self, key, None)
+            else:
+                _[key] = getattr(self, key, None)
+        return _
+
+    @classmethod
+    def select_one(cls, query, fields=None):
+        try:
+            result = query.one()
+        except NoResultFound:
+            return {}
+
+        if not result:
+            return {}
+
+        return dict(zip([i.key for i in fields], result))
+
+    @classmethod
+    def test_one(cls):
+        result = cls.query.first()
+        return result.to_dict()
+
+    @classmethod
+    def now(cls):
+        return int(time.time())
+
+    @classmethod
+    def now_datetime(cls):
+        return datetime.fromtimestamp(int(time.time()))
+
+    @classmethod
+    def get_all(cls):
+        objects = cls.query.all()
+        for obj in objects:
+            yield obj.to_dict()
+
+    def update(self, commit=True, session=None, **kwargs):
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+        if commit:
+            session = session or self._db.session()
+            session.commit()
+
+        return
+
+    def delete(self, session=None):
+        session = session or self._db.session()
+        session.delete(self)
+
+    @classmethod
+    def get_list(cls, query, paging=None, fields=None):
+        if fields:
+            query = query.with_entities(*fields.values())
+
+        if paging:
+            page = query.paginate(paging['page'], paging['limit'])
+            paging['total'] = page.total
+            result = page.items
+        else:
+            result = query.all()
+
+        if fields:
+            columns = fields.keys()
+            result = [dict(zip(columns, _)) for _ in result]
+        else:
+            result = [_.to_dict() for _ in result]
+
+        if paging:
+            return result, paging
+
+        return result
+
+    @classmethod
+    def set_order_by(cls, query, sorting=None):
+        """
+        配置查询结果排序
+        :param query:
+        :param sorting:
+        :return:
+        """
+        if not sorting or not isinstance(sorting, dict):
+            return query
+
+        order_field = sorting.get('order_field')
+        if not order_field:
+            return query
+
+        order = sorting.get('order')
+        if order == 'desc':
+            query = query.order_by(getattr(cls, order_field).desc())
+        else:
+            query = query.order_by(getattr(cls, order_field))
+
+        return query
+
+
+
+