codosdk 1.0.0__py2.py3-none-any.whl

websdk2/jwt_token.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+import jwt, datetime, hashlib
+from .configs import configs as my_configs
+
+
+class AuthToken:
+    def __init__(self):
+        self.token_secret = my_configs.get('token_secret', '3AIiOq18i~H=WWTIGq4ODQyMzcsIdfghs')
+
+    def encode_auth_token(self, **kwargs):
+        """
+        生成认证Token
+        :param user_id: string
+        :param username: string
+        :param nickname: string
+        :return: string
+        """
+        try:
+            exp_time = kwargs.get('exp_time', 1)
+            payload = {
+                'exp': datetime.datetime.utcnow() + datetime.timedelta(days=int(exp_time), seconds=10),
+                'nbf': datetime.datetime.utcnow() - datetime.timedelta(seconds=10),
+                'iat': datetime.datetime.utcnow(),
+                'iss': 'auth: ss',
+                'sub': 'my token',
+                'id': '15618718060',
+                'data': {
+                    'user_id': kwargs.get('user_id', ''),
+                    'username': kwargs.get('username', ''),
+                    'nickname': kwargs.get('nickname', ''),
+                    'email': kwargs.get('email', ''),
+                    'is_superuser': kwargs.get('is_superuser', False)
+                }
+            }
+            return jwt.encode(
+                payload,
+                self.token_secret,
+                algorithm='HS256'
+            )
+
+        except Exception as e:
+            return e
+
+    def encode_auth_token_v2(self, **kwargs):
+        ### 支持到自定义小时
+        """
+        生成认证Token
+        :param user_id: string
+        :param username: string
+        :param nickname: string
+        :param exp_time: int
+        :param exp_hour: int
+        :return: string
+        """
+        try:
+            exp_days = kwargs.get('exp_days', 1)
+            exp_hours = kwargs.get('exp_hours')
+            if exp_hours and isinstance(exp_hours, int) and exp_days == 1:
+                exp_time = datetime.datetime.utcnow() + datetime.timedelta(hours=int(exp_hours), seconds=30)
+            else:
+                exp_time = datetime.datetime.utcnow() + datetime.timedelta(days=int(exp_days), seconds=30)
+
+            payload = {
+                'exp': exp_time,
+                'nbf': datetime.datetime.utcnow() - datetime.timedelta(seconds=10),
+                'iat': datetime.datetime.utcnow(),
+                'iss': 'auth: ss',
+                'sub': 'my token',
+                'id': '15618718060',
+                'data': {
+                    'user_id': kwargs.get('user_id', ''),
+                    'username': kwargs.get('username', ''),
+                    'nickname': kwargs.get('nickname', ''),
+                    'email': kwargs.get('email', ''),
+                    'is_superuser': kwargs.get('is_superuser', False)
+                }
+            }
+            return jwt.encode(
+                payload,
+                self.token_secret,
+                algorithm='HS256'
+            )
+
+        except Exception as e:
+            return e
+
+    def encode_mfa_token(self, **kwargs):
+        try:
+            exp_days = kwargs.get('exp_days', 1)
+            exp_hours = kwargs.get('exp_hours')
+
+            current_time = datetime.datetime.utcnow()
+            exp_time = (datetime.datetime.utcnow() + datetime.timedelta(hours=exp_hours) if exp_hours
+                        else datetime.datetime.utcnow() + datetime.timedelta(days=exp_days)) + datetime.timedelta(
+                seconds=30)
+
+            payload = {
+                'exp': exp_time,
+                'nbf': current_time - datetime.timedelta(seconds=10),
+                'iat': current_time,
+                'data': {
+                    'user_id': kwargs.get('user_id', ''),
+                    'email': kwargs.get('email', '')
+                }
+            }
+
+            return jwt.encode(payload, self.token_secret, algorithm='HS256')
+
+        except Exception as e:
+            return str(e)
+
+    def decode_auth_token(self, auth_token):
+        """
+         验证Token
+        :param auth_token:
+        :return: dict
+        """
+        try:
+            payload = jwt.decode(auth_token, self.token_secret, algorithms=['HS256'],
+                                 leeway=datetime.timedelta(seconds=10))
+            if 'data' in payload and 'user_id' in payload['data']:
+                return payload['data']
+            else:
+                raise jwt.InvalidTokenError
+        except jwt.ExpiredSignatureError:
+            return dict(status=-1, msg='Token过期')
+        except jwt.InvalidTokenError:
+            return dict(status=-2, msg='无效Token')
+
+
+def gen_md5(pd):
+    m2 = hashlib.md5()
+    m2.update(pd.encode("utf-8"))
+    return m2.hexdigest()

