def del_award(self):
"""删除申请"""
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = ShelfFreshManfirstOrder().valid_data()
fmfaid = form.fmfaid.data
with db.auto_commit():
apply_info = FreshManFirstApply.query.filter_by_(
FMFAid=fmfaid).first_('申请未找到或已删除')
if is_supplizer():
assert apply_info.SUid == request.user.id, '供应商只能删除自己提交的申请'
if apply_info.FMFAstatus not in [
ApplyStatus.cancle.value, ApplyStatus.reject.value
]:
raise StatusError('只能删除已拒绝或已撤销状态下的申请')
apply_info.isdelete = True
return Success('删除成功', {'fmfaid': fmfaid})
def change_password(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = SupplizerChangePasswordForm().valid_data()
old_password = form.oldpassword.data
supassword = form.supassword.data
suid = form.suid.data
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == suid).first_('不存在的供应商')
if not is_admin() and not check_password_hash(
supplizer.SUpassword, old_password):
raise AuthorityError('原密码错误')
supplizer.SUpassword = generate_password_hash(supassword)
db.session.add(supplizer)
return Success('修改成功')
def cancel_apply(self):
"""取消申请"""
if is_admin():
Admin.query.filter_by_(ADid=request.user.id).first_("账号状态错误")
# elif is_supplizer():
# Supplizer.query.filter_by_(SUid=request.user.id).first_("账号状态错误")
else:
raise AuthorityError()
data = parameter_required(('ipid', ))
with db.auto_commit():
ip = IntegralProduct.query.filter(
IntegralProduct.IPid == data.get('ipid'),
IntegralProduct.isdelete == False, IntegralProduct.IPstatus ==
ApplyStatus.wait_check.value).first_("只有在审核状态下的申请可以撤销")
if is_supplizer() and ip.SUid != request.user.id:
raise AuthorityError("只能撤销属于自己的申请")
ip.update({'IPstatus': ApplyStatus.cancle.value})
db.session.add(ip)
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'IntegralProduct', data.get('ipid'))
# 返回库存
product = Products.query.filter_by(PRid=ip.PRid,
isdelete=False).first_('商品信息出错')
ips_old = IntegralProductSku.query.filter(
IntegralProductSku.IPid == ip.IPid,
IntegralProductSku.isdelete == False,
IntegralProduct.isdelete == False,
).all()
for sku in ips_old:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CIntegralStore,
self)._update_stock(int(sku.IPSstock), product,
sku_instance)
# 同时取消正在进行的审批流
Approval.query.filter_by(
AVcontent=ip.IPid,
AVstartid=request.user.id,
isdelete=False,
AVstatus=ApplyStatus.wait_check.value).update(
{'AVstatus': ApplyStatus.cancle.value})
return Success('已取消申请', dict(ipid=ip.IPid))
def check_abnormal_sale_volume():
"""销量修正"""
with db.auto_commit():
from planet.models import OrderPart, OrderMain, ProductMonthSaleValue
from sqlalchemy import extract
from sqlalchemy import func
product_list = Products.query.filter(Products.PRsalesValue != 0,
Products.isdelete == False).all()
for product in product_list:
opcount = OrderPart.query.outerjoin(
OrderMain, OrderMain.OMid == OrderPart.OMid).filter(
OrderMain.isdelete == False, OrderPart.isdelete == False,
OrderMain.OMstatus != -40, OrderPart.PRid == product.PRid,
OrderPart.OPisinORA == False).count()
print('当前PRid: {}, 销量数为{}, 订单count{}'.format(
product.PRid, product.PRsalesValue, opcount))
current_app.logger.info('当前PRid: {}, 销量数为{}, 订单count{}'.format(
product.PRid, product.PRsalesValue, opcount))
# 修正商品销量
product.update({'PRsalesValue': opcount}, null='no')
db.session.add(product)
# 修正商品月销量
ops = db.session.query(extract(
'month', OrderPart.createtime), func.count('*')).outerjoin(
OrderMain, OrderMain.OMid == OrderPart.OMid).filter(
OrderMain.isdelete == False,
OrderPart.isdelete == False, OrderMain.OMstatus != -40,
OrderPart.PRid == product.PRid,
OrderPart.OPisinORA == False).group_by(
extract('month', OrderPart.createtime)).order_by(
extract('month',
OrderPart.createtime).asc()).all()
for o in ops:
# print(o)
print("该商品{}月份销量为{}".format(o[0], o[-1]))
current_app.logger.info("该商品{}月份销量为{}".format(o[0], o[-1]))
ProductMonthSaleValue.query.filter(
ProductMonthSaleValue.PRid == product.PRid,
ProductMonthSaleValue.isdelete == False,
extract('year', ProductMonthSaleValue.createtime) == 2019,
extract('month', ProductMonthSaleValue.createtime) == o[0],
).update({
'PMSVnum': o[-1],
}, synchronize_session=False)
def add_toilet(self):
"""添加厕所"""
if common_user():
creator = User.query.filter_by_(
USid=getattr(request, 'user').id).first_('请重新登录')
creator_id = creator.USid
creator_type = ApplyFrom.user.value
elif is_admin():
creator = Admin.query.filter_by_(
ADid=getattr(request, 'user').id).first_('请重新登录')
creator_id = creator.ADid
creator_type = ApplyFrom.platform.value
else:
raise TokenError('请重新登录')
data = parameter_required({
'latitude': '纬度',
'longitude': '经度',
'toimage': '图片'
})
latitude, longitude = data.get('latitude'), data.get('longitude')
latitude, longitude = self.cplay.check_lat_and_long(
latitude, longitude)
if common_user() and latitude and longitude:
self.BaseController.get_user_location(latitude, longitude,
creator_id)
exist = Toilet.query.filter(Toilet.isdelete == false(),
Toilet.longitude == longitude,
Toilet.latitude == latitude).first()
if exist:
raise ParamsError('该位置的厕所已被上传过')
with db.auto_commit():
toilet = Toilet.create({
'TOid': str(uuid.uuid1()),
'creatorID': creator_id,
'creatorType': creator_type,
'longitude': longitude,
'latitude': latitude,
'TOimage': data.get('toimage'),
'TOstatus': ApprovalAction.submit.value
})
db.session.add(toilet)
super(CScenicSpot, self).create_approval('totoilet', creator_id,
toilet.TOid, creator_type)
return Success('上传成功', data={'toid': toilet.TOid})
def fix_evaluate_status_error():
"""修改评价异常数据（已评价，未修改状态）"""
current_app.logger.info("-----> 开始检测商品评价异常数据 <-----")
with db.auto_commit():
order_evaluations = OrderEvaluation.query.filter_by_().all()
count = 0
for oe in order_evaluations:
om = OrderMain.query.filter(
OrderMain.OMid == oe.OMid,
OrderMain.OMfrom.in_(
[OrderFrom.carts.value,
OrderFrom.product_info.value])).first()
if not om:
om_info = OrderMain.query.filter(
OrderMain.OMid == oe.OMid).first()
current_app.logger.info(
"--> 存在有评价，主单已删除或来自活动订单，OMid为{0}, OMfrom为{1} <--".format(
str(oe.OMid), str(om_info.OMfrom)))
continue
omid = om.OMid
omstatus = om.OMstatus
if int(omstatus) == OrderMainStatus.wait_comment.value:
current_app.logger.info(
"--> 已存在评价的主单id为 {}，未修改前的主单状态为{} <--".format(
str(omid), str(omstatus)))
current_app.logger.info("--> 开始更改状态 <--")
upinfo = OrderMain.query.filter_by_(OMid=omid).update(
{'OMstatus': OrderMainStatus.ready.value})
count += 1
if upinfo:
current_app.logger.info("--> {}:更改状态成功 <--".format(
str(omid)))
else:
current_app.logger.info("--> {}:更改失败 <--".format(
str(omid)))
current_app.logger.info(
"--------------分割线----------------------")
current_app.logger.info(
"--------------分割线----------------------")
else:
current_app.logger.info("-----> 没有发现商品评价异常数据 <-----")
current_app.logger.info("-----> 更新结束，共更改{}条数据 <-----".format(
str(count)))
def check_for_update(*args, **kwargs):
current_app.logger.info('args is {}, kwargs is {}'.format(args, kwargs))
from planet.control.CUser import CUser
if 'users' in kwargs:
users = kwargs.get('users')
elif 'usid' in kwargs:
users = User.query.filter(User.isdelete == False,
User.USid == kwargs.get('usid')).all()
elif args:
users = args
else:
users = User.query.filter(User.isdelete == False,
User.CommisionLevel <= 5,
User.USlevel == 2).all()
cuser = CUser()
for user in users:
with db.auto_commit():
cuser._check_for_update(user=user)
db.session.add(user)
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)
BASEADMIN().create_action(AdminActionS.insert.value, 'ActivationCodeRule', str(uuid.uuid1()))
return Success('添加成功', rule_instance.ACRid)
def create_ticket(self):
"""创建票务"""
data = request.json
(tistarttime, tiendtime, tiprice, tideposit, tinum, liids, ticategory,
titripstarttime, titripendtime) = self._validate_ticket_param(data)
if Ticket.query.filter(Ticket.isdelete == false(), Ticket.TIname == data.get('tiname')).first():
raise ParamsError('该门票名称已存在')
instance_list = []
with db.auto_commit():
ticket = Ticket.create({'TIid': str(uuid.uuid1()),
'ADid': getattr(request, 'user').id,
'TIname': data.get('tiname'),
'TIimg': data.get('tiimg'),
'TIstartTime': tistarttime,
'TIendTime': tiendtime,
'TItripStartTime': titripstarttime,
'TItripEndTime': titripendtime,
'TIrules': data.get('tirules'),
'TIcertificate': data.get('ticertificate') if data.get('ticertificate') else None,
'TIdetails': data.get('tidetails'),
'TIprice': tiprice,
'TIdeposit': tideposit,
'TIstatus': TicketStatus.ready.value,
'TInum': tinum,
'TIabbreviation': data.get('tiabbreviation'),
'TIcategory': ticategory
})
instance_list.append(ticket)
for liid in liids:
linkage = Linkage.query.filter(Linkage.isdelete == false(), Linkage.LIid == liid).first()
if not linkage:
continue
tl = TicketLinkage.create({'TLid': str(uuid.uuid1()),
'LIid': liid,
'TIid': ticket.TIid})
instance_list.append(tl)
db.session.add_all(instance_list)
# 异步任务: 开始
self._create_celery_task(ticket.TIid, tistarttime)
# 异步任务: 结束
self._create_celery_task(ticket.TIid, tiendtime, start=False)
self.BaseAdmin.create_action(AdminActionS.insert.value, 'Ticket', ticket.TIid)
return Success('创建成功', data={'tiid': ticket.TIid})
def auto_confirm_order():
"""已签收7天自动确认收货, 在物流跟踪上已经签收, 但是用户没有手动签收的订单"""
from planet.models import OrderLogistics
from planet.control.COrder import COrder
cfs = ConfigSettings()
auto_confirm_day = int(cfs.get_item('order_auto', 'auto_confirm_day'))
time_now = datetime.now()
corder = COrder()
order_mains = OrderMain.query.filter(
OrderMain.isdelete == False,
OrderMain.OMstatus == OrderMainStatus.wait_recv.value,
OrderLogistics.OMid == OrderMain.OMid,
OrderLogistics.isdelete == False, OrderLogistics.OLsignStatus ==
LogisticsSignStatus.already_signed.value, OrderLogistics.updatetime <=
time_now - timedelta(days=auto_confirm_day)).all()
current_app.logger.info('自动确认收货, 共{}个订单'.format(len(order_mains)))
for order_main in order_mains:
with db.auto_commit():
order_main = corder._confirm(order_main=order_main)
def delete(self):
data = parameter_required(('coid', ))
coid = data.get('coid')
with db.auto_commit():
coupon = Coupon.query.filter(
Coupon.isdelete == False,
Coupon.COid == coid,
).first_('优惠券不存在')
coupon.isdelete = True
db.session.add(coupon)
# 删除用户的优惠券
coupon_user = CouponUser.query.filter(
CouponUser.isdelete == False,
CouponUser.COid == coid).delete_()
coupon_for = CouponFor.query.filter(
CouponFor.isdelete == False, CouponFor.COid == coid).delete_()
current_app.logger.info(
'删除优惠券的同时 将{}个用户拥有的优惠券也删除'.format(coupon_user))
return Success('删除成功')
def update(self):
"""平台分销佣金设置"""
form = CommsionUpdateForm().valid_data()
with db.auto_commit():
commision = Commision.query.filter(
Commision.isdelete == False).first()
if not commision:
commision = Commision()
from planet import JSONEncoder
commission_dict = {
'Levelcommision':
json.dumps(form.levelcommision.data, cls=JSONEncoder),
'InviteNum':
form.invitenum.data,
'GroupSale':
form.groupsale.data,
'PesonalSale':
form.pesonalsale.data,
'InviteNumScale':
form.invitenumscale.data,
'GroupSaleScale':
form.groupsalescale.data,
'PesonalSaleScale':
form.pesonalsalescale.data,
'ReduceRatio':
json.dumps(form.reduceratio.data, cls=JSONEncoder),
'IncreaseRatio':
json.dumps(form.increaseratio.data, cls=JSONEncoder),
}
[
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')
levelcommision = json.loads(commision.Levelcommision)[:-1]
if sum(levelcommision) > 100:
raise ParamsError('总佣金比大于100')
db.session.add(commision)
BASEADMIN().create_action(AdminActionS.update.value, 'Commision',
commision.COid)
return Success('修改成功')
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 get(self):
"""获取主单物流"""
data = parameter_required(('omid', ))
omid = data.get('omid')
with db.auto_commit():
order_logistics = OrderLogistics.query.filter_by_({
'OMid': omid
}).first_('未获得物流信息')
time_now = datetime.now()
if order_logistics.OLdata:
oldata = json.loads(order_logistics.OLdata)
if not oldata:
oldata_status = False
else:
oldata_status = oldata.get('status')
if str(oldata_status) == "205":
oldata_status = False
else:
oldata_status = True
else:
oldata_status = False
# 没有data信息或超过6小时 并且状态不是已签收
if ((not oldata_status or
(time_now - order_logistics.updatetime).total_seconds() >
6 * 3600) and order_logistics.OLsignStatus !=
LogisticsSignStatus.already_signed.value):
order_logistics = self._get_logistics(order_logistics)
logistics_company = LogisticsCompnay.query.filter_by_({
'LCcode':
order_logistics.OLcompany
}).first()
order_logistics.fill(
'OLsignStatus_en',
LogisticsSignStatus(order_logistics.OLsignStatus).name)
order_logistics.fill(
'OLsignStatus_zh',
LogisticsSignStatus(order_logistics.OLsignStatus).zh_value)
order_logistics.fill('logistics_company', logistics_company)
order_logistics.OLdata = json.loads(order_logistics.OLdata)
order_logistics.OLlastresult = json.loads(order_logistics.OLlastresult)
return Success(data=order_logistics)
def shelf(self):
"""下架"""
# if is_supplizer():
# usid = request.user.id
# sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
# current_app.logger.info('Supplizer {} shelf integral apply'.format(sup.SUname))
if is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} shelf integral apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('ipid', ))
ipid = data.get('ipid')
with db.auto_commit():
ip = IntegralProduct.query.filter_by_(IPid=ipid).first_('无此申请记录')
if sup and ip.SUid != usid:
raise StatusError('只能下架自己的商品')
if ip.IPstatus != ApplyStatus.agree.value:
raise StatusError('只能下架已上架的商品')
ip.IPstatus = ApplyStatus.shelves.value
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'IntegralProduct', ipid)
# 返回库存
product = Products.query.filter_by(PRid=ip.PRid,
isdelete=False).first_('商品信息出错')
ips_old = IntegralProductSku.query.filter(
IntegralProductSku.IPid == ip.IPid,
IntegralProductSku.isdelete == False,
IntegralProduct.isdelete == False,
).all()
for sku in ips_old:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CIntegralStore,
self)._update_stock(int(sku.IPSstock), product,
sku_instance)
return Success('下架成功', {'ipid': ipid})
def back_confirm_recv(self):
"""后台确认收货"""
form = RefundConfirmRecvForm().valid_data()
oraid = form.oraid.data
with db.auto_commit():
OrderRefundApply.query.filter(
OrderRefundApply.isdelete == False,
OrderRefundApply.ORAid == oraid,
OrderRefundApply.ORAstatus == ApplyStatus.agree.value,
OrderRefundApply.ORAstate ==
OrderRefundORAstate.goods_money.value).first_('对应的退货申请不存在或未同意')
order_refund = OrderRefund.query.filter(
OrderRefund.isdelete == False,
OrderRefund.ORstatus >=
OrderRefundOrstatus.wait_recv.value, # 确认收货后执行退款
OrderRefund.ORAid == oraid).first_('未发货')
order_refund.ORstatus = OrderRefundOrstatus.ready_recv.value
db.session.add(order_refund)
msg = '已收货'
return Success(msg)
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)
BASEADMIN().create_action(AdminActionS.update.value, 'IndexBanner', ibid)
if not banner:
raise SystemError('服务器繁忙 10000')
return Success('修改成功', {'ibid': ibid})
def delete(self):
# todo 记录删除操作管理员
data = parameter_required(('pbid',))
pbid = data.get('pbid')
with db.auto_commit():
brand = ProductBrand.query.filter(
ProductBrand.PBid == pbid,
ProductBrand.isdelete == False
).first_('品牌不存在')
brand.isdelete = True
db.session.add(brand)
BASEADMIN().create_action(AdminActionS.delete.value, 'ProductBrand', pbid)
# 商品下架
off_products = Products.query.filter(
Products.isdelete == False,
Products.PBid == pbid
).update({
'PRstatus': ProductStatus.off_shelves.value
})
return Success('删除成功')
def get_user_location(lat, lng, usid):
from planet.common.get_location import GetLocation
from planet.models.user import UserLocation
gl = GetLocation(lat, lng)
result = gl.result
with db.auto_commit():
ul = UserLocation.create({
'ULid': str(uuid.uuid1()),
'ULformattedAddress': result.get('formatted_address'),
'ULcountry': result.get('addressComponent').get('country'),
'ULprovince': result.get('addressComponent').get('province'),
'ULcity': result.get('addressComponent').get('city'),
'ULdistrict': result.get('addressComponent').get('district'),
'ULresult': json.dumps(result),
'ULlng': result.get('location').get('lng'),
'ULlat': result.get('location').get('lat'),
'USid': usid,
})
db.session.add(ul)
return ul.ULformattedAddress
def shelf(self):
"""下架"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info('Supplizer {} shelf guess group apply'.format(sup.SUname))
elif is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} shelf guess group apply'.format(admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('gpid',))
gpid = data.get('gpid')
pending_group = GuessGroup.query.filter(GuessGroup.isdelete == False,
GuessGroup.GGstatus.in_((GuessGroupStatus.pending.value,
GuessGroupStatus.waiting.value)),
GuessGroup.GGendtime >= datetime.datetime.now(),
GuessGroup.GPid == gpid).first()
if pending_group:
raise StatusError('该商品仍有拼团未完成，暂不能下架')
with db.auto_commit():
gp = GroupGoodsProduct.query.filter_by_(GPid=gpid).first_('无此申请记录')
if sup and gp.SUid != usid:
raise StatusError('只能下架自己的商品')
if gp.GPstatus != ApplyStatus.agree.value:
raise StatusError('只能下架已上架的商品')
gp.GPstatus = ApplyStatus.shelves.value
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value, 'GroupGoodsProduct', gpid)
# 返回库存
product = Products.query.filter_by(PRid=gp.PRid, isdelete=False).first_('商品信息出错')
gps_old = GroupGoodsSku.query.filter(GroupGoodsSku.GPid == gp.GPid,
GroupGoodsSku.isdelete == False,
).all()
for sku in gps_old:
sku_instance = ProductSku.query.filter_by(isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CGuessGroup, self)._update_stock(int(sku.GSstock), product, sku_instance)
return Success('下架成功', {'gpid': gpid})
def shelf_award(self):
"""撤销申请"""
if is_supplizer():
sup = Supplizer.query.filter_by_(
SUid=request.user.id).first_("账号状态错误")
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter(
MagicBoxApply.MBAid == mbaid,
MagicBoxApply.isdelete == False,
MagicBoxApply.MBAstatus == ApplyStatus.wait_check.value,
).first_('只有待审核状态下的申请可以撤销')
if apply_info.SUid != sup.SUid:
raise AuthorityError("只能撤销属于自己的申请")
apply_info.update({'MBAstatus': ApplyStatus.cancle.value})
db.session.add(apply_info)
# 返回库存
product = Products.query.filter_by(PRid=apply_info.PRid,
isdelete=False).first_('商品信息出错')
gps_old = MagicBoxApplySku.query.filter(
MagicBoxApplySku.MBAid == apply_info.MBAid,
MagicBoxApplySku.isdelete == False,
).all()
for sku in gps_old:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
super(CMagicBox, self)._update_stock(int(sku.MBSstock),
product, sku_instance)
# 同时取消正在进行的审批流
Approval.query.filter_by(
AVcontent=apply_info.MBAid,
AVstartid=sup.SUid,
isdelete=False,
AVstatus=ApplyStatus.wait_check.value).update(
{'AVstatus': ApplyStatus.cancle.value})
return Success('取消成功', {'mbaid': mbaid})
def expired_scene_association():
"""对于修改过结束时间的限时场景，到期后定时清理关联"""
current_app.logger.info('--> 限时场景取消关联定时任务 <-- ')
try:
with db.auto_commit():
scenes = ProductScene.query.filter(
ProductScene.PSendtime < datetime.now(),
ProductScene.createtime != ProductScene.updatetime,
ProductScene.PStimelimited == True,
ProductScene.isdelete == False).all()
current_app.logger.info('--> 共有{}个被修改过的限时场景过期 <-- '.format(
len(scenes)))
for scene in scenes:
sitids = [
sitem.ITid for sitem in SceneItem.query.filter(
SceneItem.PSid == scene.PSid, SceneItem.isdelete ==
False).all()
]
current_app.logger.info('--> 限时场景id : {} <-- '.format(
scene.PSid))
for itid in sitids:
if SceneItem.query.filter(
SceneItem.ITid == itid,
SceneItem.PSid != scene.PSid,
SceneItem.isdelete == False).first():
continue
else:
current_app.logger.info(
'--> 标签"{}"只有此场景有关联，同时删除标签下的商品关联 <-- '.format(
itid))
ProductItems.query.filter(
ProductItems.ITid == itid,
ProductItems.isdelete == False).delete_()
SceneItem.query.filter(
SceneItem.PSid == scene.PSid).delete_() # 删除该场景下的标签关联
except Exception as e:
current_app.logger.error('限时场景到期任务出错 >>> {}'.format(e))
current_app.logger.info('--> 限时场景取消关联定时任务结束 <-- ')
def update_toilet(self):
"""编辑厕所"""
if not is_admin():
raise TokenError('请重新登录')
data = parameter_required(('toid', 'latitude', 'longitude', 'toimage'))
latitude, longitude = data.get('latitude'), data.get('longitude')
latitude, longitude = self.cplay.check_lat_and_long(
latitude, longitude)
toilet = Toilet.query.filter(
Toilet.isdelete == false(),
Toilet.TOid == data.get('toid')).first_('未找到相应厕所信息')
with db.auto_commit():
if data.get('delete'):
toilet.update({'isdelete': True})
self.BaseAdmin.create_action(AdminActionS.delete.value,
'Toilet', toilet.TOid)
else:
toilet.update({
'longitude': longitude,
'latitude': latitude,
'TOimage': data.get('toimage'),
'TOstatus': ApprovalAction.submit.value
})
self.BaseAdmin.create_action(AdminActionS.update.value,
'Toilet', toilet.TOid)
db.session.add(toilet)
# 如果有正在进行的审批，取消
approval_info = Approval.query.filter(
Approval.AVcontent == toilet.TOid,
or_(Approval.AVstartid == toilet.creatorID,
Approval.AVstartid == getattr(request, 'user').id),
Approval.AVstatus == ApplyStatus.wait_check.value,
Approval.isdelete == false()).first()
if approval_info:
approval_info.AVstatus = ApplyStatus.cancle.value
super(CScenicSpot,
self).create_approval('totoilet',
getattr(request, 'user').id, toilet.TOid,
ApplyFrom.platform.value)
return Success('编辑成功', data={'toid': toilet.TOid})
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.query.filter(Supplizer.isdelete == False,
Supplizer.SUloginPhone == mobile).update({
'SUpassword':
generate_password_hash(password)
})
return Success('修改成功')
def send_msg(self, umsgtext, umsgtype, roomid, userid):
umsg = UserMessage.create({
'UMSGid': str(uuid.uuid1()),
'USid': userid,
'ROid': roomid,
'UMSGtext': umsgtext,
'UMSGtype': umsgtype,
})
from planet import socketio
with db.auto_commit():
db.session.add(umsg)
self._fill_umsg(umsg)
room = Room.query.filter_by(ROid=roomid, isdelete=False).first()
um_list = UserRoom.query.filter(UserRoom.ROid == roomid,
UserRoom.USid != userid,
UserRoom.isdelete == False).all()
usersid = self.get_usersid()
for um in um_list:
user = User.query.filter_by(USid=um.USid,
isdelete=False).first()
admin = Admin.query.filter_by(ADid=um.USid,
isdelete=False).first()
usunread = 0
if user:
user.USunread = (user.USunread or 0) + 1
usunread = user.USunread
if admin:
admin.ADunread = (admin.ADunread or 0) + 1
usunread = admin.ADunread
um.URunread = (um.URunread or 0) + 1
umsg.fill('usunread', usunread)
umsg.fill('urunread', um.URunread)
socketio.emit('notice', umsg, room=usersid.get(um.USid))
room.updatetime = datetime.now()
return umsg
def join(self):
"""参与活动, 分享前(或分享后调用), 创建用户的参与记录
"""
# 判断帮拆活动总控制是否结束
Activity.query.filter_by({
'ACtype': ActivityType.magic_box.value
}).first_('活动已结束')
form = MagicBoxJoinForm().valid_data()
mbaid = form.mbaid.data
usid = request.user.id
with db.auto_commit():
today = date.today()
magic_box_apply = MagicBoxApply.query.filter_by_().filter(
MagicBoxApply.AgreeStartime <= today,
MagicBoxApply.AgreeEndtime >= today,
MagicBoxApply.MBAid == mbaid).first_('活动结束')
# 已参与则不再新建记录
magic_box_join = MagicBoxJoin.query.filter_by_({
'USid': usid,
'MBAid': mbaid
}).first()
if not magic_box_join:
# 一期活动只可参与一次
magic_box_join = MagicBoxJoin.create({
'MBJid':
str(uuid.uuid1()),
'USid':
usid,
'MBAid':
mbaid,
'MBJprice':
magic_box_apply.SKUprice,
})
db.session.add(magic_box_join)
else:
# 但是可以多次分享
if magic_box_join.MBJstatus == ActivityRecvStatus.ready_recv.value:
raise StatusError('本期已参与')
return Success('参与成功', data={'mbjid': magic_box_join.MBJid})
def auto_agree_task(avid):
current_app.logger.info('avid is {}'.format(avid))
from planet.control.CApproval import CApproval
cp = CApproval()
with db.auto_commit():
approval = Approval.query.filter(
Approval.isdelete == False,
Approval.AVstatus == ApplyStatus.wait_check.value,
Approval.AVid == avid).first()
if approval:
current_app.logger.info('5分钟自动同意')
current_app.logger.info(dict(approval))
else:
current_app.logger.info('该审批已提前处理')
try:
cp.agree_action(approval)
approval.AVstatus = ApplyStatus.agree.value
except NotFound:
current_app.logger.info('审批流状态有误')
# 如果不存在的商品, 需要将审批流失效
approval.AVstatus = ApplyStatus.cancle.value
db.session.add(approval)
def set_entry(self):
current_app.logger.info("Admin {} set entry banner".format(request.user.username))
data = parameter_required(('contentlink', 'enpic', 'enshow'))
enid = data.get('enid') or str(uuid.uuid1())
with db.auto_commit():
en = Entry.query.filter(
Entry.isdelete == False, Entry.ENid == enid).first()
if data.get('delete'):
if not en:
raise ParamsError('banner 已删除')
en.update({'isdelete': True})
db.session.add(en)
BASEADMIN().create_action(AdminActionS.delete.value, 'Entry', enid)
return Success('删除成功', {'enid': enid})
endict = {
'contentlink': data.get('contentlink'),
'ENpic': data.get('enpic'),
'ENshow': bool(data.get('enshow')),
'ENtype': data.get('entype')
}
if not en:
endict.setdefault('ENid', enid)
endict.setdefault('ACid', request.user.id)
en = Entry.create(endict)
BASEADMIN().create_action(AdminActionS.insert.value, 'Entry', enid)
msg = '添加成功'
else:
en.update(endict)
BASEADMIN().create_action(AdminActionS.update.value, 'Entry', enid)
msg = '修改成功'
db.session.add(en)
if en.ENshow:
Entry.query.filter(
Entry.ENid != enid, Entry.isdelete == False, Entry.ENtype == en.ENtype).update({'ENshow': False})
return Success(msg, {'enid': enid})
def read(self):
data = parameter_required(('pmid', ))
if not common_user():
raise AuthorityError
user = get_current_user()
with db.auto_commit():
upm = UserPlatfromMessage.query.filter_by(PMid=data.get('pmid'),
USid=user.USid,
isdelete=False).first()
upml = UserPlatfromMessageLog.create({
'UPMLid': str(uuid.uuid1()),
'UPMid': upm.UPMid,
'USid': user.USid
})
if upm.UPMstatus != UserPlanetMessageStatus.read.value:
upm.UPMstatus = UserPlanetMessageStatus.read.value
db.session.add(upml)
db.session.add(upm)
# usersids = self.get_usersid()
# self.push_platform_message(usid=user.USid, usersid=usersids.get(user.USid))
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)
BASEADMIN().create_action(AdminActionS.insert.value,
'ManagerSystemNotes', str(uuid.uuid1()))
return Success('创建通告成功', data=mn.MNid)
