import os
import logging
import logging.config

USER_PATH = ''  # 日志文件夹
BASIC_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)))

if USER_PATH:
    if not os.path.isdir(USER_PATH):
        raise Exception('USER_PATH 目录不存在')
    if not os.path.isdir(os.path.join(BASIC_PATH, 'logs')):
        os.makedirs(os.path.join(BASIC_PATH, 'logs'))
    PATH = os.path.join(BASIC_PATH, 'logs')
else:
    if not os.path.isdir(os.path.join(USER_PATH, 'logs')):
        os.makedirs(os.path.join(USER_PATH, 'logs'))
    PATH = os.path.join(USER_PATH, 'logs')


class Logger:
    simple = '[%(asctime)s][%(levelname)s][%(filename)s:%(lineno)d]>>>: %(message)s'
    standard = '%(levelname)s [%(asctime)s][%(pathname)s:%(lineno)d][%(process)d][%(processName)s][%(thread)d][%(threadName)s]>>>: %(message)s'
    default_log_path = '{}/{}'.format(PATH, 'log.log')
    app_log_path = '{}/{}'.format(PATH, 'app.log')
    config_dic = {
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'simple': {
                'format': simple,
                'datefmt': '%H:%M:%S'
            },
            'standard': {
                'format': standard,
                'datefmt': '%Y-%m-%d %H:%M:%S'
            }
        },
        'handlers': {
            'console': {
                'level': 'DEBUG',
                'class': 'logging.StreamHandler',
                'formatter': 'simple'
            },
            'default_file': {
                'level': 'DEBUG',
                'class': 'logging.handlers.RotatingFileHandler',
                'formatter': 'standard',
                'filename': default_log_path,
                'maxBytes': 1024 * 1024 * 20,
                'backupCount': 1,
                'encoding': 'utf-8',
            },
            'app_file': {
                'level': 'DEBUG',
                'class': 'logging.handlers.RotatingFileHandler',
                'formatter': 'standard',
                'filename': app_log_path,
                'maxBytes': 1024 * 1024 * 20,
                'backupCount': 1,
                'encoding': 'utf-8',
            }
        },
        'loggers': {
            'default': {
                'handlers': ['console', 'default_file'],
                'level': 'INFO',
                'propagate': False,
            },
            'app': {
                'handlers': ['console', 'app_file'],
                'level': 'INFO',
                'propagate': False,
            }

        },
    }

    @classmethod
    def load_logger(cls, logger_name='default'):
        logging.config.dictConfig(cls.config_dic)
        return logging.getLogger(logger_name)


logger = Logger.load_logger()
logger_app = Logger.load_logger('app')



"""
配置 DIR_PATH 参数
from ... import logger,logger_app 
logger.info('hello')
logger_app.info('hello app')

"""

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file :
# @time : 2022/4/25 6:22
from Crypto import Random
from Crypto.PublicKey import RSA

random_generator = Random.new().read  # 生成随机偏移量
# print(random_generator)
rsa = RSA.generate(2048, random_generator)  # 生成一个私钥
# print(rsa)
# 生成私钥
private_key = rsa.exportKey()  # 导出私钥
# print(private_key.decode())
# 生成公钥
public_key = rsa.publickey().exportKey()  # 生成私钥所对应的公钥
# print(public_key.decode())

with open('rsa_private_key.pem', 'wb') as f:
    f.write(private_key)  # 将私钥内容写入文件中

with open('rsa_public_key.pem', 'wb') as f:
    f.write(public_key)  # 将公钥内容写入文件中

# !/usr/bin/env python
# -*- coding: UTF-8 -*-
# @author: A.L.Kun
# @file :
# @time : 2022/4/25 6:22
import base64
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_cipher


def get_key(key_file):
    with open(key_file) as f:
        data = f.read()  # 获取，密钥信息
        key = RSA.importKey(data)
    return key


def encrypt_data(msg):
    public_key = get_key('rsa_public_key.pem')  # 读取公钥信息
    cipher = PKCS1_cipher.new(public_key)  # 生成一个加密的类
    encrypt_text = base64.b64encode(cipher.encrypt(msg.encode()))  # 对数据进行加密
    return encrypt_text.decode()  # 对文本进行解码码


