def test(self):
log_helper.info('记录代码执行的相关记录或信息')
try:
result = '0' / 10
except Exception as e:
log_helper.error('出现异常：' + str(e.args))
def get_sql(self, query, vars=None):
"""获取编译后的sql语句"""
# 记录程序执行开始时间
start_time = time.clock()
try:
# 判断是否记录sql执行语句
if self.is_output_sql:
log_helper.info('sql:' + str(query))
# 建立游标
self.cursor = self.connect.cursor()
# 执行SQL
self.data = self.cursor.mogrify(query, vars)
except Exception as e:
# 将异常写入到日志中
log_helper.error('sql生成失败:' + str(e.args) + ' query:' + str(query))
self.data = '获取编译sql失败'
finally:
# 关闭游标
self.cursor.close()
# 记录程序执行结束时间
end_time = time.clock()
# 写入日志
self.write_log(start_time, end_time, query)
return self.data
def read(sql):
"""
连接pg数据库并进行数据查询
如果连接失败，会把错误写入日志中，并返回false，如果sql执行失败，也会把错误写入日志中，并返回false
如果所有执行正常，则返回查询到的数据，这个数据是经过转换的，转成字典格式，方便模板调用，其中字典的key是数据表里的字段名
"""
try:
# 连接数据库
conn = psycopg2.connect(database=db_name, user=db_user, password=db_pass, host=db_host, port=db_port)
# 获取游标
cursor = conn.cursor()
except Exception as e:
print(e.args)
log_helper.error('连接数据库失败：' + str(e.args))
return False
try:
# 执行查询操作
cursor.execute(sql)
# 将返回的结果转换成字典格式
data = [dict((cursor.description[i][0], value) for i, value in enumerate(row)) for row in cursor.fetchall()]
except Exception as e:
print(e.args)
log_helper.error('sql执行失败:' + str(e.args) + ' sql:' + str(sql))
return False
finally:
# 关闭游标和数据库链接
cursor.close()
conn.close()
# 返回结果（字典格式）
return data
def commit(self):
"""提交事务"""
try:
if self.connect:
self.connect.commit()
self.close_conn()
except Exception as e:
log_helper.error('提交事务失败：' + str(e.args))
def rollback(self):
"""回滚操作"""
try:
# 异常时，进行回滚操作
if self.connect:
self.connect.rollback()
except Exception as e:
log_helper.error('回滚操作失败：' + str(e.args))
def open_conn(self):
"""连接数据库，并建立游标"""
try:
if not self.connect:
self.connect = psycopg2.connect(database=self.db_name, user=self.db_user, password=self.db_pass,
host=self.db_host, port=self.db_port)
return self.connect
except Exception as e:
log_helper.error('连接数据库失败：' + str(e.args))
return False
def wrapper(*args, **kwargs):
try:
# 执行接口方法
return func(*args, **kwargs)
except Exception as e:
# 捕捉异常，如果是中断无返回类型操作，则再执行一次
if isinstance(e, HTTPResponse):
func(*args, **kwargs)
# 否则写入异常日志，并返回错误提示
else:
log_helper.error(str(e.args))
return web_helper.return_msg(-1, "操作失败")
def write(sql, vars):
"""
连接pg数据库进行写操作
如果连接失败，会把错误写入日志，并返回false，如果sql执行失败，也会把错误写入日志，
并返回false，如果所有执行正常，则返回true
:param sql:
:param vars:
:return:
"""
try:
#连接数据库
conn = psycopg2.connect(database=db_name,
user=db_user,
password=db_pass,
host=db_host,
port=db_port)
# 获取游标
cursor = conn.cursor()
except Exception as e:
print(e.args)
log_helper.error('连接数据库失败:' + str(e.args))
return False
try:
#执行sql语句
cursor.execute(sql, vars)
#提交事务
conn.commit()
except Exception as e:
print(e.args)
#如果出错，则事务回滚
conn.rollback()
log_helper.error('sql执行失败:' + str(e.args) + 'sql:' + str(sql))
return False
else:
#获取数据
try:
data = [
dict((cursor.description[i][0], value)
for i, value in enumerate(row))
for row in cursor.fetchall()
]
except Exception as e:
#没有设置returning或执行修改或删除语句时，记录不存在
data = None
finally:
#关闭游标和数据库连接
cursor.close()
conn.close()
#如果写入数据后，将数据返回的数据返回给调用者
return data
def execute(self, query, vars=None):
"""执行sql语句查询，返回结果集或影响行数"""
if not query:
return None
# 记录程序执行开始时间
start_time = time.clock()
try:
# 判断是否记录sql执行语句
if self.is_output_sql:
log_helper.info('sql:' + str(query))
# 建立游标
self.cursor = self.connect.cursor()
# 执行SQL
result = self.cursor.execute(query, vars)
print(str(result))
except Exception as e:
# 将异常写入到日志中
log_helper.error('sql执行失败:' + str(e.args) + ' query:' + str(query))
self.data = None
else:
# 获取数据
try:
if self.cursor.description:
# 在执行insert/update/delete等更新操作时，如果添加了returning，则读取返回数据组合成字典返回
self.data = [
dict((self.cursor.description[i][0], value)
for i, value in enumerate(row))
for row in self.cursor.fetchall()
]
else:
# 如果执行insert/update/delete等更新操作时没有添加returning，则返回影响行数，值为0时表时没有数据被更新
self.data = self.cursor.rowcount
except Exception as e:
# 将异常写入到日志中
log_helper.error('数据获取失败:' + str(e.args) + ' query:' +
str(query))
self.data = None
finally:
# 关闭游标
self.cursor.close()
# 记录程序执行结束时间
end_time = time.clock()
# 写入日志
self.write_log(start_time, end_time, query)
# 如果有返回数据，则把该数据返回给调用者
return self.data
def callback():
"""
修改记录
"""
# 检查用户权限
_common_logic.check_user_power()
# 初始化输出值
result = {"state": "FAIL", "url": "", "title": "上传失败", "original": ""}
# 获取上传文件
try:
# upfile为前端HTML上传控件名称
upload = request.files.get('upfile')
# 如果没有读取到上传文件或上传文件的方式不正确，则返回上传失败状态
if not upload:
return result
# 取出文件的名字和后缀
name, ext = os.path.splitext(upload.filename)
# 给上传的文件重命名，默认上传的是图片
if ext and ext != '':
file_name = datetime_helper.to_number() + random_helper.get_string(
5) + ext
else:
file_name = datetime_helper.to_number() + random_helper.get_string(
5) + '.jpg'
upload.filename = file_name
# 设置文件存储的相对路径
filepath = '/upload/' + datetime_helper.to_number('%Y%m%d') + '/'
# 组合成服务器端存储绝对路径
upload_path = os.getcwd() + filepath
# 如果目录不存在，则创建目录
if not os.path.exists(upload_path):
os.mkdir(upload_path)
# 保存文件
upload.save(upload_path + upload.filename, overwrite=True)
# 设置输出参数（返回相对路径给客户端）
result['title'] = result['original'] = upload.filename
result['url'] = filepath + upload.filename
result['state'] = 'SUCCESS'
except Exception as e:
log_helper.error('上传失败：' + str(e.args))
# 直接输出json
return result
def get_verify():
"""生成验证码图片"""
try:
# 获取生成验证码图片与验证码
code_img, verify_code = verify_helper.create_verify_code()
# 将字符串转化成大写保存到session中
s = web_helper.get_session()
s['verify_code'] = verify_code.upper()
s.save()
# 输出图片流
buffer = BytesIO()
code_img.save(buffer, "jpeg")
code_img.close()
response.set_header('Content-Type', 'image/jpg')
return buffer.getvalue()
except Exception as e:
log_helper.error(str(e.args))
def read(sql):
"""
连接pg数据库并进行数据查询
如果连接失败，会把错误写入日志中，并返回false，如果sql执行失败，也会把错误写入日志中，并返回false
如果所有执行正常，则返回查询到的数据，这个数据是经过转换的，转成字典格式，方便模板调用，其中字典的key是数据表里的字段名
"""
try:
# 连接数据库
conn = pymysql.connect(db_host, db_user, db_pass, db_name, charset='utf8')
# 获取游标
cursor = conn.cursor()
except Exception as e:
print(e.args)
log_helper.error('连接数据库失败：' + str(e.args))
return False
try:
# 执行查询操作
cursor.execute(sql)
results = cursor.fetchall()
jsonData = []
for row in results:
result = {}
result['id'] = row[0]
result['userId'] = row[1]
result['logType'] = row[2]
result['userName'] = row[3]
result['operModule'] = row[4]
result['operType'] = row[5]
result['operTime'] = row[6]
result['remark'] = row[7]
result['host'] = row[8]
jsonData.append(result)
except Exception as e:
print(e.args)
log_helper.error('sql执行失败:' + str(e.args) + ' sql:' + str(sql))
return False
finally:
# 关闭游标和数据库链接
cursor.close()
conn.close()
# 返回结果（字典格式）
return jsonData
def copy(self, values, table_name, columns):
"""
百万级数据更新函数
:param values: 更新内容，字段之间用\t分隔，记录之间用\n分隔 "1\taaa\tabc\n2\bbb\abc\n"
:param table_name: 要更新的表名称
:param columns: 需要更新的字段名称：例：('id','userame','passwd')
:return:
"""
try:
# 建立游标
self.cursor = self.connect.cursor()
self.cursor.copy_from(StringIO(values), table_name, columns=columns)
self.connect.commit()
return True
except Exception as e:
# 将异常写入到日志中
log_helper.error('批量更新失败:' + str(e.args) + ' table:' + table_name)
finally:
# 关闭游标
self.cursor.close()
def write(sql, vars):
'''
链接数据库 进行写操作
:param sql: sql语句
:param vars: 参数
:return:
'''
try:
conn = psycopg2.connect(database=db_name,
user=db_user,
password=db_pass,
port=db_port,
host=db_host)
cours = conn.cursor()
except Exception as e:
print(e.args)
log_helper.error(e.args, False)
return False
try:
cours.execute(sql, vars)
conn.commit()
except Exception as e:
print(e.args)
# 如果出错，则事务回滚
conn.rollback()
log_helper.error('sql执行失败:' + str(e.args) + ' sql:' + str(sql))
return False
else:
# 获取数据
try:
# data = [dict((cours.description[i][0], value) for i, value in enumerate(row))
# for row in cours.fetchall()]
data = cours.fetchone()
except Exception as e:
# 没有设置returning或执行修改或删除语句时，记录不存在
data = None
finally:
cours.close()
conn.close()
return data
def write(sql, vars):
"""
连接pg数据库并进行写的操作
如果连接失败，会把错误写入日志中，并返回false，如果sql执行失败，也会把错误写入日志中，并返回false，如果所有执行正常，则返回true
"""
try:
# 连接数据库
conn = pymysql.connect(db_host, db_user, db_pass, db_name, charset='utf8')
# 获取游标
cursor = conn.cursor()
except Exception as e:
print(e.args)
log_helper.error('连接数据库失败：' + str(e.args))
return False
try:
# 执行sql语句
cursor.execute(sql, vars)
# 提交事务
conn.commit()
except Exception as e:
print(e.args)
# 如果出错，则事务回滚
conn.rollback()
log_helper.error('sql执行失败:' + str(e.args) + ' sql:' + str(sql))
return False
else:
# 获取数据
try:
data = [dict((cursor.description[i][0], value) for i, value in enumerate(row))
for row in cursor.fetchall()]
except Exception as e:
# 没有设置returning或执行修改或删除语句时，记录不存在
data = None
finally:
# 关闭游标和数据库链接
cursor.close()
conn.close()
# 如果写入数据后，将数据库返回的数据返回给调用者
return data
def read(sql):
'''
连接pg数据库进行查询
如果连接失败，会把错误写入日志，并返回false.如果成功，返回查询到的数据，这个数据是结果转换的，字典格式，其中key是数据表里的字段
:param sql:
:return:
'''
try:
# 连接数据库
conn = psycopg2.connect(database=db_name,
user=db_user,
password=db_pass,
host=db_host,
port=db_port)
# 获取游标
cours = conn.cursor()
# cours=conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
except Exception as e:
print(e.args)
log_helper.error(e.args, False)
return False
try:
cours.execute(sql)
data = [
dict((cours.description[i][0], value)
for i, value in enumerate(row)) for row in cours.fetchall()
]
# data=cours.fetchall()
except Exception as e:
log_helper.error('sql执行失败:' + str(e.args) + '执行sql:' + str(sql))
finally:
cours.close()
conn.close()
if data:
return data
else:
return None
# coding=utf-8
#遍历当前文件夹下的所有.py文件，然后用__import__导入到程序中
import os, sys
from common import log_helper
pro_path = os.path.split(os.path.realpath(__file__))[0]
sys.path.append(pro_path)
for root, dirs, files in os.walk(pro_path):
for file in files:
name, ext = os.path.splitext(file)
if ext == '.py' and name != '__init__' and pro_path == root:
__import__(name)
for dir in dirs:
if dir != '.svn':
try:
__import__(__name__ + '.' + dir)
except Exception as e:
log_helper.error('初始化导入py文件出现异常:' + str(e.args))
break
