def _invitation_records():
secret_user_id = request.args.to_dict().get('secret_usid')
if not secret_user_id:
return
from tickets.extensions.interface.user_interface import is_user
if not is_user():
return
current_app.logger.info('>>>>>>>>record invitation<<<<<<<<')
try:
inviter_id = base_decode(secret_user_id)
current_app.logger.info(f'secret_usid --> inviter_id: {inviter_id}')
except Exception as e:
current_app.logger.error(f'解析secret_usid时出错： {e}')
return
usid = getattr(request, 'user').id
if inviter_id == usid:
current_app.logger.info('inviter == invitee')
return
from tickets.models.user import UserInvitation
from tickets.extensions.register_ext import db
import uuid
try:
with db.auto_commit():
uin = UserInvitation.create({
'UINid': str(uuid.uuid1()),
'USInviter': inviter_id,
'USInvited': usid,
'UINapi': request.path
})
current_app.logger.info(f'{request.path} 创建邀请记录')
db.session.add(uin)
except Exception as e:
current_app.logger.error(f'存储邀请记录时出错： {e}')
def set_linkcontent(self):
body = request.json
admin = Admin.query.filter(Admin.isdelete == false(),
Admin.ADid == getattr(request,
'user').id).first()
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 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 create_product(self):
"""创建商品"""
if is_admin():
product_from = ProductFrom.platform.value
elif is_supplizer():
product_from = ProductFrom.supplizer.value
else:
raise AuthorityError('当前用户无权进行该操作')
data = request.json
product_dict = self._validate_ticket_param(data)
if Product.query.filter(Product.isdelete == false(), Product.PRname == data.get('prname')).first():
raise ParamsError('该商品名称已存在')
with db.auto_commit():
product_dict.update({'PRid': str(uuid.uuid1()),
'CreatorId': getattr(request, 'user').id,
'CreatorType': getattr(request, 'user').model,
'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
})
product = Product.create(product_dict)
db.session.add(product)
# 0702 增加审批
# if product.PRtimeLimeted: # 限时商品，添加异步任务
# 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))
self.base_approval.create_approval('toshelves', request.user.id, product.PRid, product_from)
self.base_admin.create_action(AdminActionS.insert.value, 'Product', product.PRid)
return Success('创建成功', data={'prid': product.PRid})
def _invitation_record(self, secret_usid, args):
try:
superid = self.cuser._base_decode(secret_usid)
current_app.logger.info('secret_usid --> superid {}'.format(superid))
if is_user() and superid != getattr(request, 'user').id:
with db.auto_commit():
today = datetime.now().date()
uin_exist = UserInvitation.query.filter(
cast(UserInvitation.createtime, Date) == today,
UserInvitation.USInviter == superid,
UserInvitation.USInvited == getattr(request, 'user').id,
).first()
if uin_exist:
current_app.logger.info('{}今天已经邀请过这个人了{}'.format(superid, getattr(request, 'user').id))
return
uin = UserInvitation.create({
'UINid': str(uuid.uuid1()),
'USInviter': superid,
'USInvited': getattr(request, 'user').id,
'UINapi': request.path
})
current_app.logger.info('已创建邀请记录')
db.session.add(uin)
db.session.add(SharingType.create({
'STid': str(uuid.uuid1()),
'USid': superid,
'STtype': args.get('sttype', 0)
}))
self.cactivation.add_activation(
ActivationTypeEnum.share_old.value, superid, getattr(request, 'user').id)
except Exception as e:
current_app.logger.info('secret_usid 记录失败 error = {}'.format(e))
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 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 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 wechat_notify(self, **kwargs):
"""微信支付回调接口"""
redirect = kwargs.get('redirect')
with db.auto_commit():
if not redirect:
data = self.wx_pay.to_dict(request.data)
if not self.wx_pay.check(data):
return self.wx_pay.reply(u"签名验证失败", False)
out_trade_no = data.get('out_trade_no')
current_app.logger.info("This is wechat_notify, opayno is {}".format(out_trade_no))
pp = OrderPay.query.filter_by(OPayno=out_trade_no, isdelete=False).first()
if not pp:
# 支付流水不存在 钱放在平台
return self.wx_pay.reply("OK", True).decode()
self._commision(pp) # 佣金到账
pp.update({
'OPaytime': data.get('time_end'),
'OPaysn': data.get('transaction_id'),
'OPayJson': json.dumps(data)
})
else:
pp = kwargs.get('pp')
pp.update({
'OPaytime': datetime.now(),
})
db.session.add(pp)
# 修改订单状态
om = OrderMain.query.filter(OrderMain.isdelete == false(), OrderMain.OPayno == pp.OPayno).first()
if not om:
current_app.logger.error('===订单查询失败 OPayno= {} ==='.format(pp.OPayno))
return self.wx_pay.reply("OK", True).decode()
if om.OMpayType == PayType.deposit.value: # 押金付
om.OMstatus = OrderStatus.pending.value
elif om.OMpayType == PayType.scorepay.value: # 信用付
om.OMstatus = OrderStatus.pending.value
elif om.OMpayType == PayType.cash.value: # 直接买
om.OMstatus = OrderStatus.has_won.value
om.OMqrcode = self._ticket_order_qrcode(om.OMid, om.USid)
# todo 管理员确认中奖
return self.wx_pay.reply("OK", True).decode()
def update(self):
"""更新供应商信息"""
if not is_admin() and not is_supplizer():
raise AuthorityError()
form = SupplizerUpdateForm().valid_data()
pbids = form.pbids.data
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == form.suid.data).first_('供应商不存在')
supplizer_dict = {
'SUlinkPhone': form.sulinkphone.data,
'SUname': form.suname.data,
'SUlinkman': form.sulinkman.data,
'SUaddress': form.suaddress.data,
'SUbanksn': form.subanksn.data,
'SUbankname': form.subankname.data,
# 'SUpassword': generate_password_hash(form.supassword.data), # 暂时去掉
'SUheader': form.suheader.data,
'SUcontract': form.sucontract.data,
'SUbusinessLicense': form.subusinesslicense.data,
'SUregisteredFund': form.suregisteredfund.data,
'SUmainCategory': form.sumaincategory.data,
# 'SUregisteredTime': form.suregisteredtime.data,
'SUlegalPerson': form.sulegalperson.data,
'SUemail': form.suemail.data,
'SUlegalPersonIDcardFront': form.sulegalpersonidcardfront.data,
'SUlegalPersonIDcardBack': form.sulegalpersonidcardback.data,
}
if is_admin():
# if form.subaserate.data:
# supplizer_dict['SUbaseRate'] = form.subaserate.data,
if isinstance(form.sustatus.data, int):
supplizer_dict['SUstatus'] = form.sustatus.data
if form.sustatus.data == UserStatus.usual.value and not supplizer.SUpassword:
supplizer_dict['SUpassword'] = generate_password_hash(
supplizer.SUloginPhone)
supplizer.update(supplizer_dict, null='dont ignore')
db.session.add(supplizer)
if is_admin():
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', form.suid.data)
return Success('更新成功')
def set_verifier(self):
form = SetVerifier().valid_data()
if is_admin():
suid = form.suid.data
assert suid, '供应商未指定'
elif is_supplizer():
suid = request.user.id
else:
raise AuthorityError()
sup = Supplizer.query.filter(
Supplizer.isdelete == false(),
Supplizer.SUstatus == UserStatus.usual.value,
Supplizer.SUid == suid).first_('供应商状态异常')
if sup.SUgrade != SupplizerGrade.ticket.value:
raise StatusError('仅虚拟商品供应商可设置核销员')
phone_list = form.phone_list.data
tvid_list = []
instence_list = []
phone_list = {}.fromkeys(phone_list).keys()
with db.auto_commit():
for phone in phone_list:
User.query.filter(
User.isdelete == false(),
User.UStelephone == phone).first_(f'没有手机号为 {phone} 用户 ')
tv = ProductVerifier.query.filter_by(SUid=suid,
PVphone=phone).first()
if not tv:
tv = ProductVerifier.create({
'PVid': str(uuid.uuid1()),
'SUid': suid,
'PVphone': phone
})
instence_list.append(tv)
tvid_list.append(tv.PVid)
db.session.add_all(instence_list)
# 删除无效的
ProductVerifier.query.filter(
ProductVerifier.isdelete == false(),
ProductVerifier.SUid == suid,
ProductVerifier.PVid.notin_(tvid_list)).delete_(
synchronize_session=False)
return Success('修改成功', data=suid)
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 _add_pay_detail(self, **kwargs):
with db.auto_commit():
mountprice = kwargs.get('mount_price')
if Decimal(str(mountprice)) <= Decimal('0'):
# mountprice = Decimal('0.01')
mountprice = Decimal('0.00')
pp = OrderPay.create({
'OPayid': str(uuid.uuid1()),
'OPayno': kwargs.get('opayno'),
'OPayType': kwargs.get('opayType'),
'OPayMount': mountprice,
})
db.session.add(pp)
if kwargs.get('redirect'):
self.wechat_notify(redirect=True, pp=pp)
return ''
return self._pay_detail(kwargs.get('body'), float(mountprice),
kwargs.get('opayno'), kwargs.get('openid'))
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)
if is_admin():
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', suid)
return Success('修改成功')
def _history_order(self, *args, **kwargs):
with db.auto_commit() as session:
status = kwargs.get('status', None)
day = kwargs.get('day', None)
suid = kwargs.get('suid', None)
if 'total' in args:
query = session.query(func.sum(OrderMain.OMtrueMount))
elif 'count' in args:
query = session.query(func.count(OrderMain.OMid))
# elif 'refund' in args:
# return self._inrefund(*args, **kwargs)
query = query.filter(OrderMain.isdelete == False)
if status is not None:
query = query.filter(*status)
if day is not None:
query = query.filter(
cast(OrderMain.createtime, Date) == day,
)
if suid is not None:
query = query.filter(OrderMain.PRcreateId == suid)
return query.first()[0] or 0
def deal_approval(self):
"""管理员处理审批流"""
if is_admin():
admin = Admin.query.filter_by_(
ADid=request.user.id).first_("该管理员已被删除")
sup = None
elif is_supplizer():
sup = Supplizer.query.filter_by_(
SUid=request.user.id).first_("账号状态错误，请重新登录")
admin = None
else:
raise AuthorityError('权限不足')
receive_data = request.json
with db.auto_commit():
if isinstance(receive_data, list):
for data in receive_data:
self.deal_single_approval(data, admin, sup)
else:
self.deal_single_approval(receive_data, admin, sup)
return Success("审批操作完成")
def _cancle(self, order_main):
with db.auto_commit():
# 主单状态修改
order_main.OMstatus = OrderStatus.cancle.value
omid = order_main.OMid
db.session.add(order_main)
# 库存修改
# 库存不限量 暂时去除 0624
# product = Product.query.filter(Product.PRid == order_main.PRid, Product.isdelete == false()).first()
# if product:
# product.PRnum += 1
# db.session.add(product)
# 扣除月销量
today = datetime.now()
ProductMonthSaleValue.query.filter(
ProductMonthSaleValue.isdelete == false(),
ProductMonthSaleValue.PRid == order_main.PRid,
extract('month', ProductMonthSaleValue.createtime) == today.month,
extract('year', ProductMonthSaleValue.createtime) == today.year,
).update({'PMSVnum': ProductMonthSaleValue.PMSVnum - 1}, synchronize_session=False)
def get_user_location(lat, lng, usid, ul=None):
from tickets.common.get_location import GetLocation
from tickets.models.user import UserLocation
try:
gl = GetLocation(lat, lng)
result = gl.result
except Exception as e:
current_app.logger.error('解析地址失败 {}'.format(e))
result = {
'ULlng': lng,
'ULlat': lat,
'ULformattedAddress': '请稍后再试'
}
with db.auto_commit():
if ul:
ul.update(result)
db.session.add(ul)
return ul.ULformattedAddress
result.setdefault('USid', usid)
result.setdefault('ULid', str(uuid.uuid1()))
ul = UserLocation.create(result)
db.session.add(ul)
return ul.ULformattedAddress
def reset_password(self):
form = SupplizerResetPasswordForm().valid_data()
mobile = form.suloginphone.data
password = form.supassword.data
# if is_supplizer():
# code = form.code.data
# correct_code = conn.get(mobile + '_code')
# if correct_code:
# correct_code = correct_code.decode()
# current_app.logger.info('correct code is {}, code is {}'.format(correct_code, code))
# if code != correct_code:
# raise ParamsError('验证码错误')
if not is_admin():
raise AuthorityError()
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUloginPhone == mobile).first()
supplizer.update({'SUpassword': generate_password_hash(password)})
db.session.add(supplizer)
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', supplizer.SUid)
return Success('修改成功')
def _fill_month_sale_value(prid):
month_sale_instance = ProductMonthSaleValue.query.filter(ProductMonthSaleValue.isdelete == false(),
ProductMonthSaleValue.PRid == prid
).order_by(ProductMonthSaleValue.createtime.desc()
).first()
with db.auto_commit():
if not month_sale_instance:
salevolume_dict = {'PMSVid': str(uuid.uuid1()),
'PRid': prid,
'PMSVfakenum': random.randint(15, 100)
}
month_sale_value = salevolume_dict['PMSVfakenum']
current_app.logger.info('没有销量记录，现在创建 >>> {}'.format(month_sale_value))
elif month_sale_instance.createtime.month != datetime.now().month:
month_sale_value = getattr(month_sale_instance, 'PMSVnum')
month_sale_value = random.randint(15, 100) if month_sale_value < 15 else month_sale_value
salevolume_dict = {'PMSVid': str(uuid.uuid1()),
'PRid': prid,
'PMSVfakenum': month_sale_value
}
current_app.logger.info('没有本月销量记录，现在创建 >>> {}'.format(month_sale_value))
else:
salevolume_dict = None
month_sale_value = getattr(month_sale_instance, 'PMSVnum')
current_app.logger.info('存在本月销量 {}'.format(month_sale_value))
if month_sale_value < 15:
month_sale_value = random.randint(15, 100)
month_sale_instance.update({'PMSVfakenum': month_sale_value})
db.session.add(month_sale_instance)
current_app.logger.info('本月销量更新为 {}'.format(month_sale_value))
if salevolume_dict:
db.session.add(ProductMonthSaleValue.create(salevolume_dict))
return month_sale_value
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 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})
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 create_approval(self,
avtype,
startid,
avcontentid,
applyfrom=None,
**kwargs):
"""
avtype:审批流类型id
startid: 发起人id
avcontentid: 待审批的对象
"""
current_app.logger.info(
'start create approval ptid = {0}'.format(avtype))
pt = PermissionType.query.filter_by_(PTid=avtype).first_('参数异常')
start, content = self.__get_approvalcontent(pt,
startid,
avcontentid,
applyfrom=applyfrom,
**kwargs)
db.session.expunge_all()
av = Approval.create({
"AVid":
str(uuid.uuid1()),
"AVname":
avtype + datetime.now().strftime('%Y%m%d%H%M%S'),
"PTid":
avtype,
"AVstartid":
startid,
"AVlevel":
1,
"AVstatus":
ApplyStatus.wait_check.value,
"AVcontent":
avcontentid,
'AVstartdetail':
json.dumps(start, cls=JSONEncoder),
'AVcontentdetail':
json.dumps(content, cls=JSONEncoder),
})
with db.auto_commit():
# 处理人姓名逻辑处理
if applyfrom == ApplyFrom.supplizer.value:
sup = Supplizer.query.filter_by_(SUid=startid).first()
name = getattr(sup, 'SUname', '')
elif applyfrom == ApplyFrom.platform.value:
admin = Admin.query.filter_by_(ADid=startid).first()
name = getattr(admin, 'ADname', '')
else:
user = User.query.filter_by_(USid=startid).first()
name = getattr(user, 'USname', '')
# 创建审批流处理（此时为待处理）记录
aninstance = ApprovalNotes.create({
"ANid":
str(uuid.uuid1()),
"AVid":
av.AVid,
"ADid":
startid,
"ANaction":
ApprovalAction.submit.value,
"AVadname":
name,
"ANabo":
"发起申请",
"ANfrom":
applyfrom
})
db.session.add(av)
db.session.add(aninstance)
return av.AVid
def create(self):
"""添加"""
if is_admin():
Admin.query.filter_by_(ADid=request.user.id).first_('账号状态异常')
current_app.logger.info(">>> Admin Create a Supplizer <<<")
elif is_anonymous():
current_app.logger.info(
">>> Tourist Uploading Supplizer Files <<<")
else:
raise AuthorityError('无权限')
form = SupplizerCreateForm().valid_data()
if isinstance(form.sugrade.data, int) and form.sugrade.data == 0:
raise AuthorityError('暂时只支持添加虚拟商品供应商')
suid = str(uuid.uuid1())
if is_admin():
sustatus = UserStatus.usual.value
sudeposit = form.sudeposit.data
else:
sustatus = UserStatus.auditing.value
sudeposit = 0
supassword = generate_password_hash(
form.supassword.data) if form.supassword.data else None
try:
with db.auto_commit():
supperlizer = Supplizer.create({
'SUid':
suid,
'SUlinkPhone':
form.sulinkphone.data,
'SUloginPhone':
form.suloginphone.data,
'SUname':
form.suname.data,
'SUlinkman':
form.sulinkman.data,
# 'SUbaseRate': form.subaserate.data,
'SUaddress':
form.suaddress.data,
'SUdeposit':
sudeposit,
'SUstatus':
sustatus, # 管理员添加的可直接上线
'SUbanksn':
form.subanksn.data,
'SUbankname':
form.subankname.data,
'SUpassword':
supassword,
'SUheader':
form.suheader.data,
'SUcontract':
form.sucontract.data,
'SUbusinessLicense':
form.subusinesslicense.data,
'SUregisteredFund':
form.suregisteredfund.data,
'SUmainCategory':
form.sumaincategory.data,
'SUregisteredTime':
form.suregisteredtime.data,
'SUlegalPerson':
form.sulegalperson.data,
'SUemail':
form.suemail.data,
'SUlegalPersonIDcardFront':
form.sulegalpersonidcardfront.data,
'SUlegalPersonIDcardBack':
form.sulegalpersonidcardback.data,
'SUgrade':
form.sugrade.data or 0,
})
db.session.add(supperlizer)
if is_admin():
self.base_admin.create_action(AdminActionS.insert.value,
'Supplizer', suid)
# if pbiminActionS.insert.value, 'SupplizerDepositLog', str(uuid.uuid1()))
except IntegrityError:
raise ParamsError('手机号重复')
return Success('创建成功', data={'suid': supperlizer.SUid})