def decrypt_data(encrypt_msg):
    private_key = get_key('rsa_private_key.pem')  # 读取私钥信息
    cipher = PKCS1_cipher.new(private_key)  # 生成一个解密的类
    back_text = cipher.decrypt(base64.b64decode(encrypt_msg), 0)  # 进行解密
    return back_text.decode()  # 对文本内容进行解码


msg = "A.L.Kun"
encrypt_text = encrypt_data(msg)  # 加密
decrypt_text = decrypt_data(encrypt_text)  # 解密
print(decrypt_text, encrypt_text)

import base64
from Crypto.Cipher import AES

iv = '1234567887654321'
key = 'miyaoxuyao16ziji'
data = 'hello world'


# 将原始的明文用空格填充到16字节
def pad(data):
    pad_data = data
    for i in range(0, 16 - len(data) % 16):
        pad_data = pad_data + ' '
    return pad_data


# 将明文用AES加密
def aes(key, data):
    # 将长度不足16字节的字符串补齐
    if len(data) < 16:
        data = pad(data)
    # 创建加密对象
    AES_obj = AES.new(key.encode("utf-8"), AES.MODE_CBC, iv.encode("utf-8"))
    # 完成加密
    AES_en_str = AES_obj.encrypt(data.encode("utf-8"))
    # 用base64编码一下
    AES_en_str = base64.b64encode(AES_en_str)
    # 最后将密文转化成字符串
    AES_en_str = AES_en_str.decode("utf-8")
    return AES_en_str


def aes_de(key, data):
    # 解密过程逆着加密过程写
    # 将密文字符串重新编码成二进制形式
    data = data.encode("utf-8")
    # 将base64的编码解开
    data = base64.b64decode(data)
    # 创建解密对象
    AES_de_obj = AES.new(key.encode("utf-8"), AES.MODE_CBC, iv.encode("utf-8"))
    # 完成解密
    AES_de_str = AES_de_obj.decrypt(data)
    # 去掉补上的空格
    AES_de_str = AES_de_str.strip()
    # 对明文解码
    AES_de_str = AES_de_str.decode("utf-8")
    return AES_de_str


if __name__ == '__main__':
    data = aes(key, data)
    print(data)  # 加密后的文本
    data = aes_de(key, data)
    print(data)  # 解密后的文本

import os


class Config(object):
    """项目配置"""

    # 项目路径
    ROOT_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__).replace('\\', '/')))

    # 数据库设置
    _Mysql = {
        'test': {
            'MYSQL_HOST': 'localhost',
            'MYSQL_PORT': 3306,
            'MYSQL_USER': 'root',
            'MYSQL_PASSWD': 'mysql',
            'MYSQL_DBNAME': 'localhostdata',
            'MYSQL_CHARSET': 'utf8mb4',
        },
        'pro': {
            'MYSQL_HOST': '地址',
            'MYSQL_PORT': 3306,
            'MYSQL_USER': 'root',
            'MYSQL_PASSWD': '123',
            'MYSQL_DBNAME': 'data',
            'MYSQL_CHARSET': 'utf8mb4',
        }
    }

    _Mysql_Type = 'pro'

    @classmethod
    def get_mysql_config(cls):
        return cls._Mysql.get(cls._Mysql_Type)

import pymysql
from dbutils.pooled_db import PooledDB
from config import Config

mysql_config = Config().get_mysql_config()

def create_pool():
    pool = PooledDB(
        creator=pymysql,
        host=mysql_config.get("MYSQL_HOST"),
        port=mysql_config.get("MYSQL_PORT"),
        user=mysql_config.get("MYSQL_USER"),
        passwd=mysql_config.get("MYSQL_PASSWD"),
        db=mysql_config.get("MYSQL_DBNAME"),
        charset=mysql_config.get("MYSQL_CHARSET"),
        mincached=0,  # 初始化连接池时创建的连接数。默认为0，即初始化时不创建连接。
        maxcached=0,  # 池中空闲连接的最大数量。默认为0，即无最大数量限制。
        maxshared=20,  # 池中共享连接的最大数量。
        maxconnections=100,  # 被允许的最大连接数。
        blocking=True,  # 连接数达到最大时，新连接是否可阻塞。默认False，即达到最大连接数时，再取新连接将会报错。(建议True，达到最大连接数时，新连接阻塞，等待连接数减少再连接)
        maxusage=0,  # 连接的最大使用次数。默认0，即无使用次数限制。
        setsession=None
    )

    return pool

