def shelf_award(self):
"""撤销申请"""
if not (is_supplizer() or is_admin()):
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
other_apply_info = MagicBoxApply.query.filter(
MagicBoxApply.isdelete == False,
MagicBoxApply.MBAid != mbaid,
MagicBoxApply.MBAstatus.notin_(
[ApplyStatus.cancle.value, ApplyStatus.reject.value]),
MagicBoxApply.OSid == apply_info.OSid,
).first()
current_app.logger.info("其他的同库存申请 --> {}".format(other_apply_info))
if apply_info.MBAstatus != ApplyStatus.wait_check.value:
raise StatusError('只有在审核状态的申请可以撤销')
if apply_info.SUid != request.user.id:
raise AuthorityError('仅可撤销自己提交的申请')
apply_info.MBAstatus = ApplyStatus.cancle.value
# 是否修改库存
if not other_apply_info:
out_stock = OutStock.query.filter(
OutStock.isdelete == False,
OutStock.OSid == apply_info.OSid).first()
self._update_stock(out_stock.OSnum, skuid=apply_info.SKUid)
# 同时将正在进行的审批流改为取消
approval_info = Approval.query.filter_by_(
AVcontent=mbaid,
AVstartid=request.user.id,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.AVstatus = ApplyStatus.cancle.value
return Success('取消成功', {'mbaid': mbaid})
def cancel_apply(self):
"""取消申请"""
if is_supplizer():
sup = Supplizer.query.filter_by_(SUid=request.user.id).first_("账号状态错误")
else:
raise AuthorityError()
data = parameter_required(('gpid',))
with db.auto_commit():
gp = GroupGoodsProduct.query.filter(GroupGoodsProduct.GPid == data.get('gpid'),
GroupGoodsProduct.isdelete == False,
GroupGoodsProduct.GPstatus == ApplyStatus.wait_check.value
).first_("只有待审核状态下的申请可以撤销")
if gp.SUid != sup.SUid:
raise AuthorityError("只能撤销属于自己的申请")
gp.update({'GPstatus': ApplyStatus.cancle.value})
db.session.add(gp)
# 返回库存
product = Products.query.filter_by(PRid=gp.PRid, isdelete=False).first_('商品信息出错')
gps_old = GroupGoodsSku.query.filter(GroupGoodsSku.GPid == gp.GPid,
GroupGoodsSku.isdelete == False,
).all()
for sku in gps_old:
sku_instance = ProductSku.query.filter_by(isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CGuessGroup, self)._update_stock(int(sku.GSstock), product, sku_instance)
# 同时取消正在进行的审批流
Approval.query.filter_by(AVcontent=gp.GPid, AVstartid=sup.SUid,
isdelete=False, AVstatus=ApplyStatus.wait_check.value
).update({'AVstatus': ApplyStatus.cancle.value})
return Success('已取消申请', {'gpid': gp.GPid})
def resubmit_apply(self):
"""重新提交申请"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} resubmit commodity'.format(
sup.SUname))
nefrom = ApplyFrom.supplizer.value
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} resubmit commodity'.format(
admin.ADname))
nefrom = ApplyFrom.platform.value
sup = None
else:
raise AuthorityError()
data = parameter_required(('tcid', ))
tcid = data.get('tcid')
with db.auto_commit():
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('无此商品信息')
if commodity.TCstatus not in [
TrialCommodityStatus.cancel.value,
TrialCommodityStatus.reject.value
]:
raise StatusError('只有撤销或已下架状态的申请可以重新提交')
if sup:
if commodity.CreaterId != usid:
raise AuthorityError('仅可重新提交自己上传的商品')
commodity.TCstatus = TrialCommodityStatus.auditing.value
# 重新创建一个审批流
super().create_approval('totrialcommodity', usid, tcid, nefrom)
return Success('提交成功', {'tcid': tcid})
def cancel_commodity_apply(self):
"""撤销自己的申请"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} cancel commodity'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} cancel commodity'.format(
admin.ADname))
else:
raise AuthorityError()
data = parameter_required(('tcid', ))
tcid = data.get('tcid')
with db.auto_commit():
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('无此商品信息')
if commodity.TCstatus != TrialCommodityStatus.auditing.value:
raise StatusError('只有在审核状态的申请可以撤销')
if commodity.CreaterId != request.user.id:
raise AuthorityError('仅可撤销自己提交的申请')
commodity.TCstatus = TrialCommodityStatus.cancel.value
# 同时将正在进行的审批流改为取消
approval_info = Approval.query.filter_by_(
AVcontent=tcid,
AVstartid=request.user.id,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.AVstatus = ApplyStatus.cancle.value
return Success('取消成功', {'tcid': tcid})
def shelf_award(self):
"""撤销申请"""
if not (is_supplizer() or is_admin()):
raise AuthorityError()
data = parameter_required(('tlpid', ))
tlpid = data.get('tlpid')
if is_supplizer():
tlp_from = ApplyFrom.supplizer.value
suid = request.user.id
else:
tlp_from = ApplyFrom.platform.value
suid = None
with db.auto_commit():
apply_info = TimeLimitedProduct.query.filter_by(
TLPid=tlpid, isdelete=False).first_('无此申请记录')
if apply_info.TLAstatus != ApplyStatus.wait_check.value:
raise StatusError('只有在审核状态的申请可以撤销')
if apply_info.SUid != suid:
raise AuthorityError('仅可撤销自己提交的申请')
apply_info.TLAstatus = ApplyStatus.cancle.value
# 获取原商品属性
# gnap_old = GuessNumAwardProduct.query.filter(GuessNumAwardProduct.GNAAid == apply_info.GNAAid,
# GuessNumAwardProduct.isdelete == False).first()
product = Products.query.filter_by(PRid=apply_info.PRid,
PRfrom=tlp_from,
isdelete=False).first_('商品信息出错')
# 获取原sku属性
tls_list = TimeLimitedSku.query.filter(
TimeLimitedSku.isdelete == False,
TimeLimitedSku.TLPid == apply_info.TLPid).all()
# 遍历原sku 将库存退出去
for sku in tls_list:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
self._update_stock(int(sku.TLSstock), product, sku_instance)
# 同时将正在进行的审批流改为取消 todo
approval_info = Approval.query.filter_by(
AVcontent=tlpid,
AVstartid=request.user.id,
isdelete=False,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.AVstatus = ApplyStatus.cancle.value
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'TimeLimitedProduct', tlpid)
return Success('取消成功', {'tlpid': tlpid})
def on_setsession(self, token):
from planet.common.request_handler import token_to_user_
current_app.logger.info(token)
user = token_to_user_(token)
current_app.logger.info(user)
usersid = conn.get('usersid')
current_app.logger.info('get sids', usersid)
current_app.logger.info('get connect sid ', request.sid)
# from flaskrun import sids
current_app.logger.info(
'request ',
request.headers,
)
# join_room(request.sid)
if user:
sessiondict = {user.id: request.sid}
# 创建session
session.update({'id': user.id})
if not usersid:
conn.set('usersid', sessiondict)
else:
usersid = ast.literal_eval(str(usersid, encoding='utf-8'))
current_app.logger.info('pre append ', usersid)
# sids.append(request.sid)
usersid.update(sessiondict)
current_app.logger.info('after ', usersid)
conn.set('usersid', usersid)
# res = json.loads(json.dumps(Success('{} is connect '.format(user.username)), cls=JSONEncoder))
# current_app.logger.info(res, type(res))
# res = json.loads(Success('{} is connect '.format(user.username)), cls=JSONEncoder)
# current_app.logger.info(res, type(res))
# self.socketio.emit('server_response', Success('{} is connect '.format(user.username)))
emit('server_response',
Success('{} is connect '.format(user.username)))
return return_res(
Success('{} is connect '.format(user.username), data=user.id))
# conn.set('sid', session.sid)
# else:
# # session['id'] = 'random'
# # session['username'] = '******'
# # conn.set('')
# return '{} is connect '.format('unknown')
# self.socketio.emit('server_response', AuthorityError('token 失效'))
emit('server_response', AuthorityError('token 失效'))
return return_res(AuthorityError('token 失效'))
def delete(self):
"""删除申请"""
# if is_supplizer():
# usid = request.user.id
# sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
# suid = sup.SUid
# current_app.logger.info('Supplizer {} delete integral apply'.format(sup.SUname))
if is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} delete integral apply'.format(
admin.ADname))
sup = None
suid = None
else:
raise AuthorityError()
data = parameter_required(('ipid', ))
ipid = data.get('ipid')
with db.auto_commit():
apply_info = IntegralProduct.query.filter_by(
IPid=ipid, isdelete=False).first_('没有该商品记录')
if sup and apply_info.SUid != suid:
raise ParamsError('只能删除自己提交的申请')
if apply_info.IPstatus not in [
ApplyStatus.cancle.value, ApplyStatus.reject.value,
ApplyStatus.shelves.value
]:
raise StatusError('只能删除已下架或已撤销状态下的申请')
apply_info.isdelete = True
IntegralProductSku.query.filter(
IntegralProductSku.IPid == apply_info.IPid).delete_()
if is_admin():
BASEADMIN().create_action(AdminActionS.delete.value,
'IntegralProduct', apply_info.IPid)
return Success('删除成功', {'ipid': ipid})
def delete_question(self):
"""后台管理员删除问题"""
if not is_admin():
raise AuthorityError('权限不足')
admin = Admin.query.filter_by_(ADid=request.user.id).first_('权限已被回收')
data = parameter_required(('qulist',))
qulist = data.get('qulist')
for quid in qulist:
qu = Quest.query.filter_by_(QUid=quid).first()
if not qu:
continue
qu.isdelete = True
qalist = Answer.query.filter_by_(QUid=qu.QUid).all()
for qa in qalist:
qa.isdelete = True
qan = QuestAnswerNote.create({
'QANid': str(uuid.uuid1()),
'QANcontent': '删除问题',
'QANcreateid': admin.ADid,
'QANtargetId': quid,
'QANtype': QuestAnswerNoteType.qu.value,
})
db.session.add(qan)
return Success('删除完成')
def delete_questoutline(self):
"""后台管理员删除问题分类"""
if not is_admin():
raise AuthorityError('权限不足')
admin = Admin.query.filter_by_(ADid=request.user.id).first_('权限已被回收')
data = parameter_required(('qolist', ))
qolist = data.get('qolist')
for qoid in qolist:
qomodel = QuestOutline.query.filter_by_(QOid=qoid).first()
if not qomodel:
continue
qomodel.isdelete = True
qulist = Quest.query.filter_by_(QOid=qoid).all()
for qu in qulist:
qu.isdelete = True
qalist = Answer.query.filter_by_(QUid=qu.QUid).all()
for qa in qalist:
qa.isdelete = True
qan = QuestAnswerNote.create({
'QANid': str(uuid.uuid1()),
'QANcontent': '删除问题分类',
'QANcreateid': admin.ADid,
'QANtargetId': qoid
})
db.session.add(qan)
BASEADMIN().create_action(AdminActionS.delete.value,
'QuestAnswerNote', str(uuid.uuid1()))
return Success('删除完成')
def delete_apply(self):
"""删除申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info(
'Supplizer {} delete magicbox apply'.format(sup.SUname))
elif is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} magicbox apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
if sup:
assert apply_info.SUid == usid, '供应商只能删除自己提交的申请'
if apply_info.MBAstatus not in [
ApplyStatus.cancle.value, ApplyStatus.reject.value
]:
raise StatusError('只能删除已拒绝或已撤销状态下的申请')
apply_info.isdelete = True
return Success('删除成功', {'mbaid': mbaid})
def shelf_award(self):
"""撤销申请"""
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = ShelfFreshManfirstOrder().valid_data()
fmfaid = form.fmfaid.data
with db.auto_commit():
suid = request.user.id if is_supplizer() else None
apply_query = FreshManFirstApply.query.filter(
FreshManFirstApply.isdelete == False,
FreshManFirstApply.FMFAid == fmfaid,
FreshManFirstApply.FMFAstatus == ApplyStatus.wait_check.value)
if suid:
apply_query = apply_query.filter(
FreshManFirstApply.SUid == request.user.id, )
apply = apply_query.first_('申请已处理')
# 库存处理
self._re_stock(apply)
apply.FMFAstatus = ApplyStatus.cancle.value
db.session.add(apply)
# 相应的审批流
Approval.query.filter(Approval.isdelete == False,
Approval.AVcontent == fmfaid).update(
{'AVstatus': ApplyStatus.cancle.value})
return Success('撤销成功')
def validate_usid(self, raw):
"""普通用户默认使用自己的id"""
if not raw.data:
if not is_admin():
raw.data = request.user.id
if request.user.id != raw.data:
raise AuthorityError()
def download(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
args = parameter_required(('type', ))
type = args.get('type')
try:
tp = getattr(ExcelTemplateType, type).value
except Exception:
raise ParamsError('type 参数错误')
current_app.logger.info('start download template')
template_path = os.path.join(current_app.config['BASEDIR'], 'img',
'xls')
current_app.logger.info('template path {}'.format(template_path))
if tp:
current_app.logger.info('is file {}'.format(
os.path.isfile(
os.path.join(template_path, 'deliverytemplate.xlsx'))))
return send_from_directory(template_path,
'deliverytemplate.xlsx',
as_attachment=True)
current_app.logger.info('is file {}'.format(
os.path.isfile(os.path.join(template_path, 'template.xlsx'))))
return send_from_directory(template_path,
'template.xlsx',
as_attachment=True)
def shelves(self):
"""下架申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info(
'Supplizer {} delete magicbox apply'.format(sup.SUname))
elif is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} magicbox apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
if sup:
assert apply_info.SUid == usid, '供应商只能下架自己的申请'
if apply_info.MBAstatus != ApplyStatus.agree.value:
raise StatusError('只能下架已通过的申请')
apply_info.MBAstatus = ApplyStatus.reject.value
return Success('下架成功', {'mbaid': mbaid})
def del_commodity(self):
"""删除试用商品"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} delete commodity'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} delete commodity'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(("tcid", ))
tcid = data.get('tcid')
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('未找到商品信息, tcid参数异常')
if sup:
assert commodity.CreaterId == usid, '供应商只能删除自己上传的商品'
if commodity.TCstatus not in [
TrialCommodityStatus.reject.value,
TrialCommodityStatus.cancel.value
]:
raise StatusError('只能删除已下架或已撤销的商品')
with db.auto_commit():
TrialCommodity.query.filter_by(TCid=tcid).delete_()
TrialCommodityImage.query.filter_by(TCid=tcid).delete_()
TrialCommoditySku.query.filter_by(TCid=tcid).delete_()
TrialCommoditySkuValue.query.filter_by(TCid=tcid).delete_()
return Success('删除成功', {'tcid': tcid})
def shelves(self):
"""批量下架试用商品"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} shelves commodity'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} shelves commodity'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(("tcids", ))
tcid_list = data.get('tcids')
for tcid in tcid_list:
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('未找到商品信息, tcid参数异常')
if sup:
assert commodity.CreaterId == usid, '供应商只能下架自己上传的商品'
if commodity.TCstatus != TrialCommodityStatus.upper.value:
raise StatusError('只能下架正在上架状态的商品')
with db.auto_commit():
commodity.TCstatus = TrialCommodityStatus.reject.value
return Success('下架成功', {'tcid': tcid_list})
def change_password(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = SupplizerChangePasswordForm().valid_data()
old_password = form.oldpassword.data
supassword = form.supassword.data
suid = form.suid.data
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == suid).first_('不存在的供应商')
if not is_admin() and not check_password_hash(
supplizer.SUpassword, old_password):
raise AuthorityError('原密码错误')
supplizer.SUpassword = generate_password_hash(supassword)
db.session.add(supplizer)
return Success('修改成功')
def cancel_apply(self):
"""取消申请"""
if is_admin():
Admin.query.filter_by_(ADid=request.user.id).first_("账号状态错误")
# elif is_supplizer():
# Supplizer.query.filter_by_(SUid=request.user.id).first_("账号状态错误")
else:
raise AuthorityError()
data = parameter_required(('ipid', ))
with db.auto_commit():
ip = IntegralProduct.query.filter(
IntegralProduct.IPid == data.get('ipid'),
IntegralProduct.isdelete == False, IntegralProduct.IPstatus ==
ApplyStatus.wait_check.value).first_("只有在审核状态下的申请可以撤销")
if is_supplizer() and ip.SUid != request.user.id:
raise AuthorityError("只能撤销属于自己的申请")
ip.update({'IPstatus': ApplyStatus.cancle.value})
db.session.add(ip)
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'IntegralProduct', data.get('ipid'))
# 返回库存
product = Products.query.filter_by(PRid=ip.PRid,
isdelete=False).first_('商品信息出错')
ips_old = IntegralProductSku.query.filter(
IntegralProductSku.IPid == ip.IPid,
IntegralProductSku.isdelete == False,
IntegralProduct.isdelete == False,
).all()
for sku in ips_old:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CIntegralStore,
self)._update_stock(int(sku.IPSstock), product,
sku_instance)
# 同时取消正在进行的审批流
Approval.query.filter_by(
AVcontent=ip.IPid,
AVstartid=request.user.id,
isdelete=False,
AVstatus=ApplyStatus.wait_check.value).update(
{'AVstatus': ApplyStatus.cancle.value})
return Success('已取消申请', dict(ipid=ip.IPid))
def delete(self):
if not is_admin():
raise AuthorityError()
data = SignIndelete().valid_data()
siaid = data.siaid.data
check_sia = SignInAward.query.filter_by(SIAid=siaid,
isdelete=False).delete_()
if not check_sia:
raise ParamsError('已删除')
return Success('删除设置成功')
def shelf_award(self):
"""撤销申请"""
if is_supplizer():
sup = Supplizer.query.filter_by_(
SUid=request.user.id).first_("账号状态错误")
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter(
MagicBoxApply.MBAid == mbaid,
MagicBoxApply.isdelete == False,
MagicBoxApply.MBAstatus == ApplyStatus.wait_check.value,
).first_('只有待审核状态下的申请可以撤销')
if apply_info.SUid != sup.SUid:
raise AuthorityError("只能撤销属于自己的申请")
apply_info.update({'MBAstatus': ApplyStatus.cancle.value})
db.session.add(apply_info)
# 返回库存
product = Products.query.filter_by(PRid=apply_info.PRid,
isdelete=False).first_('商品信息出错')
gps_old = MagicBoxApplySku.query.filter(
MagicBoxApplySku.MBAid == apply_info.MBAid,
MagicBoxApplySku.isdelete == False,
).all()
for sku in gps_old:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CMagicBox, self)._update_stock(int(sku.MBSstock),
product, sku_instance)
# 同时取消正在进行的审批流
Approval.query.filter_by(
AVcontent=apply_info.MBAid,
AVstartid=sup.SUid,
isdelete=False,
AVstatus=ApplyStatus.wait_check.value).update(
{'AVstatus': ApplyStatus.cancle.value})
return Success('取消成功', {'mbaid': mbaid})
def delete(self):
if not is_admin():
raise AuthorityError()
data = SignIndelete().valid_data()
siaid = data.siaid.data
check_sia = SignInAward.query.filter_by(SIAid=siaid,
isdelete=False).delete_()
BASEADMIN().create_action(AdminActionS.delete.value, 'SignInAward',
siaid)
if not check_sia:
raise ParamsError('已删除')
return Success('删除设置成功')
def shelves(self):
"""下架申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info('Supplizer {} shelf magicbox apply'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} shelf magicbox apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
pending_box = MagicBoxJoin.query.filter(
MagicBoxJoin.isdelete == False,
MagicBoxJoin.MBJstatus == MagicBoxJoinStatus.pending.value,
MagicBoxJoin.MBSendtime >= datetime.now().date(),
MagicBoxJoin.MBAid == mbaid).first()
if pending_box:
current_app.logger.info('仍存在未完成礼盒 MBJid: {}'.format(
pending_box.MBJid))
raise StatusError('该商品仍有正在分享中的礼盒未完成，暂不能下架')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
if sup and apply_info.SUid != usid:
raise StatusError('只能下架自己的申请')
if apply_info.MBAstatus != ApplyStatus.agree.value:
raise StatusError('只能下架已通过的申请')
apply_info.MBAstatus = ApplyStatus.shelves.value
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'MagicBoxApply', mbaid)
# 返回库存
product = Products.query.filter_by(PRid=apply_info.PRid,
isdelete=False).first_('商品信息出错')
mbs_old = MagicBoxApplySku.query.filter(
MagicBoxApplySku.MBAid == apply_info.MBAid,
MagicBoxApplySku.isdelete == False,
).all()
for sku in mbs_old:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CMagicBox, self)._update_stock(int(sku.MBSstock),
product, sku_instance)
return Success('下架成功', {'mbaid': mbaid})
def download(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
current_app.logger.info('start download template')
template_path = os.path.join(current_app.config['BASEDIR'], 'img',
'xls')
current_app.logger.info('template path {}'.format(template_path))
current_app.logger.info('is file {}'.format(
os.path.isfile(os.path.join(template_path, 'template.xlsx'))))
return send_from_directory(template_path,
'template.xlsx',
as_attachment=True)
def list_apply(self):
"""查看申请列表"""
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = ListFreshmanFirstOrderApply().valid_data()
starttime, endtime = form.starttime.data, form.endtime.data
suid = form.suid.data
if is_supplizer():
suid = request.user.id
adid = form.adid.data
status = form.status.data
query = FreshManFirstApply.query.filter(
FreshManFirstApply.isdelete == False)
if suid:
query = query.filter(
FreshManFirstApply.SUid == suid,
FreshManFirstApply.FMFAfrom == ApplyFrom.supplizer.value)
if adid:
query = query.filter(
FreshManFirstApply.SUid == adid,
FreshManFirstApply.FMFAfrom == ApplyFrom.platform.value)
if status is not None:
query = query.filter(FreshManFirstApply.FMFAstatus == status)
applys = query.filter(
FreshManFirstApply.FMFAstartTime >= starttime,
FreshManFirstApply.FMFAendTime <= endtime).order_by(
FreshManFirstApply.createtime.desc()).all_with_page()
for apply in applys:
# 状态中文
apply.fill('FMFAstatus_zh', ApplyStatus(apply.FMFAstatus).zh_value)
# 商品
fresh_product = FreshManFirstProduct.query.filter(
FreshManFirstProduct.isdelete == False,
FreshManFirstProduct.FMFAid == apply.FMFAid,
).first()
apply.fill('fresh_product', fresh_product)
# 活动sku
freshsku = FreshManFirstSku.query.filter(
FreshManFirstSku.isdelete == False,
FreshManFirstSku.FMFPid == fresh_product.FMFPid).all()
fresh_product.fill('sku', freshsku)
# 申请人
if apply.FMFAfrom == ApplyFrom.supplizer.value:
supplizer = Supplizer.query.filter(
Supplizer.SUid == apply.SUid).first()
apply.fill('from_supplizer', supplizer)
elif apply.FMFAfrom == ApplyFrom.platform.value:
admin = Admin.query.filter(Admin.ADid == apply.SUid).first()
admin.hide('ADfirstpwd', 'ADpassword')
apply.fill('from_admin', admin)
return Success(data=applys)
def set_banner(self):
data = parameter_required({'pbid': '品牌唯一值缺失'})
pbid = data.get('pbid')
if is_supplizer():
supplizer = get_current_supplizer()
ProductBrand.query.filter(
ProductBrand.PBid == pbid, ProductBrand.SUid == supplizer.SUid).first_('只能修改自己的品牌')
elif is_admin():
ProductBrand.query.filter(
ProductBrand.PBid == pbid).first_('品牌不存在')
else:
raise AuthorityError()
bbid = data.get('bbid')
bbcontent = data.get('bbcontent')
if bbcontent:
try:
bbcontent = json.dumps(bbcontent)
except Exception as e:
current_app.logger.info('转置json 出错 bbcontent = {} e = {}'.format(bbcontent, e))
bbsort = data.get('bbsort')
if bbsort:
bbsort = self._check_sort(bbsort, model=BrandBanner, filter_args=[BrandBanner.PBid == pbid], default=1)
with db.auto_commit():
if bbid:
if data.get('delete'):
BrandBanner.query.filter(BrandBanner.BBid == bbid, BrandBanner.isdelete == false()).delete_(
synchronize_session=False)
return Success('删除成功')
bb = BrandBanner.query.filter(BrandBanner.BBid == bbid, BrandBanner.isdelete == false()).first()
if bb:
if bbsort:
bb.BBsort = bbsort
if bbcontent:
bb.BBcontent = bbcontent
return Success('更新成功', data=bbid)
bbid = str(uuid.uuid1())
if not bbcontent:
raise ParamsError('轮播图图片路由缺失')
bb = BrandBanner.create({
'BBid': bbid,
'PBid': pbid,
'BBsort': bbsort or 1,
'BBcontent': bbcontent
})
db.session.add(bb)
return Success('添加成功', data=bbid)
def add_questanswer(self):
"""插入或更新问题及答案"""
if not is_admin():
raise AuthorityError('权限不足')
data = parameter_required(('qoid', 'quest', 'answer'))
admin = Admin.query.filter(
Admin.ADid == request.user.id,
Admin.ADstatus == AdminStatus.normal.value).first_('权限被收回')
quest_filter = Quest.query.filter_(Quest.QOid == data.get('qoid'),
Quest.QUquest == data.get('quest'),
Quest.isdelete == False).first()
# answer_model = Answer.query.filter_(Answer.QAcontent == data.get('answer'), Answer.isdelete == False).first()
if data.get('quid'):
quest_model = Quest.query.filter_(Quest.QUid == data.get('quid'),
Quest.isdelete == False).first()
# 根据id 更新问题，如果问题重复则抛出异常
self.__update_quest(data, quest_model, quest_filter)
self.__update_answer(data.get('answer'), quest_model)
return Success('修改问题成功')
# 如果传入的问题已经存在但是没有传入id ，还是执行update 操作
if quest_filter:
self.__update_quest(data, quest_filter)
self.__update_answer(data.get('answer'), quest_filter)
return Success('修改问题成功')
# 不在数据库内的问题插入
quest_instance = Quest.create({
'QOid': data.get('qoid'),
'QUid': str(uuid.uuid1()),
'QUquest': data.get('quest'),
'QUcreateId': admin.ADid
})
answer_instance = Answer.create({
'QAid': str(uuid.uuid1()),
'QUid': quest_instance.QUid,
'QAcontent': data.get('answer'),
'QAcreateId': admin.ADid
})
db.session.add(
quest_instance,
BASEADMIN().create_action(AdminActionS.insert.value, 'Quest',
str(uuid.uuid1())))
db.session.add(answer_instance)
BASEADMIN().create_action(AdminActionS.insert.value, 'Answer',
str(uuid.uuid1()))
return Success('创建问题成功')
def get(self):
if not is_admin() and not is_supplizer():
raise AuthorityError()
form = SupplizerGetForm().valid_data()
supplizer = form.supplizer
self._fill_supplizer(supplizer)
pbs = ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.SUid == supplizer.SUid).all()
for pb in pbs:
if pb:
pb.pbstatus_zh = ProductBrandStatus(pb.PBstatus).zh_value
pb.add('pbstatus_zh')
supplizer.fill('pbs', pbs)
supplizer.fill('SUbaseRate', supplizer.SUbaseRate or 0)
return Success(data=supplizer)
def del_award(self):
"""删除申请"""
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = ShelfFreshManfirstOrder().valid_data()
fmfaid = form.fmfaid.data
with db.auto_commit():
apply_info = FreshManFirstApply.query.filter_by_(FMFAid=fmfaid).first_('申请未找到或已删除')
if is_supplizer():
assert apply_info.SUid == request.user.id, '供应商只能删除自己提交的申请'
if apply_info.FMFAstatus not in [ApplyStatus.cancle.value, ApplyStatus.reject.value]:
raise StatusError('只能删除已拒绝或已撤销状态下的申请')
apply_info.isdelete = True
if is_admin():
BASEADMIN().create_action(AdminActionS.delete.value, 'FreshManFirstApply', fmfaid)
return Success('删除成功', {'fmfaid': fmfaid})
def get_all(self):
"""后台管理员查看所有的问题及答案"""
if not is_admin():
raise AuthorityError('权限不足')
qo_list = QuestOutline.query.filter_(
QuestOutline.isdelete == False).order_by(QuestOutline.createtime.desc()).all()
for qo in qo_list:
qo.fields = self.QuestOutlineFields[:]
question_list = Quest.query.filter_(
Quest.isdelete == False, Quest.QOid == qo.QOid).order_by(Quest.createtime.desc()).all()
for question in question_list:
question.fields = self.QuestFields[:]
answer = Answer.query.filter_(Answer.QUid == question.QUid, Answer.isdelete == False).first_('问题答案遗失')
answer.fields = self.AnswerFields[:]
question.fill('answer', answer.QAcontent)
qo.fill('question', question_list)
return Success('获取客服问题列表成功', data=qo_list)
def add_questoutline(self):
"""插入或更新问题分类"""
if not is_admin():
raise AuthorityError('权限不足')
data = parameter_required(('qoicon', 'qoname'))
qotype = data.get('qotype')
admin = Admin.query.filter(
Admin.ADid == request.user.id,
Admin.ADstatus == AdminStatus.normal.value).first_('权限被收回')
if qotype != 222:
qotype = 111
qo_filter = QuestOutline.query.filter_(
QuestOutline.QOname == data.get('qoname'),
QuestOutline.QOtype == qotype,
QuestOutline.isdelete == False).first()
# 查看是否为修改
if data.get('qoid'):
qo_model = QuestOutline.query.filter_(
QuestOutline.isdelete == False,
QuestOutline.QOid == data.get('qoid')).first()
if qo_model:
self.__update_questoutline(data, qo_model, qotype, qo_filter)
qo_model.fields = self.QuestOutlineFields[:]
return Success('修改问题分类成功', data=qo_model)
# 名称重复的增加 暂时变更为修改，后期可以扩展为整个分类的迁移
if qo_filter:
self.__update_questoutline(data, qo_filter, qotype)
qo_filter.fields = self.QuestOutlineFields[:]
return Success('修改问题分类成功', data=qo_filter)
# 正常添加
qo_instance = QuestOutline.create({
'QOid': str(uuid.uuid1()),
'QOicon': data.get('qoicon'),
'QOname': data.get('qoname'),
'QOtype': qotype,
'QOcreateId': admin.ADid
})
db.session.add(qo_instance)
BASEADMIN().create_action(AdminActionS.insert.value, 'QuestOutline',
str(uuid.uuid1()))
qo_instance.fields = self.QuestOutlineFields[:]
return Success('创建问题分类成功', data=qo_instance)