def add_route(gid, routes):
with db.auto_commit():
Group.get_or_404(id=gid, msg='无指定权限组')
for route_id in routes:
Route.get_or_404(id=route_id, msg='无指定路由节点')
Menu.abort_repeat(group_id=gid, route_id=route_id)
Menu.create(group_id=gid, route_id=route_id)
def create_user(form):
with db.auto_commit():
user = User.create(commit=False,
nickname=getattr(form, 'nickname', None),
auth=ScopeEnum.COMMON.value)
if (hasattr(form, 'username')):
Identity.abort_repeat(identifier=form.username,
msg='该用户名已被使用，请重新输入新的用户名')
Identity.create(commit=False,
user_id=user.id,
type=ClientTypeEnum.USERNAME.value,
verified=1,
identifier=form.username,
password=form.password)
if (hasattr(form, 'mobile')):
Identity.abort_repeat(identifier=form.mobile,
msg='手机号已被使用，请重新输入新的手机号')
Identity.create(commit=False,
user_id=user.id,
type=ClientTypeEnum.MOBILE.value,
identifier=form.mobile,
password=form.password)
if (hasattr(form, 'email')):
Identity.abort_repeat(identifier=form.email,
msg='邮箱已被使用，请重新输入新的邮箱号')
Identity.create(commit=False,
user_id=user.id,
type=ClientTypeEnum.EMAIL.value,
identifier=form.email,
password=form.password)
def __create_order(self, snap):
'''将订单写入到数据库'''
order_no = OrderService.make_order_no()
with db.auto_commit():
order = Order()
order.user_id = self.uid
order.order_no = order_no
order.total_price = snap['order_price']
order.total_count = snap['total_count']
order.snap_img = snap['snap_img']
order.snap_name = snap['snap_name']
order.snap_address = snap['snap_address']
order.snap_items = json.dumps(snap['p_status'], ensure_ascii=False)
db.session.add(order)
db.session.flush() # 刷新数据库缓存，不操作事务
order_id = order.id # 获取更新后的order信息
for p in self.o_products:
# 起初每个p的格式 {'product_id': x, 'count': y}
p['order_id'] = order_id
db.session.add_all([
Order2Product(p['order_id'], p['product_id'], p['count'])
for p in self.o_products
])
return {
'order_no': order_no,
'order_id': order_id,
'create_time': order.create_time
}
def reset_password(uid, password):
identity_list = Identity.query.filter(
Identity.type.in_([
ClientTypeEnum.USERNAME.value, ClientTypeEnum.EMAIL.value,
ClientTypeEnum.MOBILE.value
]), Identity.user_id == uid).all()
with db.auto_commit():
for item in identity_list:
item.update(commit=False, password=password)
def set_avatar(id, avatar):
'''
:param id: 用户id
:param avatar: 头像url
:return:
'''
with db.auto_commit():
user = User.get(id=id)
user._avatar = avatar
def cover_menus(group_id, routes):
Menu.query.filter_by(group_id=group_id).delete(
synchronize_session=False)
t = RouteTree()
t.generate_by_dir({'id': 0, 'children': routes})
with db.auto_commit():
for route in t.deserialize():
if route['id'] != 0:
Menu.create(group_id=group_id, route_id=route['id'])
def register_by_wx_mina(openid: str):
"""小程序注册"""
with db.auto_commit():
user = User.create(commit=False)
Identity.create(commit=False,
user_id=user.id,
type=ClientTypeEnum.WX_MINA.value,
identifier=openid,
verified=1)
return user
def delete(id: int):
route = Route.get_or_404(id=id, msg='路由不存在, 删除失败')
# 禁止任意删除
if Menu.get(route_id=id):
raise Forbidden(msg='存在权限组的菜单绑定路由，不可删除')
with db.auto_commit():
route.delete(commit=False)
Route.query.filter_by(parent_id=id).delete(
synchronize_session=False)
def change_password(uid, old_password, new_password):
identity = Identity.get_or_404(user_id=uid) # 找到一个
if identity.check_password(old_password):
identity_list = Identity.query.filter(
Identity.type.in_([
ClientTypeEnum.USERNAME.value, ClientTypeEnum.EMAIL.value,
ClientTypeEnum.MOBILE.value
]), Identity.user_id == uid).all()
with db.auto_commit():
for item in identity_list:
item.update(commit=False, password=new_password)
def delete_auth_list(group_id, auth_ids=[]):
'''
:param group_id: 权限组id
:param auth_ids: 权限id数组
:return:
'''
auth_name_list = [get_ep_name(id) for id in auth_ids]
with db.auto_commit():
db.session.query(Auth).filter(
Auth.name.in_(auth_name_list),
Auth.group_id == group_id).delete(synchronize_session=False)
def delivery(order_id, jump_page=''):
''' 将订单状态从「已支付」转为「已发货」
jump_page(跳转页面)
'''
order = Order.query.filter_by(id=order_id).first_or_404()
# 判断是否已付款
if order.order_status != OrderStatusEnum.PAID:
raise OrderException(code=403,
error_code=8002,
msg='订单未支付，或已经更新过订单了')
with db.auto_commit():
order.order_status = OrderStatusEnum.DELIVERED
return {'order': order, 'jump_page': jump_page}
def change_route(route_list: list):
cur_t = RouteTree()
cur_t.generate_by_dir({'id': 0, 'children': route_list})
cur_list = cur_t.deserialize()
with db.auto_commit():
for cur_route in cur_list:
old_route = Route.get(id=cur_route['id'])
if old_route and \
(old_route.parent_id != cur_route['parent_id'] or
old_route.order != cur_route['order']):
old_route.update(id=cur_route['id'],
parent_id=cur_route['parent_id'],
order=cur_route['order'],
commit=False)
def delete_group(id):
'''
:param id: 权限组id
:return:
'''
group = Group.get_or_404(id=id, msg='分组不存在，删除失败')
if User.get(group_id=id):
raise Forbidden(msg='分组下存在用户，不可删除')
# 删除group拥有的权限
with db.auto_commit():
db.session.query(Auth).filter(Auth.group_id == id).delete(
synchronize_session=False)
group.hard_delete(commit=False)
def delete_identity(user_id, type):
'''删除时，需要判断type的类型
因为username、mobile、email的解绑需要清除user表的对应字段
'''
user = User.get(id=user_id)
with db.auto_commit():
# 判断是否是网站内部的身份类型
if ClientTypeEnum(
type) in current_app.config['CLINET_INNER_TYPES']:
attr = ClientTypeEnum(type).name.lower()
setattr(user, attr, None)
user.save(commit=False)
identity = Identity.get_or_404(user_id=user_id, type=type)
identity.hard_delete(commit=False) # 硬删除
def reorder_image(p_id, src_order, dest_order):
'''
:param p_id: 商品id
:param src_order: 图片的原顺序
:param dest_order: 图片的新顺序
:return:
'''
[min, max] = sorted([src_order, dest_order])
pending_reorder_list = Product2Image.query.filter(
Product2Image.product_id == p_id,
Product2Image.order.between(min, max)
).order_by(Product2Image.order.asc()).all()
if len(pending_reorder_list) <= 1:
raise ProductException(msg='该商品仅有一张图片，无法重新排序')
# 往后移动(1,2,「3」,4,5 ==> 1,2,4,5,「3」)
# 3放在5的位置(即prev_order为3，next_order为5)
if src_order < dest_order:
with db.auto_commit():
src_obj = pending_reorder_list.pop(0) # 抛除首位
dest_obj = pending_reorder_list[-1]
src_obj.update(commit=False, order=dest_obj.order)
# order向前移动(变小)
for obj in pending_reorder_list:
obj.update(commit=False, order=obj.order - 1)
# 往后移动(1,2,「3」,4,5 ==> 「3」,1,2,4,5)
# 3放在5的位置(即prev_order为3，next_order为1)
if src_order >= dest_order:
with db.auto_commit():
src_obj = pending_reorder_list.pop() # 抛除末位
dest_obj = pending_reorder_list[0]
src_obj.update(commit=False, order=dest_obj.order)
# order向后移动(变大)
for obj in pending_reorder_list:
obj.update(commit=False, order=obj.order + 1)
def create_identity(user_id, identifier, credential, type):
# 判断是否是网站内部的身份类型
if ClientTypeEnum(type) in current_app.config['CLINET_INNER_TYPES']:
with db.auto_commit():
user = User.get(id=user_id)
attr = ClientTypeEnum(type).name.lower()
setattr(user, attr, identifier)
Identity.create(commit=False,
user_id=user_id,
type=type,
identifier=identifier,
credential=credential)
user.save(commit=False)
# 第三方平台，则无需修改用户信息
else:
Identity.create(user_id=user_id, type=type, identifier=identifier)
def append_auth_list(group_id, auth_ids=[]):
'''
:param group_id: 权限组id
:param auth_ids: 权限id数组
:return:
'''
auth_name_list = [get_ep_name(id) for id in auth_ids]
with db.auto_commit():
for name in auth_name_list:
one = Auth.get(group_id=group_id, name=name)
if not one:
meta = find_auth_module(name)
Auth.create(group_id=group_id,
name=meta.name,
module=meta.module,
commit=False)
def create_group(name, auth_ids, info):
'''
:param name: 权限组名
:param auth_ids: 权限ids
:param info: 权限组名描述
:return:
'''
auth_list = [get_ep_name(auth_id) for auth_id in auth_ids] # 权限名列表
with db.auto_commit():
group = Group.create(name=name, info=info, commit=False)
db.session.flush()
for auth in auth_list:
meta = find_auth_module(auth)
if meta:
Auth.create(auth=meta.name,
module=meta.module,
group_id=group.id,
commit=False)
def move_files(dest_parent_id, file_ids):
'''
:param dest_parent_id: 目标父级目录ID
:param file_id: 文件ID
:return:
'''
file_list = File.query.filter(File.id.in_(file_ids)).all()
# 如果不重名则可以复制
with db.auto_commit():
for file in file_list:
File.abort_repeat(parent_id=dest_parent_id,
name=file.name,
extension=file.extension,
msg='文件名重复，无法移动！')
file.update(
parent_id=dest_parent_id,
commit=False,
)
def update_user(uid, form):
# 第1步: 核对需修改的信息(用户名、手机号、邮箱)
identity_infos = []
if (hasattr(form, 'username')):
identity_infos.append({
'identifier': form.username,
'type': ClientTypeEnum.USERNAME.value,
'msg': '该用户名已被使用，请重新输入新的用户名'
})
if (hasattr(form, 'mobile')):
identity_infos.append({
'identifier': form.mobile,
'type': ClientTypeEnum.MOBILE.value,
'msg': '手机号已被使用，请重新输入新的手机号'
})
if (hasattr(form, 'email')):
identity_infos.append({
'identifier': form.email,
'type': ClientTypeEnum.EMAIL.value,
'msg': '邮箱已被使用，请重新输入新的邮箱号'
})
# 第2步: 修改用户信息
with db.auto_commit():
# 第2.1步: 获取用户信息
user = User.query.filter_by(id=uid).first_or_404()
credential = IdentityDao.get_credential(user_id=uid)
# 第2.2步: 修改用户昵称
if hasattr(form, 'nickname'):
user.update(commit=False, nickname=form.nickname)
# 第2.3步: 依次修改用户身份信息(用户名、手机号、邮箱)
for item in identity_infos:
Identity.abort_repeat(identifier=item['identifier'],
msg=item['msg'])
IdentityDao.update_identity(commit=False,
user_id=uid,
identifier=item['identifier'],
credential=credential,
type=item['type'])
def delete_files(ids):
with db.auto_commit():
db.session.query(File).filter(
File.id.in_(ids), ).delete(synchronize_session=False)
def reset_permission(group_id, element_ids):
with db.auto_commit():
db.session.query(Group2Element).filter(Group2Element.group_id == group_id).delete(synchronize_session=False)
for element_id in element_ids:
Group2Element.create(group_id=group_id, element_id=element_id, commit=False)
def delete_element(ids):
with db.auto_commit():
Group2Element.query.filter(Group2Element.element_id.in_(ids)).delete(synchronize_session=False)
Element.query.filre(Element.id.in_(ids)).delete(synchronize_session=False)
def delete_routes(gid, routes):
with db.auto_commit():
Menu.query.filter(
Menu.group_id == gid,
Menu.route_id.in_(routes)).delete(synchronize_session=False)
def migrate_users(src_id, dest_id):
with db.auto_commit():
db.session.query(User).filter(User.group_id == src_id) \
.update({User.group_id: dest_id})
def delete_user(uid):
user = User.query.filter_by(id=uid).first_or_404()
with db.auto_commit():
Identity.query.filter_by(user_id=user.id).delete(commit=False)
user.delete(commit=False)
def delete_product(t_id, p_id):
theme, product = ThemeDao._check_relation_exist(t_id, p_id)
with db.auto_commit():
theme.products.remove(product)
def append_product(t_id, p_id):
theme, product = ThemeDao._check_relation_exist(t_id, p_id)
with db.auto_commit():
theme.products.append(product)
def delete_auths_by_group(group_id):
with db.auto_commit():
db.session.query(Auth).filter(Auth.group_id == group_id).delete(
synchronize_session=False)
def delete_all_log():
'''删除所有登录日志'''
with db.auto_commit():
LoginLog.query.filter().delete(synchronize_session=False)
return Success(error_code=2)