class Connection:
    _pool = create_pool()

    @classmethod
    def get_connection(cls):
        return cls._pool.connection()

# coding=utf-8
from connection import Connection


class MysqlBase(object):

    def __init__(self):
        self._connection = Connection.get_connection()
        self.connect = self._connection
        self.cursor = self._connection.cursor()

    def close(self):
        self.cursor.close()
        self.connect.close()

    @staticmethod
    def parse_res(raw):
        data = list()
        if not raw:
            return []
        if len(raw[0]) == 1:
            for item in raw:
                data.append(item[0])
        else:
            for item in raw:
                data.append(list(item))
        return data

    def execute_batch(self, sql, kwargs_list):
        try:
            self.cursor.executemany(sql, kwargs_list)
            self.connect.commit()
        except Exception as e:
            self.connect.rollback()
            raise e
        finally:
            self.close()

    def query(self, sql, **kwargs):
        self.cursor.execute(sql, kwargs)
        res = self.parse_res(self.cursor.fetchall())
        return res

    def query_one(self, sql, **kwargs):
        try:
            res = self.query(sql, **kwargs)
            if res:
                return res[0]
            else:
                return ''
        except Exception as e:
            raise e
        finally:
            self.close()

    def query_all(self, sql, **kwargs):
        try:
            return self.query(sql, **kwargs)
        except Exception as e:
            raise e
        finally:
            self.close()

    def execute(self, sql, **kwargs):
        try:
            self.cursor.execute(sql, kwargs)
            self.connect.commit()
        except Exception as e:
            self.connect.rollback()
            raise e
        finally:
            self.close()

class MysqlService(object):

    def __init__(self):
        self._connection = Connection.get_connection()
        self.connect = self._connection
        self.cursor = self._connection.cursor()

    def rollback(self):
        self._connection.rollback()

    def commit(self):
        self._connection.commit()

    def transform_res(self, rows):
        if rows:
            if len(rows[0]) == 1:
                return [item[0] for item in rows]
            else:
                return [list(item) for item in rows]
        else:
            return {}

    def close(self):
        self.cursor.close()
        self.connect.close()

# =================== 整理批量sql插入语句 ==================
def insert_sql_to_dic_str(insert_sql):
    import json
    """
    把复制的insert sql 语句 转换成字典
    :param insert_sql: 复制的查询sql语句
    :return:_lst, _dic, _string 列表,字典,字符串
    """
    insert_str = insert_sql.replace('\n', '')
    start = insert_str.find('(') + 1
    end = insert_str.find(')')
    json_str = '[' + insert_str[start:end].replace('`', '"') + ']'
    # 获取field(域)列表
    _lst = json.loads(json_str)
    # 获取插入字典
    _dic = dict.fromkeys(_lst, '')
    _result = '({})'.format(",".join(['%({})s'.format(item) for item in _lst]))
    # 获取批量插入sql语句
    _string = '{} VALUES {};'.format(insert_sql.partition('values')[0], _result)
    return _lst, _dic, _string


if __name__ == '__main__':
    insert_sql = """INSERT INTO `pc_yz_vip_level`(`id`, `level_name`, `status`) values (1, NULL, NULL);"""
    lst, dic, string = insert_sql_to_dic_str(insert_sql)
    print(lst)  # ['id', 'level_name', 'status']
    print(dic)  # {'id': '', 'level_name': '', 'status': ''}
    # INSERT INTO `pc_yz_vip_level`(`id`, `level_name`, `status`)  VALUES (%(id)s,%(level_name)s,%(status)s);
    print(string)