def set_linkcontent(self):
body = request.json
admin = get_current_admin()
current_app.logger.info('当前管理员是 {}'.format(admin.ADname))
lcid = body.get('lcid')
lccontent = body.get('lccontent')
with db.auto_commit():
if lcid:
lc = LinkContent.query.filter(LinkContent.LCid == lcid, LinkContent.isdelete == False).first()
if body.get('delete'):
current_app.logger.info('开始删除富文本内容 lcid = {}'.format(lcid))
if not lc:
raise ParamsError('该内容已删除')
lc.isdelete = True
return Success('删除成功', data=lcid)
if lc:
current_app.logger.info('开始更新富文本内容 lcid = {}'.format(lcid))
if lccontent:
lc.LCcontent = lccontent
db.session.add(lc)
return Success('更新成功', data=lcid)
if not lccontent:
raise ParamsError('富文本内容不能为空')
lc = LinkContent.create({
'LCid': str(uuid.uuid1()),
'LCcontent': lccontent
})
current_app.logger.info('开始创建富文本内容 lcid = {}'.format(lc.LCid))
db.session.add(lc)
return Success('添加成功', data=lc.LCid)
def collect(self):
data = parameter_required(('uclcollection', 'uclcotype'))
user = get_current_user()
# crusid = user
ctid = data.get('uclcollection')
c = data.get('uclcotype', 0)
try:
c = CollectionType(c).value
except:
current_app.logger.info('get colletcion type {} error '.format(c))
c = 0
ctid = self._check_type_id(c, ctid)
flag = UserCollectionLog.query.filter(
UserCollectionLog.UCLcollector == user.USid,
UserCollectionLog.UCLcoType == c,
UserCollectionLog.UCLcollection == ctid,
UserCollectionLog.isdelete == False).first()
with db.auto_commit():
if flag:
flag.isdelete = True
return Success('取消收藏成功')
uin = UserCollectionLog.create({
'UCLid': str(uuid.uuid1()),
'UCLcollector': user.USid,
'UCLcollection': ctid,
'UCLcoType': c
})
db.session.add(uin)
return Success('添加收藏成功')
def add_update_notes(self):
# 创建或更新通告
from flask import request
if not is_admin():
raise AuthorityError
data = parameter_required(('mncontent', 'mnstatus'))
mnstatus = data.get('mnstatus')
mnstatus = getattr(NotesStatus, mnstatus, None)
if not mnstatus:
mnstatus = 0
else:
mnstatus = mnstatus.value
mncontent = data.get('mncontent')
mnid = data.get('mnid')
with db.auto_commit():
if mnid:
mn = ManagerSystemNotes.query.filter(
ManagerSystemNotes.MNid == mnid,
ManagerSystemNotes.isdelete == False).first()
if mn:
mn.MNcontent = mncontent
mn.MNstatus = mnstatus
mn.MNupdateid = request.user.id
return Success('更新通告成功', data=mn.MNid)
mn = ManagerSystemNotes.create({
'MNid': str(uuid.uuid1()),
'MNcontent': mncontent,
'MNstatus': mnstatus,
'MNcreateid': request.user.id
})
db.session.add(mn)
return Success('创建通告成功', data=mn.MNid)
def guide(self):
user = User.query.filter_by_(
USid=getattr(request, 'user').id).first_('请重新登录')
guide = Guide.query.filter_by_(USid=user.USid).first()
if not guide:
return Success(data={})
guide.hide('GUid')
guide.fill('gustatus_en', GuideApplyStatus(guide.GUstatus).name)
guide.fill('gustatus_zh', GuideApplyStatus(guide.GUstatus).zh_value)
return Success(data=guide)
def list(self):
"""拼团/商品列表"""
args = request.args.to_dict()
now = datetime.datetime.now()
option = args.get('option')
gpstatus = args.get('gpstatus')
starttime, endtime = args.get('starttime', '2019-01-01') or '2019-01-01', args.get('endtime', '2100-01-01') or '2100-01-01'
if is_admin() or is_supplizer():
return self._back_group_product_list(gpstatus, starttime, endtime)
if str(option) == 'my':
my_group = []
if common_user():
my_group = self._filter_joined_group().all_with_page()
list(map(lambda x: self._fill_single_group(x), my_group))
return Success(data=my_group)
elif str(option) == 'all':
all_group = self._filter_not_joined_group().all_with_page()
list(map(lambda x: self._fill_single_group(x), all_group))
return Success(data=all_group)
my_group = []
if common_user():
my_group = self._filter_joined_group().distinct().limit(2).all()
list(map(lambda x: self._fill_single_group(x), my_group))
all_group = self._filter_not_joined_group().distinct().limit(2).all()
list(map(lambda x: self._fill_single_group(x), all_group))
group_goods = GroupGoodsProduct.query.filter(GroupGoodsProduct.isdelete == False,
GroupGoodsProduct.GPstatus == ApplyStatus.agree.value,
GroupGoodsProduct.GPday == now.date()
).order_by(GroupGoodsProduct.createtime.desc()).all_with_page()
for gp in group_goods:
gp.hide('SUid', 'PRid', 'GPfreight')
product = Products.query.filter(Products.PRid == gp.PRid, Products.isdelete == False).first()
if not product:
continue
gps_list = GroupGoodsSku.query.filter_by(GPid=gp.GPid, isdelete=False).all()
gpsku_price = [gps.SKUPrice for gps in gps_list]
gp.fill('gpstatus_en', ApplyStatus(gp.GPstatus).name)
gp.fill('gpstatus_zh', ApplyStatus(gp.GPstatus).zh_value)
gp.fill('prmainpic', product['PRmainpic'])
gp.fill('prtitle', product.PRtitle)
gp.fill('gpdeposit', max(gpsku_price))
res = {'my_group': my_group,
'all_group': all_group,
'group_goods': group_goods
}
return Success(data=res)
def del_room(self):
data = parameter_required(('roid', ))
roid = data.get('roid')
usid = request.user.id
ur = UserRoom.query.filter_by(USid=usid, ROid=roid,
URshow=True).first()
if not ur:
return Success('已经删除')
with db.auto_commit():
ur.URshow = False
return Success('删除成功')
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 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_user_activationcode(self):
"""获取用户拥有的激活码"""
if not is_admin():
usid = request.user.id
user_act_codes = UserActivationCode.query.filter(
UserActivationCode.isdelete == False,
UserActivationCode.USid == usid
).order_by(
UserActivationCode.UACuseFor.asc(),
UserActivationCode.createtime.desc()
).all_with_page()
elif is_admin():
data = parameter_required()
usid = data.get('usid')
user_act_codes = UserActivationCode.query.filter_(
UserActivationCode.isdelete == False,
UserActivationCode.USid == usid
).order_by(
UserActivationCode.createtime.desc()
).all_with_page()
# todo 管理员查看激活码
pass
for user_act_code in user_act_codes:
user_act_code.fill('uacstatus_zh',
UserActivationCodeStatus(user_act_code.UACstatus).zh_value)
return Success(data=user_act_codes)
def set_supplizeraccount(self):
if not is_supplizer():
raise AuthorityError
from flask import request
data = request.json
# todo 数据校验
sa = SupplizerAccount.query.filter(
SupplizerAccount.SUid == request.user.id,
SupplizerAccount.isdelete == False).first()
if sa:
for key in sa.__dict__:
if str(key).lower() in data:
if str(key).lower() == 'suid':
continue
setattr(sa, key, data.get(str(key).lower()))
else:
sa_dict = {}
for key in SupplizerAccount.__dict__:
if str(key).lower() in data:
if str(key).lower() == 'suid':
continue
if not data.get(str(key).lower()):
continue
sa_dict.setdefault(key, data.get(str(key).lower()))
sa_dict.setdefault('SAid', str(uuid.uuid1()))
sa_dict.setdefault('SUid', request.user.id)
sa = SupplizerAccount.create(sa_dict)
db.session.add(sa)
return Success('设置供应商账户信息成功')
def batch_upload(self):
if is_tourist():
current_app.logger.info(">>> Tourist Bulk Uploading Files <<<")
else:
current_app.logger.info(">>> {} Bulk Uploading Files <<<".format(
request.user.model))
self.check_file_size()
files = request.files.to_dict()
current_app.logger.info(">>> Uploading {} Files <<<".format(
len(files)))
if len(files) > 30:
raise ParamsError('最多可同时上传30张图片')
# todo 视频数量限制
data = parameter_required()
folder = self.allowed_folder(data.get('type'))
file_url_list = []
for file in files.values():
upload_file = self._upload_file(file, folder)
file_dict = {
'data': upload_file[0],
'video_thum': upload_file[1],
'video_dur': upload_file[2],
'upload_type': upload_file[3]
}
file_url_list.append(file_dict)
return Success('上传成功', file_url_list)
def set_rule(self):
"""设置一些规则"""
form = ActRuleSetFrom().valid_data()
with db.auto_commit():
deleted = ActivationCodeRule.query.delete_()
rule_instance = ActivationCodeRule.create({
'ACRid':
str(uuid.uuid1()),
'ACRrule':
form.acrrule.data,
'ACRphone':
form.acrphone.data,
'ACRaddress':
form.acraddress.data,
'ACRname':
form.acrname.data,
'ACRbankSn':
form.acrbanksn.data,
'ACRbankAddress':
form.acrbankaddress.data,
'ACRnum':
form.acrnum.data,
'ACRcash':
form.acrcash.data
})
db.session.add(rule_instance)
return Success('添加成功', rule_instance.ACRid)
def delete(self):
"""删除"""
data = parameter_required(('suid', ))
suid = data.get('suid')
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == suid).first_('供应商不存在')
if self._check_lasting_order(suid=suid):
raise StatusError('供应商部分订单正在进行')
supplizer.isdelete = True
db.session.add(supplizer)
BASEADMIN().create_action(AdminActionS.delete.value, 'Supplizer',
suid)
# 品牌删除
productbrands = ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.SUid == suid).all()
current_app.logger.info('删除供应商{}'.format(supplizer.SUname))
for pb in productbrands:
pb.isdelete = True
db.session.add(pb)
# 商品删除
delete_product = Products.query.filter(
Products.isdelete == False,
Products.PBid == pb.PBid).update(
{'PRstatus': ProductStatus.off_shelves.value})
return Success('删除成功')
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 update(self):
"""更新购物车"""
data = parameter_required(('caid', ))
caid = data.get('caid')
usid = request.user.id
card = self.scart.get_card_one({'CAid': caid, 'USid': usid}, error='购物车不存在') # card就是cart.
# 默认的sku和数量
skuid = data.get('skuid') or card.SKUid
try:
num = int(data.get('canums', card.CAnums))
if num < 0:
raise TypeError()
except TypeError as e:
raise ParamsError('num类型错误')
msg = '更新成功'
with self.scart.auto_commit() as session:
# 数量为0执行删除
if num == 0:
session.query(Carts).filter_by({'CAid': caid}).delete_()
msg = '删除成功'
else:
session.query(ProductSku).filter_by_({'SKUid': skuid}).first_('商品sku不存在')
session.query(Carts).filter_by({'CAid': caid}).update({
'SKUid': skuid,
'CAnums': num
})
return Success(msg)
def set_award(self):
"""设置中奖"""
data = parameter_required('tsoid')
tsoid = data.get('tsoid')
ticket_order = TicketsOrder.query.filter(TicketsOrder.isdelete == false(),
TicketsOrder.TSOid == tsoid,
TicketsOrder.TSOstatus == TicketsOrderStatus.pending.value
).first_('状态错误')
ticket = Ticket.query.filter(Ticket.isdelete == false(), Ticket.TIid == ticket_order.TIid).first()
if not ticket or ticket.TIstatus != TicketStatus.over.value:
raise ParamsError('抢票尚未结束')
award_num = self._query_award_num(ticket.TIid)
current_app.logger.info('已中奖数：{} / {}'.format(award_num, ticket.TInum))
if award_num >= ticket.TInum:
raise StatusError('已达最大发放票数')
with db.auto_commit():
update_dict = {'TSOqrcode': 'https://play.bigxingxing.com/img/qrcode/2019/9/3/QRCODE.png',
'TSOstatus': TicketsOrderStatus.has_won.value}
if ticket.TIdeposit == ticket.TIprice: # 第二次支付押金0元的情况
update_dict['TSOstatus'] = TicketsOrderStatus.completed.value
ticket_order.update(update_dict)
db.session.add(ticket_order)
db.session.flush()
awarded_num = self._query_award_num(ticket.TIid)
current_app.logger.info('设置后中奖数：{} / {}'.format(awarded_num, ticket.TInum))
if awarded_num == ticket.TInum: # 未中奖退钱
other_to = self._query_not_won(ticket.TIid)
total_row_count = 0
for oto in other_to:
row_count = self._deposit_refund(oto)
total_row_count += row_count
current_app.logger.info('共{}条未中奖'.format(total_row_count))
return Success('设置成功', data=tsoid)
def update_banner(self):
current_app.logger.info("Admin {} update index banner".format(
request.user.username))
form = IndexUpdateBannerForm().valid_data()
ibid = form.ibid.data
isdelete = form.isdelete.data
IndexBanner.query.filter_by_(IBid=ibid).first_('未找到该轮播图信息')
with db.auto_commit():
banner_dict = {
'IBid': ibid,
'contentlink': form.contentlink.data,
'IBpic': form.ibpic.data,
'IBsort': form.ibsort.data,
'IBshow': form.ibshow.data,
'isdelete': isdelete
}
banner_dict = {
k: v
for k, v in banner_dict.items() if v is not None
}
banner = IndexBanner.query.filter_by_(
IBid=ibid).update(banner_dict)
if not banner:
raise SystemError('服务器繁忙 10000')
return Success('修改成功', {'ibid': ibid})
def pay(self):
"""购买"""
data = parameter_required()
tiid, tsoid, numbers = data.get('tiid'), data.get('tsoid'), data.get('num')
user = User.query.filter(User.isdelete == false(), User.USid == getattr(request, 'user').id).first_('请重新登录')
opayno = super(CTicket, self)._opayno()
instance_list, tscode_list = [], []
with db.auto_commit():
if tiid and numbers: # 抢票
ticket, mount_price, instance_list, tscode_list = self._grap_ticket_order(tiid, numbers, user, opayno,
instance_list, tscode_list)
elif tsoid: # 中奖后补押金
ticket, mount_price, instance_list, tscode_list = self._patch_ticket_order(tsoid, user, opayno,
instance_list, tscode_list)
else:
raise ParamsError
db.session.add_all(instance_list)
body = ticket.TIname[:16] + '...'
openid = user.USopenid1
pay_args = super(CTicket, self)._add_pay_detail(opayno=opayno, body=body, PPpayMount=mount_price, openid=openid,
PPcontent=ticket.TIid,
PPpayType=PlayPayType.ticket.value)
response = {
'pay_type': PayType.wechat_pay.name,
'opaytype': PayType.wechat_pay.value,
'tscode': tscode_list,
'args': pay_args
}
current_app.logger.info('response = {}'.format(response))
return Success(data=response)
def update(self):
"""更新分类"""
data = parameter_required(('pcid', 'pcdesc', 'pcname', 'pcpic'))
pcdesc = data.get('pcdesc')
pcname = data.get('pcname')
pcpic = data.get('pcpic')
parentpcid = data.get('parentpcid')
# pcsort = self._check_sort(data.get('pcid'), data.get('pcsort', 1))
pcsort = int(data.get('pcsort', 1))
pctoppic = data.get('pctoppic')
with db.auto_commit():
current_category = ProductCategory.query.filter(
ProductCategory.isdelete == False,
ProductCategory.PCid == data.get('pcid')).first_('分类不存在')
pcsort = self._check_sort(current_category.PCtype, pcsort,
parentpcid)
if parentpcid:
parent_cat = ProductCategory.query.filter(
ProductCategory.isdelete == False,
ProductCategory.PCid == parentpcid).first_('指定上级目录不存在')
current_category.PCtype = parent_cat.PCtype + 1
else:
current_category.PCtype = 1
current_category.update(
{
'PCname': pcname,
'PCdesc': pcdesc,
'ParentPCid': parentpcid,
'PCsort': pcsort,
'PCpic': pcpic,
'PCtopPic': pctoppic
},
null='not ignore')
db.session.add(current_category)
return Success('更新成功')
def get(self):
commision = Commision.query.filter(
Commision.isdelete == False, ).first()
commision.Levelcommision = json.loads(commision.Levelcommision)
commision.ReduceRatio = json.loads(commision.ReduceRatio)
commision.IncreaseRatio = json.loads(commision.IncreaseRatio)
return Success(data=commision)
def delete(self):
data = parameter_required(('pcid', ))
pcid = data.get('pcid')
with self.sproduct.auto_commit() as s:
product_category_instance = s.query(ProductCategory).filter_by_({
'PCid':
pcid
}).first_('该分类不存在')
product_category_instance.isdelete = True
s.add(product_category_instance)
BASEADMIN().create_action(AdminActionS.delete.value,
'ProductCategory', pcid)
s.query(Products).filter_(
Products.PCid == product_category_instance.PCid).update(
{
'PRstatus': ProductStatus.off_shelves.value,
'PCid': None
},
synchronize_session=False)
# else:
# parent_catetgory_instance = s.query(ProductCategory).filter_by_({'PCid': parent_catetgory_id}).first_()
# if not parent_catetgory_instance: # 父级目录已删除
# s.query(Products).filter_(Products.PCid.in_(sub_ids)).update({
# 'PCid': 'null'
# }, synchronize_session=False)
# else:
# pass
# s.query(Products).filter_by_({
# 'PCid': pcid
# }).update({
# 'PCid': parent_catetgory_id
# }, synchronize_session=False)
return Success('删除成功')
def offshelves(self):
current_app.logger.info('下架供应商')
data = parameter_required(('suid', ))
suid = data.get('suid')
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == suid).first_('供应商不存在')
supplizer.SUstatus = UserStatus.forbidden.value
db.session.add(supplizer)
BASEADMIN().create_action(AdminActionS.update.value, 'Supplizer',
suid)
# 供应商的品牌也下架
brand_count = ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.PBstatus == ProductBrandStatus.upper.value,
ProductBrand.SUid == suid).update(
{'PBstatus': ProductBrandStatus.off_shelves.value})
current_app.logger.info('共下架了 {}个品牌'.format(brand_count))
# 供应商的商品下架
products_count = Products.query.filter(
Products.isdelete == False,
Products.PRstatus != ProductStatus.off_shelves.value,
Products.CreaterId == suid).update({
'PRstatus':
ProductStatus.off_shelves.value,
})
current_app.logger.info('共下架了 {}个商品'.format(products_count))
return Success('供应商下架成功')
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 set_supplizeraccount(self):
if not is_supplizer():
raise AuthorityError
from flask import request
from planet.control.CUser import CUser
data = request.json
cuser = CUser()
cardno = data.get('sacardno')
cardno = re.sub(r'\s', '', str(cardno))
cuser._CUser__check_card_num(cardno)
check_res = cuser._verify_cardnum(cardno) # 检验卡号
if not check_res.data.get('validated'):
raise ParamsError('请输入正确的银行卡号')
checked_res = cuser._verify_cardnum(data.get('sabankaccount'))
# if not checked_res.data.get('validated'):
# raise ParamsError('请输入正确的开票账户银行卡号')
checked_name = cuser._verify_chinese(data.get('sacardname'))
if not checked_name or len(checked_name[0]) < 2:
raise ParamsError('请输入正确的开户人姓名')
current_app.logger.info('用户输入银行名为:{}'.format(data.get('sabankname')))
bankname = check_res.data.get('cnbankname')
try:
WexinBankCode(bankname)
except Exception:
raise ParamsError('系统暂不支持该银行提现，请更换银行后重新保存')
data['sabankname'] = bankname
current_app.logger.info('校验后更改银行名为:{}'.format(data.get('sabankname')))
sa = SupplizerAccount.query.filter(
SupplizerAccount.SUid == request.user.id,
SupplizerAccount.isdelete == False).first()
if sa:
for key in sa.__dict__:
if str(key).lower() in data:
if re.match(r'^(said|suid)$', str(key).lower()):
continue
if str(key).lower() == 'sacardno':
setattr(sa, key, cardno)
continue
setattr(sa, key, data.get(str(key).lower()))
else:
sa_dict = {}
for key in SupplizerAccount.__dict__:
if str(key).lower() in data:
if not data.get(str(key).lower()):
continue
if str(key).lower() == 'suid':
continue
if str(key).lower() == 'sacardno':
sa_dict.setdefault(key, cardno)
continue
sa_dict.setdefault(key, data.get(str(key).lower()))
sa_dict.setdefault('SAid', str(uuid.uuid1()))
sa_dict.setdefault('SUid', request.user.id)
sa = SupplizerAccount.create(sa_dict)
db.session.add(sa)
return Success('设置供应商账户信息成功')
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 create_apply(self):
"""提交购买申请"""
data = parameter_required(
('acabankname', 'acabanksn', 'acaname', 'vouchers'))
acabankname = data.get('acabankname')
acabanksn = data.get('acabanksn')
if len(acabanksn) < 10 or len(acabanksn) > 30:
raise ParamsError('卡号错误')
if re.findall('\D', acabanksn):
raise ParamsError('卡号错误')
acaname = data.get('acaname')
vouchers = data.get('vouchers')
if not vouchers or (not isinstance(vouchers,
list)) or (len(vouchers) > 4):
raise ParamsError('凭证有误')
with db.auto_commit():
apply = ActivationCodeApply.create({
'ACAid': str(uuid.uuid1()),
'USid': request.user.id,
'ACAname': acaname,
'ACAbankSn': acabanksn,
'ACAbankname': acabankname,
'ACAvouchers': vouchers
})
db.session.add(apply)
self.create_approval('toactivationcode', request.user.id, apply.ACAid)
return Success('提交成功')
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 fresh(self):
usid = request.user.id
if request.user.model == 'User':
user = User.query.filter(User.USid == usid,
User.isdelete == False).first_('用户已删除')
jwt = usid_to_token(usid,
model='User',
level=user.USlevel,
username=user.USname)
elif request.user.model == 'Admin':
admin = Admin.query.filter(Admin.ADid == request.user.id,
Admin.isdelete == False,
Admin.ADstatus == 0).first_('管理员状态有误')
jwt = usid_to_token(usid,
model='Admin',
level=admin.ADlevel,
username=admin.ADname)
else:
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False, Supplizer.SUid == request.user.id,
Supplizer.SUstatus == 0).first_('供应商状态有误')
jwt = usid_to_token(usid,
model='Supplizer',
username=supplizer.SUname)
return Success(data=jwt)
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})
