def update_message_status(self, id_list):
"""
修改系统消息状态
:param message_id:
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'inform_message'
for message_id in eval(id_list):
condition = "id=%s" % message_id
# 更新系统信息
update_fields = ['state']
update_fields_value = [1]
update_sql = self.create_update_sql(db_name, table_name,
update_fields,
update_fields_value,
condition)
self.updete_exec(db_conn, update_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.UPDATE_DATA_FAIL
finally:
db_conn.close()
def update_department_staff(self, dpt_id, user_ids):
"""
给部门下面添加员工
:param dpt_id: 部门ID
:param user_ids: 员工ID
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'users_department'
filed = 'dpt_id'
condition = "dpt_id = %s " % dpt_id
old_sql = self.create_select_sql(db_name, table_name, filed, condition)
# 获取用户和部门管理表的数据
old_dpt_data = self.execute_fetch_one(db_conn, old_sql)
if old_dpt_data:
condition = "dpt_id=%s" % old_dpt_data.get('dpt_id')
del_association_sql = self.create_delete_sql(db_name, table_name, condition)
# 删除旧的用户和部门关联表的数据
self.execute_del_data(db_conn, del_association_sql)
# 添加新的员工
for user_id in eval(user_ids):
fields = '(dpt_id,user_id)'
insert_data = (dpt_id, user_id)
sql = DbBase.create_insert_sql(self, db_name, table_name, fields, insert_data)
DbBase.execute_sql_return_count(self, db_conn, sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.ADD_DATA_FAIL
finally:
db_conn.close()
def add_role(self, role_name, note_info):
"""
添加角色
:param role_name: 角色名称
:param note_info: 备注信息
:return:
"""
db_conn = MysqlConn()
try:
create_time = get_system_datetime()
db_name = configuration.get_database_name()
table_name = 'role'
filed = 'name'
condition = "name = '%s'" % role_name
system_name_sql = self.create_select_sql(db_name, table_name,
filed, condition)
res = self.execute_fetch_one(db_conn, system_name_sql)
if res:
return response_code.RECORD_EXIST
else:
fields = '(name, create_time,note_info)'
insert_data = (role_name, create_time, note_info)
sql = self.create_insert_sql(db_name, table_name, fields,
insert_data)
self.execute_sql_return_count(db_conn, sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
error_data = response_code.ADD_DATA_FAIL
return error_data
finally:
db_conn.close()
def get_user(self, **kwargs):
"""
条件查询用户
:param kwargs:
:return:
"""
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
condition = ''
for key in kwargs.keys():
if type(kwargs[key]) == int:
condition = '%s=%s' % (key, kwargs[key])
else:
condition = '%s="%s"' % (key, kwargs[key])
sql = self.create_select_sql(db_name,
'users',
'*',
condition=condition)
return self.execute_fetch_one(conn, sql)
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
conn.close()
def pwd_modify(self, user_id, old_pwd, new_pwd):
'''
修改用户密码
:return:
'''
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
condition = 'id=%s' % user_id
user_pwd_sql = self.create_select_sql(db_name, 'users',
'pass_word', condition)
pwd_result = self.execute_fetch_one(conn, user_pwd_sql)
# 验证旧密码
if not check_password_hash(pwd_result.get('pass_word'), old_pwd):
return response_code.LOGIN_IS_FAIL
# 更新密码
new_pass_word_hash = generate_password_hash(new_pwd)
update_pwd_sql = self.create_update_sql(db_name, 'users',
['pass_word'],
[new_pass_word_hash],
condition)
self.updete_exec(conn, update_pwd_sql)
# 返回
data = response_code.SUCCESS
return data
except Exception as e:
lg.error(e)
return response_code.UPDATE_DATA_FAIL
finally:
conn.close()
def update_role(self, role_id, role_name, note_info):
"""
修改角色
:param role_id: 角色ID
:param role_name: 角色名称
:param note_info: 备注信息
:return:
"""
db_conn = MysqlConn()
try:
time_modify = get_system_datetime()
db_name = configuration.get_database_name()
table_name = 'role'
filed = 'name'
condition = "id <> %s and name = '%s'" % (role_id, role_name)
old_sql = self.create_select_sql(db_name, table_name, filed,
condition)
old_pla_name_data = self.execute_fetch_one(db_conn, old_sql)
if old_pla_name_data:
return response_code.RECORD_EXIST
else:
fields = ['id', 'name', 'note_info', 'time_modify']
pla_data = [role_id, role_name, note_info, time_modify]
update_condition = 'id = %s' % str(role_id)
update_sql = self.create_update_sql(db_name, table_name,
fields, pla_data,
update_condition)
self.execute_update_sql(db_conn, update_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.UPDATE_DATA_FAIL
finally:
db_conn.close()
def get_user_group_roles(self, group_id):
"""
获取用户组的角色信息
:param group_id:
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'user_group_role'
fields = 'role_id'
condition = 'group_id=%s' % group_id
sql = self.create_select_sql(db_name, table_name, fields, condition=condition)
result = self.execute_fetch_all(db_conn, sql)
if result:
role_ids = tuple([role.get('role_id') for role in result])
if len(role_ids) == 1:
role_condition = 'id=%s' % role_ids[0]
else:
role_condition = 'id in %s' % str(role_ids)
sql = self.create_select_sql(db_name, 'role', '*', condition=role_condition)
role_result = self.execute_fetch_all(db_conn, sql)
data = response_code.SUCCESS
data['data'] = role_result
else:
data = response_code.SUCCESS
data['data'] = []
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def add_department(self, dpt_name, dpt_p_id):
"""
添加部门
:param dpt_name: 部门名称
:param dpt_p_id: 上级部门id
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'department'
filed = 'dpt_name'
condition = "dpt_name = '%s'" % dpt_name
system_name_sql = DbBase.create_select_sql(self, db_name,
table_name, filed,
condition)
res = DbBase.execute_fetch_one(self, db_conn, system_name_sql)
if res:
return response_code.RECORD_EXIST
else:
fields = '(dpt_name, p_id)'
pla_data = (dpt_name, dpt_p_id)
sql = DbBase.create_insert_sql(self, db_name, table_name,
fields, pla_data)
DbBase.execute_sql_return_count(self, db_conn, sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.ADD_DATA_FAIL
finally:
db_conn.close()
def update_department(self, dpt_id, dpt_name, p_id):
"""
修改部门
:param dpt_id: 部门ID
:param dpt_name: 部门名称
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'department'
filed = 'dpt_name'
condition = "dpt_id <> %s and dpt_name = '%s'" % (dpt_id, dpt_name)
old_sql = DbBase.create_select_sql(self, db_name, table_name,
filed, condition)
old_pla_name_data = DbBase.execute_fetch_one(
self, db_conn, old_sql)
if old_pla_name_data:
return response_code.RECORD_EXIST
else:
fields = ['dpt_id', 'dpt_name', 'p_id']
pla_data = [dpt_id, dpt_name, p_id]
update_condition = 'dpt_id = %s' % str(dpt_id)
update_sql = DbBase.create_update_sql(self, db_name,
table_name, fields,
pla_data,
update_condition)
DbBase.execute_update_sql(self, db_conn, update_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.UPDATE_DATA_FAIL
finally:
db_conn.close()
def department_add_staff(self, dpt_id, user_ids):
"""
给部门下面添加员工
:param dpt_id: 部门ID
:param user_ids: 员工ID
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'users_department'
for user_id in eval(user_ids):
condition = "user_id =%s and dpt_id=%s" % (user_id, dpt_id)
is_exist_sql = self.create_select_sql(db_name, table_name, "*",
condition)
res = self.execute_fetch_one(db_conn, is_exist_sql)
if res:
continue
fields = '(user_id,dpt_id)'
value_tuple = (user_id, dpt_id)
insert_user_sql = self.create_insert_sql(
db_name, table_name, fields, value_tuple)
self.insert_exec(db_conn, insert_user_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.ADD_DATA_FAIL
finally:
db_conn.close()
def add_user_group_roles(self, group_id, role_ids):
"""
添加用户组角色
:param group_id:
:param role_ids:
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'user_group_role'
for role_id in eval(role_ids):
condition = "role_id =%s and group_id=%s" % (role_id, group_id)
is_exist_sql = self.create_select_sql(db_name, table_name, "*", condition)
res = self.execute_fetch_one(db_conn, is_exist_sql)
if res:
continue
fields = '(role_id,group_id)'
value_tuple = (role_id, group_id)
insert_user_sql = self.create_insert_sql(db_name, table_name, fields, value_tuple)
self.insert_exec(db_conn, insert_user_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.ADD_DATA_FAIL
finally:
db_conn.close()
def get_dpt_user_info_by_id(self, dpt_id, current_page, page_size):
"""
获取部门下的员工信息
:param dpt_id:
:param current_page:
:param page_size:
:return:
"""
db_conn = MysqlConn()
try:
start_page = str((current_page - 1) * page_size)
db_name = configuration.get_database_name()
table_name = 'users_department'
fields = 'user_id'
condition = 'dpt_id=%s' % dpt_id
sql_count, sql = self.create_get_page_sql(db_name, table_name,
fields, start_page,
page_size, condition)
result = self.execute_fetch_pages(db_conn, sql_count, sql,
current_page, page_size)
data_list = result.get('data_list')
if data_list:
user_data = tuple([user.get('user_id') for user in data_list])
user_data_list = user_mgr.get_user_by_ids(user_data)
else:
user_data_list = []
data = response_code.SUCCESS
data['data'] = user_data_list
data['total'] = result.get('total_count')
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def delete_department(self, dpt_id):
"""
删除部门
:param dpt_id:
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = "department"
user_dpt_table = "users_department"
filed = 'dpt_id'
condition = "dpt_id = %s " % dpt_id
old_sql = self.create_select_sql(db_name, user_dpt_table, filed,
condition)
# 获取用户和部门管理表的数据
old_dpt_data = self.execute_fetch_one(db_conn, old_sql)
if old_dpt_data:
condition = "dpt_id=%s" % old_dpt_data.get('dpt_id')
del_association_sql = self.create_delete_sql(
db_name, user_dpt_table, condition)
# 删除用户和部门关联表的数据
self.execute_del_data(db_conn, del_association_sql)
# 删除部门数据
condition = "dpt_id=%s" % dpt_id
sql = self.create_delete_sql(db_name, table_name, condition)
self.execute_del_data(db_conn, sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.DELETE_DATA_FAIL
finally:
db_conn.close()
def upd_user_partial(self, user_json):
"""
更新用户部分指定信息
:param user_json:
:return:
"""
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
user = user_json
user_id = user.get('user_id')
condition = 'id=%s' % user_id
# 更新用户基本信息
update_user_fields = ['user_name', 'email', 'phone', 'login_name']
update_user_fields_value = [
user.get('user_name'),
user.get('email'),
user.get('phone'),
user.get('login_name')
]
update_user_sql = self.create_update_sql(db_name, 'users',
update_user_fields,
update_user_fields_value,
condition)
self.updete_exec(conn, update_user_sql)
data = response_code.SUCCESS
return data
except Exception as e:
lg.error(e)
return response_code.UPDATE_DATA_FAIL
finally:
conn.close()
def remove_user_group_roles(self, group_id, role_ids):
"""
移除用户组的角色
:param group_id:
:param role_ids:
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'user_group_role'
for role_id in eval(role_ids):
condition = "role_id =%s and group_id=%s" % (role_id, group_id)
is_exist_sql = self.create_select_sql(db_name, table_name, "*",
condition)
res = self.execute_fetch_one(db_conn, is_exist_sql)
if res:
del_user_sql = self.create_delete_sql(
db_name, table_name, condition)
self.delete_exec(db_conn, del_user_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.DELETE_DATA_FAIL
finally:
db_conn.close()
def add_user(self, user):
"""
添加用户
:return:
"""
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
# 解析参数成dict
# 判断用户是否已经存在
if_user = self.get_user(user_name=user['user_name'])
if if_user:
data = response_code.RECORD_EXIST
return data
# 需要插入的字段
fields = '(user_name,user_sex,email,pass_word,phone,position,create_time,note_info,login_name,icon)'
# 获取当前创建时间
create_time = get_system_datetime()
pass_word = generate_password_hash('123456')
# 插入值
value_tuple = (user['user_name'], user['user_sex'], user['email'],
pass_word, user['phone'], user['position'],
create_time, user['note_info'], user['login_name'],
user['icon'])
# 构造插入用户的sql语句
insert_user_sql = self.create_insert_sql(db_name, 'users', fields,
value_tuple)
self.insert_exec(conn, insert_user_sql)
# 查询插入新用户
new_user = self.get_user(user_name=user['user_name'])
# 构造插入部门关联表的sql语句,并插入值
for dpt_id in eval(str(user['dpt_ids'])):
insert_users_department_sql = self.create_insert_sql(
db_name, 'users_department', '(user_id,dpt_id)',
(new_user['ID'], dpt_id))
self.insert_exec(conn, insert_users_department_sql)
# 构造插入用户组关联表的sql语句,并插入值
for group_id in eval(str(user['group_ids'])):
insert_users_group_sql = self.create_insert_sql(
db_name, 'user_user_group', '(user_id,group_id)',
(new_user['ID'], group_id))
self.insert_exec(conn, insert_users_group_sql)
# 构造插入用户角色关联表的sql语句,并插入值
for role_id in eval(str(user['role_ids'])):
insert_users_role_sql = self.create_insert_sql(
db_name, 'user_roles', '(user_id,role_id)',
(new_user['ID'], role_id))
self.insert_exec(conn, insert_users_role_sql)
data = response_code.SUCCESS
return data
except Exception as e:
lg.error(e)
conn.conn.rollback()
return response_code.ADD_DATA_FAIL
finally:
conn.close()
def get_group_list(self, current_page, page_size, search_name):
"""
分页查询用户组信息
:param current_page:
:param page_size:
:param search_name:
:return:
"""
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
start_num = (current_page - 1) * page_size
# 添加查询条件
condition = None
if search_name:
search_condition = search_name
for key in search_condition.keys():
condition = key + ' like "%' + search_condition[key] + '%"'
user_group_fields = 'id,name,description,create_time'
sql_count, sql = self.create_get_page_sql(db_name, 'user_group', user_group_fields, start_num, page_size,
condition=condition)
groups_result = self.execute_fetch_pages(conn, sql_count, sql, current_page, page_size)
for group in groups_result["data_list"]:
# 用户组角色查询
group_id = group.get('id')
role_relations = [
{"table_name": "user_group_role", "join_condition": "user_group_role.role_id=role.id"}]
condition = "user_group_role.group_id=" + str(group_id)
role_query_sql = self.create_get_relation_sql(db_name, "role", "id,name", role_relations,
condition=condition)
roles = self.execute_fetch_all(conn, role_query_sql)
role_name_str = ''
role_ids = []
if len(roles) == 0:
pass
elif len(roles) == 1:
role_name_str = roles[0]["name"]
role_ids.append(roles[0]["id"])
else:
for role in roles:
role_name_str += role["name"] + '|'
role_ids.append(role["id"])
group["roles"] = role_name_str.rstrip('|')
group["role_ids"] = role_ids
# 返回
data = response_code.SUCCESS
data["data"] = groups_result.get('data_list')
data["total"] = groups_result.get('total_count')
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
conn.close()
def get_pages_system_log(self, current_page, page_size, search_data,
time_scope):
"""
分页查询系统日志
:param current_page:
:param page_size:
:param search_data:
:param time_scope:
:return:
"""
db_conn = MysqlConn()
try:
start_page = str((current_page - 1) * page_size)
db_name = configuration.get_database_name()
table_name = 'system_log'
fields = 'log_key,title,source,ip_address,level,status,' \
'opinion,opinion_user,opinion_time,time_create,description'
condition = ''
# 给定了查询字段
if len(json.loads(search_data)) > 0:
condition = self.create_vague_condition_sql(search_data)
# 给定了查询时间类型
if time_scope:
time_scope = eval(time_scope)
start_time = time_scope[0]
end_time = time_scope[1]
if condition:
condition += ' and TIME_CREATE between ' + str(
start_time) + ' and ' + str(end_time)
else:
condition += 'TIME_CREATE between ' + str(
start_time) + ' and ' + str(end_time)
sql_count, sql = self.create_get_page_sql(db_name, table_name,
fields, start_page,
page_size, condition)
# 执行查询
result = self.execute_fetch_pages(db_conn, sql_count, sql,
current_page, page_size)
data = response_code.SUCCESS
data['data'] = result.get('data_list')
data['total'] = result.get('total_count')
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def get_pages_operation_log(self, current_page, page_size, search_data,
time_scope):
"""
获取日志信息
:param current_page:
:param page_size:
:param search_data:
:param time_scope:
:return:
"""
db_conn = MysqlConn()
try:
start_page = str((current_page - 1) * page_size)
db_name = configuration.get_database_name()
table_name = 'system_oper_log'
fields = 'log_key, (select name from %s.users where id = user_key) as user_name,user_key,ip_address,level,description,time_create' % db_name
condition = ''
# 给定了查询字段
if len(json.loads(search_data)) > 0:
condition = self.create_vague_condition_sql(search_data)
# 给定了查询时间类型
if time_scope:
time_scope = eval(time_scope)
start_time = time_scope[0]
end_time = time_scope[1]
if condition:
condition += ' and time_create between ' + str(
start_time) + ' and ' + str(end_time)
else:
condition += 'time_create between ' + str(
start_time) + ' and ' + str(end_time)
condition += ' order by time_create desc'
sql_count, sql = self.create_get_page_sql(db_name, table_name,
fields, start_page,
page_size, condition)
result = self.execute_fetch_pages(db_conn, sql_count, sql,
current_page, page_size)
data = response_code.SUCCESS
data['data'] = result.get('data_list')
data['total'] = result.get('total_count')
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def get_user_group_by_name(self, group_name):
"""
通过名称查询用户组信息
:param group_name:
:return:
"""
conn = MysqlConn()
try:
condition = 'name="%s"' % group_name
db_name = configuration.get_database_name()
sql = self.create_select_sql(db_name, 'user_group', 'id', condition=condition)
return self.execute_fetch_one(conn, sql)
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
conn.close()
def get_role_permission_info(self, role_id):
"""
根据角色ID获取权限列表
:param role_id: 角色ID
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'roles_permission'
condition = 'role_id=%s' % role_id
# 获取权限ID
sql = DbBase.create_select_sql(self, db_name, table_name,
'permission_id', condition)
result = DbBase.execute_fetch_all(self, db_conn, sql)
permission_ids = [
permission.get('permission_id') for permission in result
]
if len(permission_ids) != 0:
# 获取权限的父ID
permission_table = 'permission'
if len(permission_ids) == 1:
condition = 'id = %s' % permission_ids
else:
condition = 'id in %s' % str(tuple(permission_ids))
per_p_sql = DbBase.create_select_sql(self, db_name,
permission_table, 'p_id',
condition)
result = DbBase.execute_fetch_all(self, db_conn, per_p_sql)
permission_p_ids = [
permission.get('p_id') for permission in result
]
# 获取权限ID和权限父ID 的差集给前端显示
result = list(
set(permission_ids).difference(set(permission_p_ids)))
data = response_code.SUCCESS
data['data'] = result
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def del_user(self, ids):
"""
删除指定用户
:param id:
:return:
"""
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
for id in eval(str(ids)):
# 删除该用户关联角色
delete_role_condition = 'user_id=%s' % id
delete_user_role_sql = self.create_delete_sql(
db_name, 'user_roles', delete_role_condition)
self.delete_exec(conn, delete_user_role_sql)
# 删除该用户关联部门
delete_department_condition = 'user_id=%s' % id
delete_user_department_sql = self.create_delete_sql(
db_name, 'users_department', delete_department_condition)
self.delete_exec(conn, delete_user_department_sql)
# 删除该用户关联用户组
delete_group_condition = 'user_id=%s' % id
delete_group_sql = self.create_delete_sql(
db_name, 'user_user_group', delete_group_condition)
self.delete_exec(conn, delete_group_sql)
# 删除该用户关联任务组
delete_task_group_condition = 'user_id=%s' % id
delete_task_group_sql = self.create_delete_sql(
db_name, 'user_task_group', delete_task_group_condition)
self.delete_exec(conn, delete_task_group_sql)
# 删除用户主表记录
delete_user_condition = 'id=%s' % id
delete_user_sql = self.create_delete_sql(
db_name, 'users', delete_user_condition)
self.delete_exec(conn, delete_user_sql)
data = response_code.SUCCESS
return data
except Exception as e:
lg.error(e)
return response_code.DELETE_DATA_FAIL
finally:
conn.close()
def get_user_by_id(self, id):
"""
通过id获取用户
:return:
"""
conn = MysqlConn()
try:
condition = "id='%s'" % id
db_name = configuration.get_database_name()
sql = self.create_select_sql(db_name,
'users',
'*',
condition=condition)
return self.execute_fetch_one(conn, sql)
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
conn.close()
def add_operation_log(self, user_key, ip_address, level, description):
"""
添加操作日志
:param user_key:
:param ip_address:
:param level:
:param description:
:return:
"""
db_conn = MysqlConn()
time_create = get_system_datetime()
db_name = configuration.get_database_name()
table_name = 'system_oper_log'
fields = '(user_key,ip_address,level,description,time_create)'
pla_data = (user_key, ip_address, level, description, time_create)
sql = DbBase.create_insert_sql(self, db_name, table_name, fields,
pla_data)
DbBase.execute_sql_return_count(self, db_conn, sql)
db_conn.close()
def get_all_user(self):
"""
查询所有用户
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'users'
fields = 'id,user_name,user_sex,email,phone,position,note_info,login_name'
sql = self.create_select_sql(db_name, table_name, fields)
result = self.execute_fetch_all(db_conn, sql)
data = response_code.SUCCESS
data['data'] = result
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def get_all_groups(self):
"""
获取所有用户组
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'user_group'
fields = 'id,name,description as desc,create_time'
sql = self.create_select_sql(db_name, table_name, fields)
result = self.execute_fetch_all(db_conn, sql)
data = response_code.SUCCESS
data['data'] = result
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def get_all_department(self):
"""
获取所有的部门信息
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'department'
fields = 'dpt_id,dpt_name,p_id'
sql = self.create_select_sql(db_name, table_name, fields)
result = self.execute_fetch_all(db_conn, sql)
data = response_code.SUCCESS
data['data'] = result
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def get_all_roles(self):
"""
获取所有的角色信息
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'role'
role_fields = 'id,name,create_time,note_info,time_modify'
sql = self.create_select_sql(db_name, table_name, role_fields)
result = self.execute_fetch_all(db_conn, sql)
data = response_code.SUCCESS
data['data'] = result
return data
except Exception as e:
lg.error(e)
return response_code.GET_DATA_FAIL
finally:
db_conn.close()
def add_group(self, group_name, group_desc, role_ids):
"""
添加用户组
:param group_name:
:param group_desc:
:return:
"""
db_conn = MysqlConn()
try:
db_name = configuration.get_database_name()
table_name = 'user_group'
filed = 'name'
condition = "name = '%s'" % group_name
is_exist_sql = self.create_select_sql(db_name, table_name, filed,
condition)
res = self.execute_fetch_one(db_conn, is_exist_sql)
if res:
return response_code.RECORD_EXIST
fields = '(name,description,create_time)'
create_time = get_system_datetime()
value_tuple = (group_name, group_desc, create_time)
insert_user_sql = self.create_insert_sql(db_name, table_name,
fields, value_tuple)
self.insert_exec(db_conn, insert_user_sql)
# 查询新添加的用户组
new_group = self.get_user_group_by_name(group_name)
new_group_id = new_group.get('id')
# 添加用户组的角色
group_role_fields = '(group_id,role_id)'
for role_id in eval(str(role_ids)):
group_role_value_tuple = (new_group_id, role_id)
insert_user_sql = self.create_insert_sql(
db_name, "user_group_role", group_role_fields,
group_role_value_tuple)
self.insert_exec(db_conn, insert_user_sql)
return response_code.SUCCESS
except Exception as e:
lg.error(e)
return response_code.ADD_DATA_FAIL
finally:
db_conn.close()
def pwd_reset(self, user_ids):
'''
重置用户密码
:return:
'''
conn = MysqlConn()
try:
db_name = configuration.get_database_name()
pass_word = generate_password_hash('123456')
for user_id in eval(str(user_ids)):
condition = 'id=%s' % user_id
update_user_sql = self.create_update_sql(
db_name, 'users', ['pass_word'], [pass_word], condition)
self.updete_exec(conn, update_user_sql)
data = response_code.SUCCESS
return data
except Exception as e:
lg.error(e)
return response_code.PASS_WORD_RESET_FAIL
finally:
conn.close()
