init

web/commons/models/mixin/base.py

@@ -0,0 +1,13 @@
+class BaseModelMixin:
+
+    def find_by_key(self):
+        ...
+
+    def upsert(self):
+        result = self.find_by_key()
+        session = self._db.session
+        if result:
+            session.delete(result)
+            session.flush()
+        session.add(self)
+        session.commit()

web/commons/models/mixin/calculator.py

@@ -0,0 +1,28 @@
+class CalculatorMixin:
+    date = None
+
+    @classmethod
+    def query_by_month(cls, query, year, month):
+        last_month_year, last_month = Helper.get_last_month(year, month)
+        query = query.filter(cls.date >= datetime.date(last_month_year, last_month, 26))
+        query = query.filter(cls.date <= datetime.date(year, month, 25))
+        return query
+
+    def upsert(self, *args, **kwargs):
+        result = self.get_by_key(*args, **kwargs)
+        if not result:
+            session = db.session
+            session.add(self)
+            session.commit()
+        else:
+            session = db.session
+            self.id = result.id
+            session.add(result)
+            session.commit()
+
+    @classmethod
+    def get_last_date_from(cls, date):
+        query = cls.query.filter(cls.date <= date)
+        query = query.with_entities(func.max(cls.date))
+        result = query.one_or_none()
+        return result[0]

web/commons/models/mixin/es_source.py

@@ -0,0 +1,23 @@
+class EsSourceMixin:
+    __table__ = None
+    __tablename__ = ''
+
+    def to_es(self):
+        primary_key_name = [str(i.name) for i in self.__table__.columns if i.primary_key][0]
+        es_data = {
+            'meta': {
+                'id': '{}/{}'.format(self.__tablename__, getattr(self, primary_key_name)),
+            },
+            'table': self.__tablename__,
+            'create_time': self.now() * 1000,
+        }
+        return es_data
+
+    @classmethod
+    def get_es_data(cls):
+        for item in cls.query.yield_per(500):
+            yield item.to_es()
+
+    @classmethod
+    def es_join_str(cls, str_list):
+        return ' '.join(str(i or '') for i in str_list if i)

web/commons/models/mixin/insensitive.py

@@ -0,0 +1,51 @@
+from nc_http.tools.helpers import camelize
+
+
+class InsensitiveMixin:
+    __table__ = None
+    _sensitive_columns = []
+
+    def to_insensitive_dict(self, is_camelized=True):
+        """
+        对象转字典且不带敏感数据 <例：密码、密钥、手机号...>
+        :return:
+        """
+        if self._sensitive_columns:
+            _ = {}
+            for column in self.__table__.columns:
+                if column in self._sensitive_columns:
+                    continue
+                key = getattr(column, 'quote', None) or column.name
+                if is_camelized:
+                    _[camelize(key)] = getattr(self, key, None)
+                else:
+                    _[key] = getattr(self, key, None)
+        else:
+            _ = self.to_dict()
+        return _
+
+    @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:
+            if cls._sensitive_columns:  # 数据脱敏
+                result = [_.to_insensitive_dict() for _ in result]
+            else:
+                result = [_.to_dict() for _ in result]
+
+        if paging:
+            return result, paging
+
+        return result

web/commons/models/mixin/operation_track.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from sqlalchemy import Column, String, DateTime
+
+
+class OperationTrackMixin:
+    update_user_id = Column('update_user_id', String(64), comment='最后更新人id')
+    update_user_name = Column('update_user_name', String(64), comment='最后更新人名称')
+    update_time = Column('update_time', DateTime, default=datetime.now, comment='最后更新时间')
+    create_user_id = Column('create_user_id', String(64), comment='创建人id')
+    create_user_name = Column('create_user_name', String(64), comment='创建人名称')
+    create_time = Column('create_time', DateTime, default=datetime.now, comment='创建时间')
+    delete_user_id = Column('delete_user_id', String(64), comment='删除人id')
+    delete_user_name = Column('delete_user_name', String(64), comment='删除人名称')
+    delete_time = Column('delete_time', DateTime, comment='删除时间')
+
+    def track_delete(self, user_id, user_name=None):
+        self.delete_user_id = user_id
+        self.delete_user_name = user_name
+        self.delete_time = datetime.now()
+
+    def track_create(self, user_id, user_name=None):
+        self.create_user_id = user_id
+        self.create_user_name = user_name
+        self.create_time = datetime.now()
+
+    def track_update(self, user_id, user_name=None):
+        self.update_user_id = user_id
+        self.update_user_name = user_name
+        self.update_time = datetime.now()

web/commons/models/mixin/steel.py

@@ -0,0 +1,25 @@
+class SteelMixin(CalculatorMixin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @classmethod
+    def get_by_key(cls, name, spec, material, source, date):
+        spec = spec or ''
+        material = material or ''
+        source = source or ''
+        query = cls.query
+        query = query.filter(cls.name == name).filter(cls.spec == spec).filter(cls.material == material)
+        query = query.filter(cls.source == source).filter(cls.date == date)
+        return query.one_or_none()
+
+    def upsert(self):
+        result = self.get_by_key(self.name, self.spec, self.material, self.source, self.date)
+        if not result:
+            session = db.session
+            session.add(self)
+            session.commit()
+        else:
+            session = db.session
+            self.id = result.id
+            session.add(result)
+            session.commit()