def deal_single_approval(self, data, admin=None, sup=None):
parameter_required(('avid', 'anaction', 'anabo'), datafrom=data)
approval_model = Approval.query.filter_by_(
AVid=data.get('avid'),
AVstatus=ApplyStatus.wait_check.value).first_('审批已处理')
if is_admin():
Permission.query.filter(
Permission.isdelete == False,
AdminPermission.isdelete == False,
Permission.PIid == AdminPermission.PIid,
AdminPermission.ADid == request.user.id,
Permission.PTid == approval_model.PTid,
Permission.PELevel == approval_model.AVlevel).first_('权限不足')
avadname = admin.ADname
adid = admin.ADid
else:
avadname = sup.SUname
adid = sup.SUid
# 审批流水记录
approvalnote_dict = {
"ANid": str(uuid.uuid1()),
"AVid": data.get("avid"),
"AVadname": avadname,
"ADid": adid,
"ANaction": data.get('anaction'),
"ANabo": data.get("anabo")
}
apn_instance = ApprovalNotes.create(approvalnote_dict)
db.session.add(apn_instance)
if is_admin():
BaseAdmin().create_action(AdminActionS.insert.value,
'ApprovalNotes', str(uuid.uuid1()))
if int(data.get("anaction")) == ApprovalAction.agree.value:
# 审批操作是否为同意
pm_model = Permission.query.filter(
Permission.isdelete == False,
Permission.PTid == approval_model.PTid,
Permission.PELevel == int(approval_model.AVlevel) + 1).first()
if pm_model:
# 如果还有下一级审批人
approval_model.AVlevel = str(int(approval_model.AVlevel) + 1)
else:
# 没有下一级审批人了
approval_model.AVstatus = ApplyStatus.agree.value
self.agree_action(approval_model, data)
else:
# 审批操作为拒绝
approval_model.AVstatus = ApplyStatus.reject.value
self.refuse_action(approval_model, data.get('anabo'))
def get_linkcontent(self):
data = parameter_required('lcid')
lcid = data.get('lcid')
lc = LinkContent.query.filter_by(LCid=lcid, isdelete=False).first()
if not lc:
raise ParamsError('链接失效')
return Success(data=lc)
def set_mp_banner(self):
"""小程序轮播图"""
data = parameter_required(('mpbpicture', ))
mpbid = data.get('mpbid')
mpb_dict = {
'MPBpicture': data.get('mpbpicture'),
'MPBsort': data.get('mpbsort'),
'MPBshow': data.get('mpbshow'),
'contentlink': data.get('contentlink')
}
with db.auto_commit():
if not mpbid:
mpb_dict['MPBid'] = str(uuid.uuid1())
mpb_dict['ADid'] = getattr(request, 'user').id
mpb_instance = MiniProgramBanner.create(mpb_dict)
# BASEADMIN().create_action(AdminActionS.insert.value, 'MiniProgramBanner', mpb_instance.MPBid)
msg = '添加成功'
else:
mpb_instance = MiniProgramBanner.query.filter_by_(
MPBid=mpbid).first_('未找到该轮播图信息')
if data.get('delete'):
mpb_instance.update({'isdelete': True})
# BASEADMIN().create_action(AdminActionS.delete.value, 'MiniProgramBanner', mpb_instance.MPBid)
msg = '删除成功'
else:
mpb_instance.update(mpb_dict, null='not')
# BASEADMIN().create_action(AdminActionS.update.value, 'MiniProgramBanner', mpb_instance.MPBid)
msg = '编辑成功'
db.session.add(mpb_instance)
return Success(message=msg, data={'mpbid': mpb_instance.MPBid})
def get_location(self):
"""获取定位"""
# user = get_current_user()
usid = getattr(request, 'user').id
data = parameter_required(('longitude', 'latitude'))
current_location = self.get_user_location(data.get('latitude'),
data.get('longitude'), usid)
return Success(data={'nelocation': current_location})
def list_activationtype(self):
data = parameter_required()
filter_args = {
ActivationType.isdelete == false()
}
# if data.get('atttype'):
# filter_args.add(ActivationType.ATTtype == data.get('atttype'))
att_list = ActivationType.query.filter(*filter_args).order_by(ActivationType.updatetime.desc()).all_with_page()
return Success(data=att_list)
def get_approvalnotes(self):
"""查看审批的所有流程"""
if not (is_admin() or is_supplizer()):
raise AuthorityError('权限不足')
data = parameter_required(('avid', ))
an_list = ApprovalNotes.query.filter_by_(
AVid=data.get('avid')).order_by(ApprovalNotes.createtime).all()
for an in an_list:
an.fill('anaction', ApprovalAction(an.ANaction).zh_value)
return Success('获取审批记录成功', data=an_list)
def update_role(self):
data = parameter_required('amtype')
# amtype = int(data.get('amtype', 0) or 0)
with db.auto_commit():
amtype = self._check_roletype(data.get('amtype', 0))
role = Agreement.query.filter_by(AMtype=amtype,
isdelete=False).first()
if not role:
raise ParamsError('规则失效')
role.AMcontent = data.get('amcontent')
return Success('更新成功')
def get(self):
data = parameter_required('omid')
omid = data.get('omid')
filter_args = [OrderMain.OMid == omid, OrderMain.isdelete == false()]
if is_user():
filter_args.append(OrderMain.USid == getattr(request, 'user').id)
om = OrderMain.query.filter(*filter_args).first_('订单不存在')
user = User.query.filter(User.isdelete == false(), User.USid == om.USid).first_('订单信息错误')
self._fill_ordermain(om)
om.fill('usname', user.USname)
om.fill('usheader', user['USheader'])
return Success(data=om)
def agree_shelves(self, approval_model, data):
parameter_required({
'prlineprice': '划线价格',
'prtrueprice': '实际价格'
},
datafrom=data)
product = Product.query.filter_by_(
PRid=approval_model.AVcontent,
PRstatus=ProductStatus.pending.value).first_('商品已处理')
prlineprice = validate_price(data.get('prlineprice'), can_zero=False)
prtrueprice = validate_price(
data.get('prtrueprice'),
can_zero=True if product.PRtimeLimeted else False)
current_app.logger.info(f'划线价, 实际价 = {prlineprice}, {prtrueprice}')
from datetime import datetime
now = datetime.now()
if product.PRtimeLimeted:
if product.PRissueStartTime > now: # 同意时未到发放开始时间
product.PRstatus = ProductStatus.ready.value # 状态为 未开始
add_async_task(func=start_product,
start_time=product.PRissueStartTime,
func_args=(product.PRid, ),
conn_id='start_product{}'.format(product.PRid))
add_async_task(func=end_product,
start_time=product.PRissueEndTime,
func_args=(product.PRid, ),
conn_id='end_product{}'.format(product.PRid))
elif product.PRissueStartTime <= now < product.PRissueEndTime: # 已到开始发放时间 未到 结束时间
product.PRstatus = ProductStatus.active.value # 状态为 活动中
add_async_task(func=end_product,
start_time=product.PRissueEndTime,
func_args=(product.PRid, ),
conn_id='end_product{}'.format(product.PRid))
else:
raise ParamsError('当前时间已超出商品发放时间范围，请联系供应商重新提交申请')
else:
product.PRstatus = ProductStatus.active.value
product.PRlinePrice = prlineprice
product.PRtruePrice = prtrueprice
def get_product(self):
"""商品详情"""
args = parameter_required(('prid',))
prid = args.get('prid')
secret_usid = args.get('secret_usid')
if secret_usid: # 创建邀请记录
self._invitation_record(secret_usid, args)
product = Product.query.filter(Product.isdelete == false(), Product.PRid == prid).first_('商品已下架')
self._fill_product(product)
month_sale_value = self._fill_month_sale_value(prid)
product.fill('month_sale_value', month_sale_value)
return Success(data=product)
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)
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', suid)
return Success('供应商下架成功')
def remove(self):
data = parameter_required(('img_url',))
try:
img_url = data.get('img_url')
dirs = img_url.split('/')[-6:]
name_shuffer = dirs[-1]
name = name_shuffer.split('.')[0]
if not 'anonymous' in name and request.user.id not in name:
raise NotFound()
path = os.path.join(current_app.config['BASEDIR'], '/'.join(dirs))
os.remove(path)
except Exception as e:
raise NotFound()
return Success(u'删除成功')
def get_duration_activation(self):
data = parameter_required('tistarttime', 'tiendtime')
if is_admin():
usid = data.get('usid')
elif is_user():
usid = getattr(request, 'user').id
else:
raise AuthorityError('请登录')
start = self._trans_time(data.get('tistarttime'))
end = self._trans_time(data.get('tiendtime'))
at_list = Activation.query.filter(
Activation.USid == usid, Activation.createtime >= start, Activation.createtime <= end).all_with_page()
for at in at_list:
self._fill_at(at)
return Success(data=at_list)
def cancle(self):
"""付款前取消订单"""
data = parameter_required(('omid',))
omid = data.get('omid')
if not is_user():
raise AuthorityError
usid = getattr(request, 'user').id
order_main = OrderMain.query.filter(
OrderMain.OMid == omid, OrderMain.USid == usid, OrderMain.isdelete == false()).first_('指定订单不存在')
# if is_supplizer() and order_main.PRcreateId != usid:
# raise AuthorityError()
# if not is_admin() and order_main.USid != usid:
# raise NotFound('订单订单不存在')
self._cancle(order_main)
return Success('取消成功')
def product_verified(self):
"""商品核销"""
data = parameter_required('param')
param = data.get('param')
try:
omid, secret_usid = str(param).split('&')
if not omid.startswith('omid'):
raise ValueError
except ValueError:
raise ParamsError('该二维码无效')
current_app.logger.info('omid: {}, secret_usid: {}'.format(omid, secret_usid))
omid = str(omid).split('=')[-1]
secret_usid = str(secret_usid).split('=')[-1]
current_app.logger.info('splited, omid: {}, secret_usid: {}'.format(omid, secret_usid))
if not omid or not secret_usid:
raise StatusError('该试用码无效')
ticket_usid = self.cuser._base_decode(secret_usid)
ticket_user = User.query.filter(User.isdelete == false(),
User.USid == ticket_usid).first_('无效试用码')
om = OrderMain.query.filter(OrderMain.isdelete == false(),
OrderMain.OMid == omid).first_('订单状态异常')
if om.OMstatus != OrderStatus.has_won.value:
current_app.logger.error('om status: {}'.format(om.TSOstatus))
raise StatusError('提示：该二维码已被核销过')
pr = Product.query.filter(Product.PRid == om.PRid).first()
if pr.PRtimeLimeted and (pr.PRuseStartTime <= datetime.now() <= pr.PRuseEndTime):
raise StatusError('当前时间不在该券有效使用时间内')
user = User.query.join(ProductVerifier, ProductVerifier.PVphone == User.UStelephone
).join(Product, Product.SUid == ProductVerifier.SUid
).filter(User.isdelete == false(), User.USid == getattr(request, 'user').id,
ProductVerifier.SUid == pr.SUid
).first_('请确认您是否拥有该券的核销权限')
with db.auto_commit():
# 订单改状态
om.update({'OMstatus': OrderStatus.completed.value})
db.session.add(om)
# 核销记录
tvr = ProductVerifiedRecord.create({'PVRid': str(uuid.uuid1()),
'ownerId': ticket_user.USid,
'VerifierId': user.USid,
'OMid': om.OMid,
'param': param})
db.session.add(tvr)
return Success('二维码验证成功', data=tvr.PVRid)
def get_promotion(self):
data = parameter_required('prid')
user = User.query.filter(User.isdelete == false(), User.USid == getattr(request, 'user').id).first_('请重新登录')
prid = data.get('prid')
params = data.get('params')
product = Product.query.filter(
Product.PRid == prid, Product.PRstatus < ProductStatus.interrupt.value,
Product.isdelete == false()).first_('活动已结束')
usid = user.USid
starttime = endtime = starttime_g = endtime_g = None
if product.PRtimeLimeted:
starttime = self._check_time(product.PRuseStartTime)
endtime = self._check_time(product.PRuseEndTime, fmt='%m/%d')
starttime_g = self._check_time(product.PRissueStartTime)
endtime_g = self._check_time(product.PRissueEndTime, fmt='%m/%d')
# 获取微信二维码
from ..control.CUser import CUser
cuser = CUser()
if not params or 'page=' not in params:
params = 'page=/pages/index/freeDetail'
if 'prid' not in params:
params = '{}&prid={}'.format(params, prid)
if 'secret_usid' not in params:
params = '{}&secret_usid={}'.format(params, cuser._base_encode(usid))
params = '{}&sttype={}'.format(params, ShareType.promotion.value)
params_key = cuser.shorten_parameters(params, usid, 'params')
wxacode_path = cuser.wxacode_unlimit(
usid, {'params': params_key}, img_name='{}{}'.format(usid, prid), is_hyaline=True)
local_path, promotion_path = PlayPicture().create_ticket(
product.PRimg, product.PRname, str(0), usid, prid, wxacode_path, product.PRlinePrice,
product.PRtruePrice, starttime, endtime, starttime_g, endtime_g)
CFile().upload_to_oss(local_path, promotion_path[1:], '商品推广图')
scene = cuser.dict_to_query_str({'params': params_key})
current_app.logger.info('get scene = {}'.format(scene))
return Success(data={
'promotion_path': promotion_path,
'scene': scene
})
def update_activationtype(self):
data = parameter_required('attid')
attid = data.pop('attid')
with db.auto_commit():
att = ActivationType.query.filter_by(ATTid=attid, isdelete=False).first_('活跃度获取方式未被记录')
admin = Admin.query.filter(
Admin.ADid == getattr(request, 'user').id, Admin.isdelete == false()).first_('用户信息有误')
update_dict = {
'ADid': admin.ADid
}
for key in att.keys():
lower_key = str(key).lower()
value = data.get(lower_key)
if value or value == 0:
if key != 'ATTname' and not str(value).isdigit():
raise ParamsError('{} 只能是自然数'.format(getattr(ActivationType, key).comment))
update_dict.setdefault(key, value)
att.update(update_dict)
db.session.add(att)
return Success('修改成功', data=attid)
def upload_img(self):
if is_anonymous():
current_app.logger.info(">>> Tourist Uploading Files <<<")
else:
current_app.logger.info(">>> {} Uploading Files <<<".format(request.user.model))
self.check_file_size()
file = request.files.get('file')
data = parameter_required()
if not data:
data = request.form
current_app.logger.info('form : {}'.format(data))
current_app.logger.info('type is {}'.format(data.get('type')))
folder = self.allowed_folder(data.get('type'))
if not file:
raise ParamsError(u'上传有误')
file_data, video_thum, video_dur, upload_type = self._upload_file(file, folder)
# return Success('上传成功', data={'url': file_data, 'video_thum': video_thum, 'video_dur': video_dur,
# 'upload_type': upload_type})
return Success('上传成功', data=file_data).get_body(video_thum=video_thum, video_dur=video_dur,
upload_type=upload_type)
def list_trade(self):
"""门票购买记录"""
# if not is_admin():
# raise StatusError('用户无权限')
args = parameter_required('prid')
prid = args.get('prid')
product = Product.query.filter(Product.isdelete == false(), Product.PRid == prid).first_('无信息')
tos = OrderMain.query.filter(
OrderMain.isdelete == false(), OrderMain.PRid == prid).order_by(
OrderMain.OMintegralpayed.desc(), OrderMain.OMstatus.desc(), OrderMain.createtime.desc()).all_with_page()
res = []
for to in tos:
usinfo = db.session.query(User.USname, User.USheader
).filter(User.isdelete == false(), User.USid == to.USid).first()
if not usinfo:
continue
res.append({'usname': usinfo[0],
'usheader': usinfo[1],
'omid': to.OMid,
'createtime': to.createtime,
'omstatus': to.OMstatus,
'omintegralpayed': to.OMintegralpayed,
'omstatus_zh': OrderStatus(to.OMstatus).zh_value
})
trade_num, award_num = map(lambda x: db.session.query(
func.count(OrderMain.OMid)).filter(
OrderMain.isdelete == false(),
OrderMain.PRid == prid,
OrderMain.OMstatus == x, ).scalar() or 0, (
OrderStatus.completed.value, OrderStatus.has_won.value))
ticket_info = {'prid': product.PRid,
'prname': product.PRname,
'time': '{} - {}'.format(product.PRissueStartTime, product.PRissueEndTime),
'prstatus': product.PRstatus,
'prstatus_zh': ProductStatus(product.PRstatus).zh_value,
'trade_num': '{} / {}'.format(trade_num, product.PRnum),
'award_num': '{} / {}'.format(award_num, product.PRnum)}
return Success(data={'product': ticket_info,
'ordermain': res})
def batch_upload(self):
if is_anonymous():
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张图片')
data = parameter_required()
folder = self.allowed_folder(data.get('type'))
file_url_list = []
for file in files.values():
file_data, video_thum, video_dur, upload_type = self._upload_file(file, folder)
file_dict = {
'url': file_data,
'video_thum': video_thum,
'video_dur': video_dur,
'upload_type': upload_type
}
file_url_list.append(file_dict)
return Success('上传成功', file_url_list)
def get_params(self):
data = parameter_required()
params_value = data.get('value')
key = data.get('key')
params = self.user.get_origin_parameters(params_value, key)
return Success(data=params)
def pay(self):
"""购买"""
data = parameter_required()
prid, ompaytype = data.get('prid'), data.get('ompaytype')
try:
ompaytype = PayType(int(ompaytype)).value
except (ValueError, AttributeError, TypeError):
raise ParamsError('支付方式错误')
# if not is_user():
# raise AuthorityError
user = self._current_user('请重新登录')
opayno = self._opayno()
now = datetime.now()
product = Product.query.filter(Product.PRid == prid, Product.PRstatus == ProductStatus.active.value,
Product.isdelete == false()).first_('商品已下架')
if product.PRtimeLimeted:
starttime = self._check_time(product.PRissueStartTime)
endtime = self._check_time(product.PRissueEndTime)
if starttime and now < starttime:
raise StatusError('商品未到发放时间')
if endtime and now > endtime:
raise StatusError('商品已过发放时间')
trade = self._query_traded(prid, user.USid) # 直购不限制
redirect = False
omid = str(uuid.uuid1())
with db.auto_commit():
if ompaytype == PayType.cash.value:
# 直购
mount_price = Decimal(product.PRtruePrice)
if mount_price == Decimal('0'):
redirect = True
trade = False
elif ompaytype == PayType.scorepay.value:
# 活跃分
# if not user.USrealname: # 暂时除去实名验证
# raise StatusError('用户未进行信用认证')
if not product.PRtimeLimeted:
raise StatusError('活跃分支持限时商品')
mount_price = 0
redirect = True
else:
raise StatusError('支付方式错误')
if trade:
raise StatusError('您已申请成功，请在“我的 - 我的试用”中查看')
omdict = {
"OMid": omid,
"OMno": self._generic_omno(),
"OPayno": opayno,
"USid": user.USid,
"PRid": prid,
"OMmount": product.PRlinePrice,
"OMtrueMount": mount_price,
"OMpayType": ompaytype,
"PRcreateId": product.CreatorId,
"PRname": product.PRname,
"PRimg": product.PRimg,
"OPnum": 1, # 目前没有添加数量
}
if ompaytype == PayType.cash.value:
user_subcommision = UserSubCommission.query.filter(UserSubCommission.USid == user.USid,
UserSubCommission.isdelete == 0)\
.first()
user_super_level = user_subcommision.USCsuperlevel
if user_super_level == 3:
pass
elif user_super_level == 2:
omdict.setdefault('UPperid3', user_subcommision.USCsupper3)
elif user_super_level == 1:
omdict.setdefault('UPperid2', user_subcommision.USCsupper2)
omdict.setdefault('UPperid3', user_subcommision.USCsupper3)
else:
omdict.setdefault('UPperid', user_subcommision.USCsupper1)
omdict.setdefault('UPperid2', user_subcommision.USCsupper2)
omdict.setdefault('UPperid3', user_subcommision.USCsupper3)
if data.get('shareid'):
omdict.setdefault('UPshareid', data.get('shareid'))
# 极差分佣暂时不需要
# omdict.setdefault('USCommission1', user.USCommission1)
# omdict.setdefault('USCommission2', user.USCommission2)
# omdict.setdefault('USCommission3', user.USCommission3)
om = OrderMain.create(omdict)
# product.PRnum -= 1 # 商品库存修改 # 0618 fix 非商品逻辑，不能改库存数
# 月销量 修改或新增
today = datetime.now()
month_sale_instance = ProductMonthSaleValue.query.filter(
ProductMonthSaleValue.isdelete == false(),
ProductMonthSaleValue.PRid == product.PRid,
extract('month', ProductMonthSaleValue.createtime) == today.month,
extract('year', ProductMonthSaleValue.createtime) == today.year,
).first()
if not month_sale_instance:
month_sale_instance = ProductMonthSaleValue.create({'PMSVid': str(uuid.uuid1()),
'PRid': prid,
'PMSVnum': 1,
'PMSVfakenum': 1
})
else:
month_sale_instance.update({'PMSVnum': ProductMonthSaleValue.PMSVnum + 1,
'PMSVfakenum': ProductMonthSaleValue.PMSVfakenum + 1})
db.session.add(month_sale_instance)
db.session.add(product)
db.session.add(om)
body = product.PRname[:16] + '...'
openid = user.USopenid1
# 直购订单 不付款 5秒后 自动取消
if not product.PRtimeLimeted:
# add_async_task(auto_cancle_order, now + timedelta(minutes=1), (omid,), conn_id='autocancle{}'.format(omid))
auto_cancle_order.apply_async(args=(omid,), countdown=5, expires=10, queue='high_priority')
pay_args = self._add_pay_detail(opayno=opayno, body=body, mount_price=mount_price, openid=openid,
opayType=ompaytype, redirect=redirect)
response = {
'pay_type': 'wechat_pay',
'opaytype': ompaytype,
# 'tscode': tscode_list,
'args': pay_args,
'redirect': redirect
}
current_app.logger.info('response = {}'.format(response))
return Success(data=response)
def list(self):
data = parameter_required()
omstatus = data.get('omstatus')
filter_args = [OrderMain.isdelete == false()]
order_by_list = [OrderMain.updatetime.desc(), OrderMain.createtime.desc()]
if is_user():
user = self._current_user('请重新登录')
try:
omstatus = OrderStatus(int(str(omstatus))).value
except ValueError:
current_app.logger.error('omstatus error')
omstatus = OrderStatus.pending.value
filter_args.append(OrderMain.USid == user.USid)
filter_args.append(OrderMain.OMstatus == omstatus)
else:
if omstatus:
try:
omstatus = OrderStatus(int(str(omstatus))).value
except:
omstatus = OrderStatus.pending.value
filter_args.append(OrderMain.OMstatus == omstatus)
omno = data.get('omno')
prname = data.get('prname')
ompaytype = data.get('ompaytype', PayType.cash.value)
try:
ompaytype = PayType(int(str(ompaytype))).value
except:
ompaytype = PayType.cash.value
filter_args.append(OrderMain.OMpayType == ompaytype)
createtime_start = self._check_date(data.get('createtime_start'))
createtime_end = self._check_date(data.get('createtime_end'))
if createtime_start:
filter_args.append(cast(OrderMain.createtime, Date) >= createtime_start)
if createtime_end:
filter_args.append(cast(OrderMain.createtime, Date) <= createtime_end)
if omno:
filter_args.append(OrderMain.OMno.ilike('%{}%'.format(omno)))
if prname:
filter_args.append(OrderMain.PRname.ilike('%{}%'.format(prname)))
if is_supplizer():
filter_args.append(OrderMain.PRcreateId == getattr(request, 'user').id)
omlist = OrderMain.query.filter(*filter_args).order_by(*order_by_list).all_with_page()
now = datetime.now()
user_list = db.session.query(User.USid, User.USname, User.USheader).filter(
User.isdelete == false(), OrderMain.USid == User.USid, *filter_args).all()
user_dict = {user_info[0]: user_info for user_info in user_list}
for om in omlist:
self._fill_ordermain(om)
if om.OMstatus == OrderStatus.wait_pay.value:
duration = om.createtime + timedelta(minutes=30) - now
om.fill('duration', str(duration))
# todo 填充商品信息
# 填充用户信息
user_info = user_dict.get(om.USid)
# current_app.logger.info('get user info {}'.format(user_info))
# current_app.logger.info('get user id {}'.format(om.USid))
# current_app.logger.info('get om id {}'.format(om.OMid))
om.fill('usname', user_info[1])
om.fill('USheader', user_info[2])
return Success(data=omlist)
def update(self):
"""平台分销佣金设置"""
# form = CommsionUpdateForm().valid_data()
data = parameter_required()
levelcommision = data.get('levelcommision')
invitenum = data.get('invitenum', 0)
groupsale = data.get('groupsale', 0)
pesonalsale = data.get('pesonalsale', 0)
invitenumscale = data.get('invitenumscale', 0)
groupsalescale = data.get('groupsalescale', 0)
pesonalsalescale = data.get('pesonalsalescale', 0)
reduceratio = data.get('reduceratio')
increaseratio = data.get('increaseratio')
deviderate = data.get('deviderate')
if not levelcommision or len(levelcommision) != 5:
raise ParamsError('请设置五级佣金比')
for comm in levelcommision:
if comm <= 0 or comm > 100:
raise ParamsError('佣金比不合适 需小于100, 大于0')
# todo 其他参数校验，目前用不到，忽略校验
leveluptwo = data.get('leveluptwo', 10)
levelupthree = data.get('levelupthree', 10)
leveldowntwo = data.get('leveldowntwo', 10)
leveldownone = data.get('leveldownone', 10)
leveldownzero = data.get('leveldownzero', 1)
leveldowntworep = data.get('leveldowntworep', 10)
leveldownonerep = data.get('leveldownonerep', 10)
leveldownzerorep = data.get('leveldownzerorep', 2)
leveluptworeward = data.get('leveluptworeward', 5)
levelupthreereward = data.get('levelupthreereward', 100)
checktime = data.get('checktime', 7)
with db.auto_commit():
commision = Commision.query.filter(
Commision.isdelete == False).first()
if not commision:
commision = Commision()
from tickets import JSONEncoder
commission_dict = {
'Levelcommision': json.dumps(levelcommision, cls=JSONEncoder),
'InviteNum': invitenum,
'GroupSale': groupsale,
'PesonalSale': pesonalsale,
'InviteNumScale': invitenumscale,
'GroupSaleScale': groupsalescale,
'PesonalSaleScale': pesonalsalescale,
'ReduceRatio': json.dumps(reduceratio, cls=JSONEncoder),
'IncreaseRatio': json.dumps(increaseratio, cls=JSONEncoder),
'DevideRate': deviderate,
'LevelUpTwo': leveluptwo,
'LevelUpThree': levelupthree,
'LevelDownTwo': leveldowntwo,
'LevelDownOne': leveldownone,
'LevelDownZero': leveldownzero,
'LevelDownTwoRep': leveldowntworep,
'LevelDownOneRep': leveldownonerep,
'LevelDownZeroRep': leveldownzerorep,
'LevelUpTwoReward': leveluptworeward,
'LevelUpThreeReward': levelupthreereward,
'CheckTime': checktime
}
[
setattr(commision, k, v) for k, v in commission_dict.items()
if v is not None and v != '[]'
]
# if not commision.InviteNum and not commision.PesonalSale and not commision.GroupSale:
# raise ParamsError('升级条件不可全为0')
usercommision = levelcommision[:-2]
if sum(usercommision) > 100:
raise ParamsError('总佣金比大于100')
db.session.add(commision)
# BASEADMIN().create_action(AdminActionS.update.value, 'Commision', commision.COid)
return Success('修改成功')
def _validate_ticket_param(self, data):
valid_dict = {'prname': '商品名称', 'primg': '封面图', 'purchaseprice': '采购价',
'suid': '供应商', 'prtimelimeted': '是否为限时商品',
'prnum': '数量', 'prdetails': '详情', 'prbanner': '轮播图', 'address': '定位地点'
}
prtimelimeted = data.get('prtimelimeted') or 0
if prtimelimeted:
valid_dict.update({'prissuestarttime': '发放开始时间',
'prissueendtime': '发放结束时间',
'prusestarttime': '使用开始时间',
'pruseendtime': '使用结束时间'})
parameter_required(valid_dict, datafrom=data)
prissuestarttime = prissueendtime = prusestarttime = pruseendtime = None
if prtimelimeted:
prissuestarttime = validate_arg(r'^\d{4}(-\d{2}){2} \d{2}(:\d{2}){2}$', str(data.get('prissuestarttime')),
'发放开始时间错误')
prissueendtime = validate_arg(r'^\d{4}(-\d{2}){2} \d{2}(:\d{2}){2}$', str(data.get('prissueendtime')),
'发放结束时间错误')
prissuestarttime, prissueendtime = map(lambda x: datetime.strptime(x, '%Y-%m-%d %H:%M:%S'),
(prissuestarttime, prissueendtime))
now = datetime.now()
if prissuestarttime < now:
raise ParamsError('发放开始时间应大于现在时间')
if prissueendtime <= prissuestarttime:
raise ParamsError('发放结束时间应大于开始时间')
prusestarttime = validate_arg(r'^\d{4}(-\d{2}){2} \d{2}(:\d{2}){2}$', str(data.get('prusestarttime')),
'使用开始时间')
pruseendtime = validate_arg(r'^\d{4}(-\d{2}){2} \d{2}(:\d{2}){2}$', str(data.get('pruseendtime')),
'使用结束时间')
prusestarttime, pruseendtime = map(lambda x: datetime.strptime(x, '%Y-%m-%d %H:%M:%S'),
(prusestarttime, pruseendtime))
if prusestarttime < now:
raise ParamsError('使用开始时间应大于现在时间')
if prusestarttime < prissueendtime:
raise ParamsError('使用开始时间不能小于发放结束时间')
if pruseendtime <= prusestarttime:
raise ParamsError('使用结束时间应大于开始时间')
# prlineprice, prtrueprice = map(lambda x: validate_price(x, can_zero=False), # 0702 改为采购价
# (data.get('prlineprice'), data.get('prtrueprice')))
purchaseprice = validate_price(data.get('purchaseprice'), can_zero=False)
latitude, longitude = self.check_lat_and_long(data.get('latitude'), data.get('longitude'))
prnum = data.get('prnum') if prtimelimeted else 99999999
if not isinstance(prnum, int) or int(prnum) <= 0:
raise ParamsError('请输入合理的商品数量')
if not isinstance(data.get('prbanner'), list):
raise ParamsError('prbanner 格式错误')
prbanner = json.dumps(data.get('prbanner'))
sup = Supplizer.query.filter(Supplizer.isdelete == false(), Supplizer.SUid == data.get('suid'),
Supplizer.SUstatus == UserStatus.usual.value).first_('选择供应商异常')
product_dict = {'PRissueStartTime': prissuestarttime,
'PRissueEndTime': prissueendtime,
'PRuseStartTime': prusestarttime,
'PRuseEndTime': pruseendtime,
'PRtimeLimeted': prtimelimeted,
'PurchasePrice': purchaseprice,
# 'PRtruePrice': prtrueprice,
'PRnum': prnum,
'PRbanner': prbanner,
'SUid': sup.SUid,
'longitude': longitude,
'latitude': latitude,
'address': data.get('address')
}
return product_dict
def get_activationtype(self):
data = parameter_required('attid')
att = ActivationType.query.filter_by(ATTid=data.get('attid'), isdelete=False).first_('活跃度获取方式未被记录')
return Success(data=att)
def get_approval_list(self):
data = parameter_required(('ptid', ))
filter_starttime, filter_endtime = data.get(
'starttime', '2018-12-01'), data.get('endtime', '2100-01-01')
avstatus = data.get('avstatus', "")
current_app.logger.info('get avstatus {0} '.format(avstatus))
if avstatus and avstatus != 'all':
avstatus = getattr(ApplyStatus, data.get('avstatus'), None)
else:
avstatus = None
if is_admin():
admin = Admin.query.filter_by_(ADid=request.user.id).first_()
if not admin:
current_app.logger.info('get admin failed id is {0}'.format(
request.user.id))
raise NotFound("该管理员已被删除")
pt = PermissionType.query.filter_by_(PTid=data.get('ptid')).first()
# ptytype = ActivityType(int(data.get('pttype'))).name
ap_querry = Approval.query.filter(
Approval.PTid == pt.PTid,
Approval.AVlevel == Permission.PELevel,
Permission.PTid == Approval.PTid,
Permission.PIid == AdminPermission.PIid,
AdminPermission.ADid == admin.ADid,
Approval.isdelete == False,
Permission.isdelete == False,
AdminPermission.isdelete == False,
)
if avstatus is not None:
current_app.logger.info('sql avstatus = {0}'.format(
avstatus.value))
ap_querry = ap_querry.filter(
Approval.AVstatus == avstatus.value)
ap_list = ap_querry.order_by(
Approval.AVstatus.desc(),
Approval.createtime.desc()).all_with_page()
else:
try:
status = getattr(ApplyStatus, data.get('avstatus',
'wait_check'),
'wait_check').value
except Exception as e:
current_app.logger.error(
"sup approval list status error :{}".format(e))
status = None
pt = PermissionType.query.filter_by_(
PTid=data.get('ptid')).first_('审批类型不存在')
sup = Supplizer.query.filter_by_(
SUid=request.user.id).first_('供应商不存在')
ap_list = Approval.query.filter_by_(
AVstartid=sup.SUid).all_with_page()
res = []
for ap in ap_list:
if not ap.AVstartdetail:
continue
ap.hide('AVcontentdetail', 'AVstartdetail')
content = ap.AVcontentdetail or 'null'
content = json.loads(content)
if content.get('prid') and content.get('suname'):
pr_nums = db.session.query(func.count(Product.PRid)).filter(
Product.isdelete == false(),
Product.PRstatus.in_((ProductStatus.ready.value,
ProductStatus.active.value)),
Product.SUid == content.get('suid'),
).scalar() or 0 # 当前已上架的商品数
content[
'suname'] = f'{content.get("suname")} » 现有{pr_nums}件商品上架'
start = ap.AVstartdetail or 'null'
ap.fill('content', content)
ap.fill('start', json.loads(start))
ap.add('createtime')
ap.fill('avstatus_en', ApplyStatus(ap.AVstatus).name)
ap.fill('avstatus_zh', ApplyStatus(ap.AVstatus).zh_value)
res.append(ap)
return Success('获取待审批列表成功', data=res)
def update_product(self):
"""编辑商品"""
if is_admin():
product_from = ProductFrom.platform.value
elif is_supplizer():
product_from = ProductFrom.supplizer.value
else:
raise AuthorityError('当前用户无权进行该操作')
data = parameter_required('prid')
product = Product.query.filter(Product.isdelete == false(),
Product.PRid == data.get('prid')).first_('未找到该商品信息')
if Product.query.filter(Product.isdelete == false(), Product.PRname == data.get('prname'),
Product.PRid != Product.PRid, Product.PRstatus != ProductStatus.over.value).first():
raise ParamsError('该商品名已存在')
approval_flag = 0
with db.auto_commit():
if data.get('delete'):
if product.PRstatus == ProductStatus.active.value:
raise ParamsError('无法直接删除正在发放中的商品')
if OrderMain.query.filter(OrderMain.isdelete == false(),
OrderMain.OMstatus > OrderStatus.not_won.value,
OrderMain.PRid == product.PRid).first():
raise StatusError('暂时无法直接删除已产生购买记录的商品')
product.update({'isdelete': True})
# 取消异步任务
cancel_async_task('start_product{}'.format(product.PRid))
cancel_async_task('end_product{}'.format(product.PRid))
self.base_admin.create_action(AdminActionS.delete.value, 'Product', product.PRid)
# 同时将正在进行的审批流改为取消
self.base_approval.cancel_approval(product.PRid, request.user.id)
elif data.get('interrupt'):
if product.PRstatus > ProductStatus.active.value:
raise StatusError('该状态下无法中止')
product.update({'PRstatus': ProductStatus.interrupt.value})
cancel_async_task('start_product{}'.format(product.PRid))
cancel_async_task('end_product{}'.format(product.PRid))
self.base_admin.create_action(AdminActionS.update.value, 'Product', product.PRid)
# 同时将正在进行的审批流改为取消
self.base_approval.cancel_approval(product.PRid, request.user.id)
else:
approval_flag = 1
if product.PRstatus < ProductStatus.interrupt.value:
raise ParamsError('仅可编辑已中止发放或已结束的商品')
product_dict = self._validate_ticket_param(data)
product_dict.update({'PRname': data.get('prname'),
'PRimg': data.get('primg'),
'PRdetails': data.get('prdetails'),
# 'PRstatus': ProductStatus.ready.value if product_dict.get(
# 'PRtimeLimeted') else ProductStatus.active.value,
'PRstatus': ProductStatus.pending.value
})
self.base_approval.cancel_approval(product.PRid, request.user.id) # 同时将正在进行的审批流改为取消
if product.PRstatus == ProductStatus.interrupt.value: # 中止的情况
current_app.logger.info('edit interrupt ticket')
product.update(product_dict, null='not')
else: # 已结束的情况，重新发起
current_app.logger.info('edit ended ticket')
product_dict.update({'PRid': str(uuid.uuid1()),
'CreatorId': getattr(request, 'user').id,
'CreatorType': getattr(request, 'user').model})
product = Product.create(product_dict)
cancel_async_task('start_product{}'.format(product.PRid))
cancel_async_task('end_product{}'.format(product.PRid))
self.base_admin.create_action(AdminActionS.insert.value, 'Product', product.PRid)
db.session.add(product)
if approval_flag:
self.base_approval.create_approval('toshelves', request.user.id, product.PRid, product_from)
return Success('编辑成功', data={'prid': product.PRid})