websdk2/ldap.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Contact : 191715030@qq.com
+Author  : shenshuo
+Date    : 2023/3/17
+Desc    : 对接LDAP登录认证
+"""
+import json
+from ldap3 import Server, Connection, ALL, SUBTREE, ServerPool
+
+
+class LdapApi:
+    def __init__(self, ldap_server_host, ldap_admin_dn, ldap_admin_password, ldap_server_port=389, ldap_use_ssl=False):
+        self._ldap_admin_dn = ldap_admin_dn
+        self._ldap_admin_password = ldap_admin_password
+        # ldap_server_pool = ServerPool(["172.16.0.102",'172.16.0.103'])
+        use_ssl = True if ldap_use_ssl in ['y', 'yes', True] else False
+        self.ldap_server = Server(ldap_server_host, port=ldap_server_port, use_ssl=ldap_use_ssl)
+
+    def ldap_server_test(self):
+        try:
+            conn = Connection(self.ldap_server, user=self._ldap_admin_dn, password=self._ldap_admin_password,
+                              check_names=True, lazy=False, raise_exceptions=False)
+            conn.open()
+            conn.bind()
+            return True
+        except Exception as e:
+            print("auth fail {}".format(e))
+            return False
+
+    def ldap_auth_v2(self, username, password, search_base, search_filter='cn'):
+        if not self.ldap_server_test(): return False, None, None
+
+        conn = Connection(self.ldap_server, user=self._ldap_admin_dn, password=self._ldap_admin_password,
+                          check_names=True, lazy=False, raise_exceptions=False)
+        conn.open()
+        conn.bind()
+        res = conn.search(search_base=search_base, search_filter=f'({search_filter}={username})',
+                          search_scope=SUBTREE, attributes=[search_filter, 'cn', 'sAMAccountName'], paged_size=5)
+        if not res: return False, None, None
+        entry = conn.response[0]
+        dn = entry['dn']
+        attr_dict = entry['attributes']
+
+        # check password by dn
+        try:
+            conn2 = Connection(self.ldap_server, user=dn, password=password, check_names=True, lazy=False,
+                               raise_exceptions=False)
+            conn2.bind()
+            if conn2.result["description"] == "success":
+                try:
+                    if 'email' in attr_dict and isinstance(attr_dict["email"], list) and attr_dict["email"]:
+                        email = attr_dict["email"][0]
+                    elif 'email' in attr_dict and not isinstance(attr_dict["email"], list) and attr_dict["email"]:
+                        email = attr_dict["email"]
+                    elif 'mail' in attr_dict and isinstance(attr_dict["mail"], list) and attr_dict["mail"]:
+                        email = attr_dict["mail"][0]
+                    elif 'mail' in attr_dict and not isinstance(attr_dict["mail"], list) and attr_dict["mail"]:
+                        email = attr_dict["mail"]
+                    else:
+                        email = None
+                except Exception as err:
+                    print(f"email fail, {err}")
+                    email = None
+
+                return True, attr_dict[search_filter], email
+            else:
+                print("auth fail")
+                return False, None, None
+        except Exception as e:
+            print("auth fail {}".format(e))
+            return False, None, None
+
+    def ldap_auth_v3(self, username, password, search_base, conf_attr_dict, search_filter='cn'):
+        # 用户  密码  用户ou 映射数据  查询过滤 应和登录的账户关联
+        if not self.ldap_server_test():
+            return False, None
+
+        conn = Connection(self.ldap_server, user=self._ldap_admin_dn, password=self._ldap_admin_password,
+                          check_names=True, lazy=False, raise_exceptions=False)
+        conn.open()
+        conn.bind()
+        try:
+            if isinstance(conf_attr_dict, str): conf_attr_dict = json.loads(conf_attr_dict)
+            attr_list = list(conf_attr_dict.values())
+        except Exception as err:
+            attr_list = ['cn', 'sAMAccountName']
+        res = conn.search(search_base=search_base, search_filter=f'({search_filter}={username})',
+                          search_scope=SUBTREE, attributes=attr_list, paged_size=1000)
+
+        if not res:
+            return False, None
+        entry = conn.response[0]
+        dn = entry['dn']
+        attr_dict = entry['attributes']
+
+        # check password by dn
+        try:
+            conn2 = Connection(self.ldap_server, user=dn, password=password, check_names=True, lazy=False,
+                               raise_exceptions=False)
+            conn2.bind()
+            if conn2.result["description"] == "success":
+                return True, {k: attr_dict.get(v) for k, v in conf_attr_dict.items()}
+            else:
+                print("auth fail 2")
+                return False, None
+        except Exception as e:
+            print(f"auth fail 3 {e}")
+            return False, None
+
+
+if __name__ == "__main__":
+    obj = LdapApi('172.16.0.102', 'cn=Manager,DC=sz,DC=com', '070068')
+    print(obj.ldap_server_test())
+    print('____________')
+    print(obj.ldap_auth_v2("yanghongfei", "123456", 'ou=opendevops,dc=sz,dc=com', 'cn'))

websdk2/logger.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+
+import os
+import logging
+import sys
+import datetime
+import tornado.log
+
+# from tornado.options import options
+#
+# options.log_file_prefix = os.path.join(os.path.dirname(os.path.dirname(__file__)), f'/tmp/codo.log')
+
+
+class LogFormatter(tornado.log.LogFormatter):
+    default_msec_format = '%s.%03d'
+
+    def __init__(self):
+        super(LogFormatter, self).__init__(
+            fmt='%(color)s%(asctime)s | %(levelname)s%(end_color)s     | %(filename)s:%(funcName)s:%(lineno)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S.%f'
+        )
+
+    def formatTime(self, record, datefmt=None):
+        ct = datetime.datetime.now()
+        t = ct.strftime(self.default_time_format)
+        s = self.default_msec_format % (t, record.msecs)
+        return s
+
+
+def init_logging():
+    # write file
+    [
+        i.setFormatter(LogFormatter())
+        for i in logging.getLogger().handlers
+    ]
+    logging.getLogger().setLevel(logging.INFO)
+    # write stdout
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setFormatter(LogFormatter())
+    logging.getLogger().addHandler(stdout_handler)
+    logging.info('[APP Logging Init] logging has been started')

websdk2/model_utils.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+"""
+Author : shenshuo
+Date   : 2019年12月11日
+Desc   : models类
+"""
+
+from typing import Type, Union
+from datetime import datetime
+from sqlalchemy.orm import class_mapper
+from sqlalchemy.ext.declarative import DeclarativeMeta
+from sqlalchemy import text
+from sqlalchemy.exc import IntegrityError
+from .utils import get_contain_dict
+from .db_context import DBContextV2 as DBContext
+from .utils.pydantic_utils import sqlalchemy_to_pydantic, ValidationError, PydanticDelList
+
+
+def model_to_dict(model):
+    model_dict = {}
+    for key, column in class_mapper(model.__class__).c.items():
+        if isinstance(getattr(model, key), datetime):
+            model_dict[column.name] = str(getattr(model, key))
+        else:
+            model_dict[column.name] = getattr(model, key, None)
+
+    if isinstance(getattr(model, "custom_extend_column_dict", None), dict):
+        model_dict.update(**getattr(model, "custom_extend_column_dict", {}))
+    return model_dict
+
+
+def queryset_to_list(queryset, **kwargs) -> list:
+    if kwargs: return [model_to_dict(q) for q in queryset if get_contain_dict(kwargs, model_to_dict(q))]
+    return [model_to_dict(q) for q in queryset]
+
+
+def GetInsertOrUpdateObj(cls: Type, str_filter: str, **kw) -> classmethod:
+    """
+    cls:            Model 类名
+    str_filter:      filter的参数.eg:"name='name-14'" 必须设置唯一 支持 and or
+    **kw:           【属性、值】字典,用于构建新实例，或修改存在的记录
+    session.add(GetInsertOrUpdateObj(TableTest, "name='name-114'", age=33114, height=123.14, name='name-114'))
+    """
+    with DBContext('r') as session:
+        existing = session.query(cls).filter(text(str_filter)).first()
+    if not existing:
+        res = cls()
+        for k, v in kw.items():
+            if hasattr(res, k):
+                setattr(res, k, v)
+        return res
+    else:
+        res = existing
+        for k, v in kw.items():
+            if hasattr(res, k):
+                setattr(res, k, v)
+
+        return res
+
+
+def insert_or_update(cls: Type[DeclarativeMeta], str_filter: str, **kwargs) -> Union[None, DeclarativeMeta]:
+    """
+    Insert or update a record in the database.
+
+    Args:
+        cls (Type[DeclarativeMeta]): Model class.
+        str_filter (str): Filter parameters. e.g., "name='name-14'". Must be unique. Supports 'and' and 'or'.
+        **kwargs: Attributes and values dictionary used to construct a new instance or modify an existing record.
+
+    Returns:
+        Union[None, DeclarativeMeta]: Returns None if no existing record found, otherwise returns the updated or inserted record.
+    """
+    with DBContext('r') as session:
+        existing = session.query(cls).filter(text(str_filter)).first()
+    if not existing:
+        res = cls(**kwargs)
+        for k, v in kwargs.items():
+            if hasattr(res, k):
+                setattr(res, k, v)
+        return res
+    else:
+        res = existing
+        for k, v in kwargs.items():
+            if hasattr(res, k):
+                setattr(res, k, v)
+
+        return res
+
+
+class CommonOptView:
+    def __init__(self, model, **kwargs):
+        self.model = model
+        self.pydantic_model_base = sqlalchemy_to_pydantic(model)
+        self.pydantic_model = sqlalchemy_to_pydantic(model, exclude=['id'])
+
+    def prepare(self):
+        pass
+
+    @staticmethod
+    def del_data(data) -> dict:
+        if '_index' in data:
+            del data['_index']
+        if '_rowKey' in data:
+            del data['_rowKey']
+        return data
+
+    def handle_add(self, data: dict) -> dict:
+        self.prepare()
+        data = self.del_data(data)
+        try:
+            self.pydantic_model(**data)
+        except ValidationError as e:
+            return dict(code=-1, msg=str(e))
+
+        try:
+            with DBContext('w', None, True) as db:
+                db.add(self.model(**data))
+        except IntegrityError as e:
+            return dict(code=-2, msg='不要重复添加')
+
+        except Exception as e:
+            return dict(code=-3, msg=f'{e}')
+
+        return dict(code=0, msg="创建成功")
+
+    def handle_update(self, data: dict) -> dict:
+        self.prepare()
+        data = self.del_data(data)
+        try:
+            valid_data = self.pydantic_model_base(**data)
+        except ValidationError as e:
+            return dict(code=-1, msg=str(e))
+
+        try:
+            with DBContext('w', None, True) as db:
+                db.query(self.model).filter(self.model.id == valid_data.id).update(data)
+
+        except IntegrityError as e:
+            return dict(code=-2, msg=f'修改失败，已存在')
+
+        except Exception as err:
+            return dict(code=-3, msg=f'修改失败, {err}')
+
+        return dict(code=0, msg="修改成功")
+
+    def handle_delete(self, data: dict) -> dict:
+        self.prepare()
+        try:
+            valid_data = PydanticDelList(**data)
+        except ValidationError as e:
+            return dict(code=-1, msg=str(e))
+
+        with DBContext('w', None, True) as session:
+            session.query(self.model).filter(self.model.id.in_(valid_data.id_list)).delete(synchronize_session=False)
+        return dict(code=0, msg=f"删除成功")

websdk2/mqhelper.py

@@ -0,0 +1,120 @@
+# !/usr/bin/env python
+# -*-coding:utf-8-*-
+"""
+Author : ming
+date   : 2017/3/3 下午9:31
+role   : rabbitMQ 操作类
+"""
+
+import logging
+import traceback
+import pika
+from .consts import const
+from .configs import configs
+from .error import ConfigError
+
+logger = logging.getLogger('pika')
+logger.setLevel(logging.WARNING)
+
+
+class MessageQueueBase(object):
+    def __init__(self, exchange, exchange_type, routing_key='', routing_keys=None, queue_name='', no_ack=False,
+                 mq_key=const.DEFAULT_MQ_KEY):
+        mq_config = configs[const.MQ_CONFIG_ITEM][mq_key]
+        if const.MQ_ADDR not in mq_config:
+            raise ConfigError(const.MQ_ADDR)
+        if const.MQ_PORT not in mq_config:
+            raise ConfigError(const.MQ_PORT)
+        if const.MQ_VHOST not in mq_config:
+            raise ConfigError(const.MQ_VHOST)
+        if const.MQ_USER not in mq_config:
+            raise ConfigError(const.MQ_USER)
+        if const.MQ_PWD not in mq_config:
+            raise ConfigError(const.MQ_PWD)
+        self.addr = mq_config[const.MQ_ADDR]
+        self.port = int(mq_config[const.MQ_PORT])
+        self.vhost = mq_config[const.MQ_VHOST]
+        self.user = mq_config[const.MQ_USER]
+        self.pwd = mq_config[const.MQ_PWD]
+        self.__exchange = exchange
+        self.__exchange_type = exchange_type
+        self.__routing_key = routing_key
+        self.__routing_keys = routing_keys
+        self.__queue_name = queue_name
+        self.__no_ack = no_ack
+        self.__channel = None
+        self.__connection = None
+
+    def start_consuming(self, exchange_durable=False):
+        channel = self.create_channel()
+
+        channel.exchange_declare(exchange=self.__exchange, exchange_type=self.__exchange_type, durable=exchange_durable)
+        if self.__queue_name:
+            result = channel.queue_declare(queue=self.__queue_name, durable=True)
+        else:
+            result = channel.queue_declare('', exclusive=True)
+        if self.__routing_keys and isinstance(self.__routing_keys, list):
+            for binding_key in self.__routing_keys:
+                channel.queue_bind(exchange=self.__exchange, queue=result.method.queue, routing_key=binding_key)
+        else:
+            channel.queue_bind(exchange=self.__exchange, queue=result.method.queue, routing_key=self.__routing_key)
+
+        channel.basic_qos(prefetch_count=1)
+        channel.basic_consume(result.method.queue, self.call_back, self.__no_ack)
+        logging.info('[*]Queue %s started.' % (result.method.queue))
+
+        channel.start_consuming()
+
+    def __enter__(self):
+        self.__channel = self.create_channel()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.__connection.close()
+
+    def close_channel(self):
+        self.__connection.close()
+
+    def create_channel(self):
+        credentials = pika.PlainCredentials(self.user, self.pwd)
+        self.__connection = pika.BlockingConnection(
+            pika.ConnectionParameters(self.addr, self.port, self.vhost, credentials=credentials))
+        channel = self.__connection.channel()
+        return channel
+
+    def new_channel(self):
+        self.__channel = self.create_channel()
+        return self
+
+    def call_back(self, ch, method, properties, body):
+        try:
+            logging.info('get message')
+            self.on_message(body)
+
+            if not self.__no_ack:
+                ch.basic_ack(delivery_tag=method.delivery_tag)
+        except:
+            logging.error(traceback.format_exc())
+            if not self.__no_ack:
+                ch.basic_nack(delivery_tag=method.delivery_tag)
+
+    def on_message(self, body):
+        pass
+
+    def publish_message(self, body, durable=True, exchange_durable=False):
+        self.__channel.exchange_declare(exchange=self.__exchange, exchange_type=self.__exchange_type,
+                                        durable=exchange_durable)
+        if self.__queue_name:
+            result = self.__channel.queue_declare(queue=self.__queue_name)
+        else:
+            result = self.__channel.queue_declare("", exclusive=True, auto_delete=True)
+
+        self.__channel.queue_bind(exchange=self.__exchange, queue=result.method.queue)
+
+        if durable:
+            properties = pika.BasicProperties(delivery_mode=2)
+            self.__channel.basic_publish(exchange=self.__exchange, routing_key=self.__routing_key, body=body,
+                                         properties=properties)
+        else:
+            self.__channel.basic_publish(exchange=self.__exchange, routing_key=self.__routing_key, body=body)
+        logging.info('Publish message %s sucessfuled.' % body)

websdk2/program.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+'''
+Author : ming
+date   : 2017/4/11 下午3:21
+desc   :
+'''
+import fire
+
+
+class MainProgram(object):
+    def __init__(self, progressid=''):
+        print(progressid)
+
+    @staticmethod
+    def run(cls_inst):
+        if issubclass(cls_inst, MainProgram):
+            fire.Fire(cls_inst)
+        else:
+            raise Exception('')