def return_coupon_deposite():
now = datetime.now()
yesterday = now - timedelta(days=1)
current_app.logger.info('开始返回供应商发布优惠券剩余押金')
with db.auto_commit():
coupon_list = Coupon.query.filter(Coupon.isdelete == False,
Coupon.COvalidEndTime > yesterday,
Coupon.COvalidEndTime <= now,
Coupon.SUid != None).all()
current_app.logger.info('今天有 {} 优惠券到期'.format(len(coupon_list)))
for coupon in coupon_list:
su = Supplizer.query.filter(Supplizer.isdelete == False,
Supplizer.SUid == coupon.SUid).first()
if not su:
continue
unused_count = CouponUser.query.filter(
CouponUser.isdelete == False, CouponUser.COid == coupon.COid,
CouponUser.UCalreadyUse == False).count()
current_app.logger.info('get 优惠券 {} 未使用的 {} 未领取的 {}'.format(
coupon.COid, unused_count, coupon.COremainNum))
coupon_remain = (Decimal(str(coupon.COremainNum or 0)) + Decimal(
str(unused_count or 0))) * Decimal(str(coupon.COsubtration))
# 押金返回
su_remain = Decimal(str(su.SUdeposit or 0))
current_app.logger.info(
'开始返回供应商 {} 押金 该供应商押金剩余 {} 本次增加 {} 修改后为 {} '.format(
su.SUname, su_remain, coupon_remain,
su_remain + coupon_remain))
su.SUdeposit = su_remain + coupon_remain
# 增加押金变更记录
sdl = SupplizerDepositLog.create({
"SDLid": str(uuid.uuid1()),
'SUid': su.SUid,
'SDLnum': coupon_remain,
'SDafter': su.SUdeposit,
'SDbefore': su_remain,
'SDLacid': 'system'
})
db.session.add(sdl)
db.session.flush()
current_app.logger.info('返回供应商押金结束')
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_tourist():
current_app.logger.info(
">>> Tourist Uploading Supplizer Files <<<")
else:
raise AuthorityError('无权限')
form = SupplizerCreateForm().valid_data()
pbids = form.pbids.data
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,
})
db.session.add(supperlizer)
if is_admin():
BASEADMIN().create_action(AdminActionS.insert.value,
'Supplizer', suid)
if pbids:
for pbid in pbids:
product_brand = ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.PBid == pbid).first()
if not product_brand:
raise NotFound('品牌不存在')
if product_brand.SUid:
raise DumpliError('品牌已有供应商')
product_brand.SUid = supperlizer.SUid
db.session.add(product_brand)
if sudeposit and is_admin():
SupplizerDepositLog.create({
'SDLid': str(uuid.uuid1()),
'SUid': suid,
'SDLnum': Decimal(sudeposit),
'SDafter': Decimal(sudeposit),
'SDbefore': 0,
'SDLacid': request.user.id,
})
BASEADMIN().create_action(AdminActionS.insert.value,
'SupplizerDepositLog',
str(uuid.uuid1()))
except IntegrityError:
raise ParamsError('手机号重复')
return Success('创建成功', data={'suid': supperlizer.SUid})
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), # todo 是不是要加上
'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)
if form.sudeposit.data:
sudeposit = form.sudeposit.data
supplizer_dict['SUdeposit'] = Decimal(sudeposit)
if Decimal(sudeposit) != Decimal(
getattr(supplizer, 'SUdeposit', 0)): # 押金有变化时进行记录
depositlog = SupplizerDepositLog.create({
'SDLid':
str(uuid.uuid1()),
'SUid':
form.suid.data,
'SDLnum':
Decimal(sudeposit) -
Decimal(getattr(supplizer, 'SUdeposit', 0)),
'SDafter':
Decimal(sudeposit),
'SDbefore':
Decimal(getattr(supplizer, 'SUdeposit', 0)),
'SDLacid':
request.user.id,
})
db.session.add(depositlog)
BASEADMIN().create_action(AdminActionS.insert.value,
'SupplizerDepositLog',
str(uuid.uuid1()))
supplizer.update(supplizer_dict, null='dont ignore')
db.session.add(supplizer)
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'Supplizer', form.suid.data)
if pbids and is_admin():
for pbid in pbids:
product_brand = ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.PBid == pbid).first()
if not product_brand:
raise NotFound('品牌不存在')
if product_brand.SUid and product_brand.SUid != supplizer.SUid:
raise DumpliError('品牌已有供应商')
# if product_brand.PBstatus ==
# todo 品牌已下架
product_brand.SUid = form.suid.data
db.session.add(product_brand)
# 删除其他的关联
ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.SUid == form.suid.data,
ProductBrand.PBid.notin_(pbids)).update(
{'SUid': None}, synchronize_session=False)
return Success('更新成功')
def create(self):
form = CouponCreateForm().valid_data()
pbids = form.pbids.data
prids = form.prids.data
adid = suid = None
if is_admin():
adid = request.user.id
elif is_supplizer():
suid = request.user.id
"""如果是供应商暂时取消发布折扣优惠券权限"""
if form.codiscount.data != 10:
raise ParamsError('暂不提供供应商发放折扣优惠券，请联系平台后台发放')
if not form.colimitnum:
raise ParamsError('需要指定发放数量')
if not (pbids or prids):
raise ParamsError('不能发放全平台优惠券')
else:
raise AuthorityError()
with self.strade.auto_commit() as s:
s_list = []
coid = str(uuid.uuid1())
itids = form.itids.data
coupon_instance = Coupon.create({
'COid':
coid,
'COname':
form.coname.data,
'COisAvailable':
form.coisavailable.data,
'COcanCollect':
form.coiscancollect.data,
'COlimitNum':
form.colimitnum.data,
'COcollectNum':
form.cocollectnum.data,
'COsendStarttime':
form.cosendstarttime.data,
'COsendEndtime':
form.cosendendtime.data,
'COvalidStartTime':
form.covalidstarttime.data,
'COvalidEndTime':
form.covalidendtime.data,
'COdiscount':
form.codiscount.data,
'COdownLine':
form.codownline.data,
'COsubtration':
form.cosubtration.data,
'COdesc':
form.codesc.data,
'COuseNum':
form.cousenum.data,
'ADid':
adid,
'SUid':
suid
})
s_list.append(coupon_instance)
for itid in itids:
s.query(Items).filter_by_({
'ITid': itid,
'ITtype': ItemType.coupon.value
}).first_('指定标签不存在')
# 优惠券标签中间表
couponitem_instance = CouponItem.create({
'CIid':
str(uuid.uuid4()),
'COid':
coid,
'ITid':
itid
})
s_list.append(couponitem_instance)
# 优惠券和应用对象的中间表
for pbid in pbids:
# 限制使用品牌
pb = ProductBrand.query.filter(
ProductBrand.isdelete == False, ProductBrand.PBid == pbid,
ProductBrand.SUid == suid).first_('品牌不存在')
coupon_for = CouponFor.create({
'CFid': str(uuid.uuid1()),
'PBid': pbid,
'COid': coupon_instance.COid,
})
s_list.append(coupon_for)
for prid in prids:
# 限制使用商品
product = Products.query.filter(
Products.isdelete == False, Products.PRid == prid,
Products.CreaterId == suid).first_('不能指定其他供应商商品')
coupon_for = CouponFor.create({
'CFid': str(uuid.uuid1()),
'PRid': prid,
'COid': coupon_instance.COid,
})
s_list.append(coupon_for)
if is_supplizer():
# 供应商发放优惠券 押金扣除
su = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == request.user.id).first()
co_total = Decimal(
str(coupon_instance.COlimitNum *
coupon_instance.COsubtration))
if su.SUdeposit < co_total:
raise ParamsError('供应商押金不足。当前账户剩余押金 {} 发放优惠券需要 {}'.format(
su.SUdeposit, co_total))
after_deposit = su.SUdeposit - co_total
sdl = SupplizerDepositLog.create({
'SDLid': str(uuid.uuid1()),
'SUid': su.SUid,
'SDLnum': co_total,
# 'SDLtype': SupplizerDepositLogType.account_out.value,
'SDafter': after_deposit,
'SDbefore': su.SUdeposit,
'SDLacid': su.SUid
})
current_app.logger.info(
'供应商 {} 押金 {} 发放优惠券 {} 变更后 押金剩余 {} '.format(
su.SUname, su.SUdeposit, co_total, after_deposit))
su.SUdeposit = after_deposit
s_list.append(sdl)
# todo 优惠券历史创建
s.add_all(s_list)
return Success('添加成功', data=coid)
def _caculate_commsion(self,
user,
up1,
up2,
up3,
commision,
order_part,
is_act=False):
"""计算各级佣金"""
# 活动佣金即时到账
suid = order_part.PRcreateId
if is_act:
current_app.logger.info('活动订单和押金即时到账')
UCstatus = UserCommissionStatus.in_account.value
else:
UCstatus = None
default_level1commision, default_level2commision, default_level3commision, default_planetcommision = json.loads(
commision.Levelcommision)
reduce_ratio = json.loads(commision.ReduceRatio)
increase_ratio = json.loads(commision.IncreaseRatio)
# 基础佣金比
user_level1commision = Decimal(
str(
self._current_commission(
getattr(order_part, 'USCommission1', ''),
default_level1commision)))
user_level2commision = Decimal(
str(
self._current_commission(
getattr(order_part, 'USCommission2', ''),
default_level2commision)))
user_level3commision = Decimal(
str(
self._current_commission(
getattr(order_part, 'USCommission3', ''),
default_level3commision)))
# 平台 + 用户 抽成: 获取成功比例, 依次查找订单--> sku --> 系统默认
planet_and_user_rate = Decimal(str(order_part.SkudevideRate or 0))
if not planet_and_user_rate:
sku = ProductSku.query.filter(
ProductSku.SKUid == OrderPart.SKUid).first()
if sku:
planet_and_user_rate = Decimal(str(sku.SkudevideRate or 0))
if not planet_and_user_rate:
planet_and_user_rate = default_planetcommision
planet_and_user_rate = Decimal(planet_and_user_rate) / 100
# 平台固定抽成
planet_rate = Decimal(default_planetcommision) / 100
planet_commision = order_part.OPsubTotal * planet_rate # 平台获得, 是总价的的百分比
user_commision = order_part.OPsubTotal * planet_and_user_rate - planet_commision # 用户获得, 是总价 - 平台获得
# user_rate = planet_and_user_rate - planet_rate # 用户的的比例
# 用户佣金
commision_for_supplizer = order_part.OPsubTotal * (
Decimal('1') - planet_and_user_rate) # 给供应商的钱 总价 * ( 1 - 让利 )
commision_for_supplizer = self.get_two_float(commision_for_supplizer)
desposit = 0
# 正常应该获得佣金
up1_base = up2_base = up3_base = 0
if up1 and up1.USlevel > 1:
user_level1commision = self._current_commission(
up1.USCommission1, user_level1commision) / 100 # 个人佣金比
up1_base = user_commision * user_level1commision
if up2 and up2.USlevel > 1:
user_level2commision = self._current_commission(
up2.USCommission2, user_level2commision) / 100 # 个人佣金比
up2_base = user_commision * user_level2commision
# 偏移
up1_up2 = up1.CommisionLevel - up2.CommisionLevel
up1_base, up2_base = self._caculate_offset(
up1_up2, up1_base, up2_base, reduce_ratio, increase_ratio)
if up3 and up3.USlevel > 1:
user_level3commision = self._current_commission(
up3.USCommission3, user_level3commision) / 100 # 个人佣金比
up3_base = user_commision * user_level3commision
up2_up3 = Decimal(up2.CommisionLevel) - Decimal(
up3.CommisionLevel)
up2_base, up3_base = self._caculate_offset(
up2_up3, up2_base, up3_base, reduce_ratio,
increase_ratio)
if up1_base:
up1_base = self.get_two_float(up1_base)
user_commision -= up1_base
current_app.logger.info('一级获得佣金: {}'.format(up1_base))
commision_account = UserCommission.create({
'UCid': str(uuid.uuid1()),
'OMid': order_part.OMid,
'OPid': order_part.OPid,
'UCcommission': up1_base,
'USid': up1.USid,
'PRtitle': order_part.PRtitle,
'SKUpic': order_part.SKUpic,
'UCstatus': UCstatus,
'FromUsid': user.USid
})
db.session.add(commision_account)
if up2_base:
up2_base = self.get_two_float(up2_base)
user_commision -= up2_base
current_app.logger.info('二级获得佣金: {}'.format(up2_base))
commision_account = UserCommission.create({
'UCid': str(uuid.uuid1()),
'OMid': order_part.OMid,
'OPid': order_part.OPid,
'UCcommission': up2_base,
'USid': up2.USid,
'PRtitle': order_part.PRtitle,
'SKUpic': order_part.SKUpic,
'UCstatus': UCstatus,
'FromUsid': user.USid
})
db.session.add(commision_account)
if up3_base:
up3_base = self.get_two_float(up3_base)
user_commision -= up3_base
current_app.logger.info('三级获得佣金: {}'.format(up3_base))
commision_account = UserCommission.create({
'UCid': str(uuid.uuid1()),
'OMid': order_part.OMid,
'OPid': order_part.OPid,
'UCcommission': up3_base,
'USid': up3.USid,
'PRtitle': order_part.PRtitle,
'SKUpic': order_part.SKUpic,
'UCstatus': UCstatus,
'FromUsid': user.USid
})
db.session.add(commision_account)
planet_remain = user_commision + planet_commision
# 优惠券计算
order_coupon = order_part.order_coupon
if order_coupon:
if order_coupon.SUid:
# commision_for_supplizer -= (Decimal(order_part.OPsubTotal) - Decimal(order_part.OPsubTrueTotal))
current_app.logger.info(
'get commision_for_supplizer {} '.format(
commision_for_supplizer))
commision_sub = (Decimal(order_part.OPsubTotal) -
Decimal(order_part.OPsubTrueTotal))
current_app.logger.info(
'get commision_sub {}'.format(commision_sub))
if commision_for_supplizer >= commision_sub:
desposit = commision_sub
commision_for_supplizer -= commision_sub
else:
desposit = commision_for_supplizer
commision_for_supplizer = 0
else:
planet_remain -= (Decimal(order_part.OPsubTotal) -
Decimal(order_part.OPsubTrueTotal))
# 供应商获取佣金
if suid:
su = Supplizer.query.filter(Supplizer.isdelete == False,
Supplizer.SUid == suid).first()
current_app.logger.info('get supplizer {}'.format(su))
if su:
if desposit:
current_app.logger.info('get change {}'.format(desposit))
desposit = Decimal(str(desposit))
sudeposit = Decimal(str(su.SUdeposit or 0))
after_deposit = sudeposit + desposit
current_app.logger.info(
'start add supplizer deposit before {} change {} after {}'
.format(sudeposit, desposit, after_deposit))
sdl = SupplizerDepositLog.create({
'SDLid':
str(uuid.uuid1()),
'SUid':
su.SUid,
'SDLnum':
desposit,
'SDafter':
after_deposit,
'SDbefore':
sudeposit,
'SDLacid':
'system',
'SDLcontentid':
order_part.OPid,
})
su.SUdeposit = after_deposit
db.session.add(sdl)
commision_account = UserCommission.create({
'UCid':
str(uuid.uuid1()),
'OMid':
order_part.OMid,
'OPid':
order_part.OPid,
'UCcommission':
commision_for_supplizer,
'USid':
suid,
'CommisionFor':
ApplyFrom.supplizer.value,
'PRtitle':
order_part.PRtitle,
'SKUpic':
order_part.SKUpic,
'UCstatus':
UCstatus,
'FromUsid':
user.USid
})
db.session.add(commision_account)
current_app.logger.info('供应商获取佣金: {}'.format(
commision_account.UCcommission))
else:
planet_remain += commision_for_supplizer
# 平台剩余佣金
commision_account = UserCommission.create({
'UCid':
str(uuid.uuid1()),
'OMid':
order_part.OMid,
'OPid':
order_part.OPid,
'UCcommission':
planet_remain,
'USid':
'0',
'CommisionFor':
ApplyFrom.platform.value,
'PRtitle':
order_part.PRtitle,
'SKUpic':
order_part.SKUpic,
'UCstatus':
UCstatus,
'FromUsid':
user.USid
})
db.session.add(commision_account)
current_app.logger.info('平台获取: {}'.format(planet_remain))