def shelf_award(self):
"""撤销申请"""
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = ShelfFreshManfirstOrder().valid_data()
fmfaid = form.fmfaid.data
with db.auto_commit():
suid = request.user.id if is_supplizer() else None
apply_query = FreshManFirstApply.query.filter(
FreshManFirstApply.isdelete == False,
FreshManFirstApply.FMFAid == fmfaid,
FreshManFirstApply.FMFAstatus == ApplyStatus.wait_check.value)
if suid:
apply_query = apply_query.filter(
FreshManFirstApply.SUid == request.user.id, )
apply = apply_query.first_('申请已处理')
# 库存处理
self._re_stock(apply)
apply.FMFAstatus = ApplyStatus.cancle.value
db.session.add(apply)
# 相应的审批流
Approval.query.filter(Approval.isdelete == False,
Approval.AVcontent == fmfaid).update(
{'AVstatus': ApplyStatus.cancle.value})
return Success('撤销成功')
def shelf_award(self):
"""撤销申请"""
if not (is_supplizer() or is_admin()):
raise AuthorityError()
data = parameter_required(('tlpid', ))
tlpid = data.get('tlpid')
if is_supplizer():
tlp_from = ApplyFrom.supplizer.value
suid = request.user.id
else:
tlp_from = ApplyFrom.platform.value
suid = None
with db.auto_commit():
apply_info = TimeLimitedProduct.query.filter_by(
TLPid=tlpid, isdelete=False).first_('无此申请记录')
if apply_info.TLAstatus != ApplyStatus.wait_check.value:
raise StatusError('只有在审核状态的申请可以撤销')
if apply_info.SUid != suid:
raise AuthorityError('仅可撤销自己提交的申请')
apply_info.TLAstatus = ApplyStatus.cancle.value
# 获取原商品属性
# gnap_old = GuessNumAwardProduct.query.filter(GuessNumAwardProduct.GNAAid == apply_info.GNAAid,
# GuessNumAwardProduct.isdelete == False).first()
product = Products.query.filter_by(PRid=apply_info.PRid,
PRfrom=tlp_from,
isdelete=False).first_('商品信息出错')
# 获取原sku属性
tls_list = TimeLimitedSku.query.filter(
TimeLimitedSku.isdelete == False,
TimeLimitedSku.TLPid == apply_info.TLPid).all()
# 遍历原sku 将库存退出去
for sku in tls_list:
sku_instance = ProductSku.query.filter_by(
isdelete=False, PRid=product.PRid,
SKUid=sku.SKUid).first_('商品sku信息不存在')
self._update_stock(int(sku.TLSstock), product, sku_instance)
# 同时将正在进行的审批流改为取消 todo
approval_info = Approval.query.filter_by(
AVcontent=tlpid,
AVstartid=request.user.id,
isdelete=False,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.AVstatus = ApplyStatus.cancle.value
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'TimeLimitedProduct', tlpid)
return Success('取消成功', {'tlpid': tlpid})
def list_apply(self):
"""查看申请列表"""
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = ListFreshmanFirstOrderApply().valid_data()
starttime, endtime = form.starttime.data, form.endtime.data
suid = form.suid.data
if is_supplizer():
suid = request.user.id
adid = form.adid.data
status = form.status.data
query = FreshManFirstApply.query.filter(
FreshManFirstApply.isdelete == False)
if suid:
query = query.filter(
FreshManFirstApply.SUid == suid,
FreshManFirstApply.FMFAfrom == ApplyFrom.supplizer.value)
if adid:
query = query.filter(
FreshManFirstApply.SUid == adid,
FreshManFirstApply.FMFAfrom == ApplyFrom.platform.value)
if status is not None:
query = query.filter(FreshManFirstApply.FMFAstatus == status)
applys = query.filter(
FreshManFirstApply.FMFAstartTime >= starttime,
FreshManFirstApply.FMFAendTime <= endtime).order_by(
FreshManFirstApply.createtime.desc()).all_with_page()
for apply in applys:
# 状态中文
apply.fill('FMFAstatus_zh', ApplyStatus(apply.FMFAstatus).zh_value)
# 商品
fresh_product = FreshManFirstProduct.query.filter(
FreshManFirstProduct.isdelete == False,
FreshManFirstProduct.FMFAid == apply.FMFAid,
).first()
apply.fill('fresh_product', fresh_product)
# 活动sku
freshsku = FreshManFirstSku.query.filter(
FreshManFirstSku.isdelete == False,
FreshManFirstSku.FMFPid == fresh_product.FMFPid).all()
fresh_product.fill('sku', freshsku)
# 申请人
if apply.FMFAfrom == ApplyFrom.supplizer.value:
supplizer = Supplizer.query.filter(
Supplizer.SUid == apply.SUid).first()
apply.fill('from_supplizer', supplizer)
elif apply.FMFAfrom == ApplyFrom.platform.value:
admin = Admin.query.filter(Admin.ADid == apply.SUid).first()
admin.hide('ADfirstpwd', 'ADpassword')
apply.fill('from_admin', admin)
return Success(data=applys)
def set_supplizeraccount(self):
if not is_supplizer():
raise AuthorityError
from flask import request
from planet.control.CUser import CUser
data = request.json
cuser = CUser()
cardno = data.get('sacardno')
cardno = re.sub(r'\s', '', str(cardno))
cuser._CUser__check_card_num(cardno)
check_res = cuser._verify_cardnum(cardno) # 检验卡号
if not check_res.data.get('validated'):
raise ParamsError('请输入正确的银行卡号')
checked_res = cuser._verify_cardnum(data.get('sabankaccount'))
# if not checked_res.data.get('validated'):
# raise ParamsError('请输入正确的开票账户银行卡号')
checked_name = cuser._verify_chinese(data.get('sacardname'))
if not checked_name or len(checked_name[0]) < 2:
raise ParamsError('请输入正确的开户人姓名')
current_app.logger.info('用户输入银行名为:{}'.format(data.get('sabankname')))
bankname = check_res.data.get('cnbankname')
try:
WexinBankCode(bankname)
except Exception:
raise ParamsError('系统暂不支持该银行提现，请更换银行后重新保存')
data['sabankname'] = bankname
current_app.logger.info('校验后更改银行名为:{}'.format(data.get('sabankname')))
sa = SupplizerAccount.query.filter(
SupplizerAccount.SUid == request.user.id,
SupplizerAccount.isdelete == False).first()
if sa:
for key in sa.__dict__:
if str(key).lower() in data:
if re.match(r'^(said|suid)$', str(key).lower()):
continue
if str(key).lower() == 'sacardno':
setattr(sa, key, cardno)
continue
setattr(sa, key, data.get(str(key).lower()))
else:
sa_dict = {}
for key in SupplizerAccount.__dict__:
if str(key).lower() in data:
if not data.get(str(key).lower()):
continue
if str(key).lower() == 'suid':
continue
if str(key).lower() == 'sacardno':
sa_dict.setdefault(key, cardno)
continue
sa_dict.setdefault(key, data.get(str(key).lower()))
sa_dict.setdefault('SAid', str(uuid.uuid1()))
sa_dict.setdefault('SUid', request.user.id)
sa = SupplizerAccount.create(sa_dict)
db.session.add(sa)
return Success('设置供应商账户信息成功')
def list(self):
"""获取优惠券列表"""
form = CouponListForm().valid_data()
itid = form.itid.data
coupons = Coupon.query.filter(Coupon.isdelete == False)
usid = suid = adid = None
if is_supplizer():
suid = request.user.id
elif is_admin():
adid = request.user.id
elif not is_tourist():
usid = request.user.id
if itid:
coupons = coupons.join(CouponItem,
CouponItem.COid == Coupon.COid).filter(
CouponItem.ITid == itid,
CouponItem.isdelete == False)
if suid:
coupons = coupons.filter(Coupon.SUid == suid)
coupons = coupons.order_by(Coupon.createtime.desc(),
Coupon.COid).all_with_page()
for coupon in coupons:
# 标签
self._coupon(coupon, usid=usid)
return Success(data=coupons)
def delete(self):
"""删除申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info('Supplizer {} delete 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 {} delete guess group apply'.format(admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('gpid',))
gpid = data.get('gpid')
with db.auto_commit():
apply_info = GroupGoodsProduct.query.filter_by(GPid=gpid, isdelete=False).first_('没有该商品记录')
if sup and apply_info.SUid != sup.SUid:
raise ParamsError('只能删除自己提交的申请')
if apply_info.GPstatus not in [ApplyStatus.cancle.value, ApplyStatus.reject.value,
ApplyStatus.shelves.value]:
raise StatusError('只能删除已下架、已拒绝、已撤销状态下的申请')
apply_info.isdelete = True
GroupGoodsSku.query.filter(GroupGoodsSku.GPid == apply_info.GPid).delete_()
if is_admin():
BASEADMIN().create_action(AdminActionS.delete.value, 'GroupGoodsProduct', apply_info.GPid)
return Success('删除成功', {'gpid': gpid})
def cancel_apply(self):
"""取消申请"""
if is_supplizer():
sup = Supplizer.query.filter_by_(SUid=request.user.id).first_("账号状态错误")
else:
raise AuthorityError()
data = parameter_required(('gpid',))
with db.auto_commit():
gp = GroupGoodsProduct.query.filter(GroupGoodsProduct.GPid == data.get('gpid'),
GroupGoodsProduct.isdelete == False,
GroupGoodsProduct.GPstatus == ApplyStatus.wait_check.value
).first_("只有待审核状态下的申请可以撤销")
if gp.SUid != sup.SUid:
raise AuthorityError("只能撤销属于自己的申请")
gp.update({'GPstatus': ApplyStatus.cancle.value})
db.session.add(gp)
# 返回库存
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)
# 同时取消正在进行的审批流
Approval.query.filter_by(AVcontent=gp.GPid, AVstartid=sup.SUid,
isdelete=False, AVstatus=ApplyStatus.wait_check.value
).update({'AVstatus': ApplyStatus.cancle.value})
return Success('已取消申请', {'gpid': gp.GPid})
def get_platform_message(self):
data = parameter_required()
filter_args = {PlatformMessage.isdelete == False}
if common_user():
filter_args.add(
PlatformMessage.PMstatus == PlanetMessageStatus.publish.value)
if is_supplizer():
filter_args.add(PlatformMessage.PMcreate == request.user.id)
if data.get('PMstatus', None) is not None:
filter_args.add(PlatformMessage.PMstatus == data.get('pmstatus'))
pm_list = PlatformMessage.query.filter(*filter_args).order_by(
PlatformMessage.createtime.desc()).all_with_page()
for pm in pm_list:
self._fill_pm(pm)
if common_user():
self._fill_um(pm, request.user.id)
else:
um_read_count = UserPlatfromMessage.query.filter(
UserPlatfromMessage.isdelete == False,
UserPlatfromMessage.PMid == pm.PMid,
UserPlatfromMessage.UPMstatus ==
UserPlanetMessageStatus.read.value).count()
pm.fill('pmreadcount', um_read_count)
return Success(data=pm_list)
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
if is_admin():
BASEADMIN().create_action(AdminActionS.delete.value, 'FreshManFirstApply', fmfaid)
return Success('删除成功', {'fmfaid': fmfaid})
def resubmit_apply(self):
"""重新提交申请"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} resubmit commodity'.format(
sup.SUname))
nefrom = ApplyFrom.supplizer.value
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} resubmit commodity'.format(
admin.ADname))
nefrom = ApplyFrom.platform.value
sup = None
else:
raise AuthorityError()
data = parameter_required(('tcid', ))
tcid = data.get('tcid')
with db.auto_commit():
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('无此商品信息')
if commodity.TCstatus not in [
TrialCommodityStatus.cancel.value,
TrialCommodityStatus.reject.value
]:
raise StatusError('只有撤销或已下架状态的申请可以重新提交')
if sup:
if commodity.CreaterId != usid:
raise AuthorityError('仅可重新提交自己上传的商品')
commodity.TCstatus = TrialCommodityStatus.auditing.value
# 重新创建一个审批流
super().create_approval('totrialcommodity', usid, tcid, nefrom)
return Success('提交成功', {'tcid': tcid})
def shelves(self):
"""批量下架试用商品"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} shelves commodity'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} shelves commodity'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(("tcids", ))
tcid_list = data.get('tcids')
for tcid in tcid_list:
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('未找到商品信息, tcid参数异常')
if sup:
assert commodity.CreaterId == usid, '供应商只能下架自己上传的商品'
if commodity.TCstatus != TrialCommodityStatus.upper.value:
raise StatusError('只能下架正在上架状态的商品')
with db.auto_commit():
commodity.TCstatus = TrialCommodityStatus.reject.value
return Success('下架成功', {'tcid': tcid_list})
def shelf_award(self):
"""撤销申请"""
if not (is_supplizer() or is_admin()):
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
other_apply_info = MagicBoxApply.query.filter(
MagicBoxApply.isdelete == False,
MagicBoxApply.MBAid != mbaid,
MagicBoxApply.MBAstatus.notin_(
[ApplyStatus.cancle.value, ApplyStatus.reject.value]),
MagicBoxApply.OSid == apply_info.OSid,
).first()
current_app.logger.info("其他的同库存申请 --> {}".format(other_apply_info))
if apply_info.MBAstatus != ApplyStatus.wait_check.value:
raise StatusError('只有在审核状态的申请可以撤销')
if apply_info.SUid != request.user.id:
raise AuthorityError('仅可撤销自己提交的申请')
apply_info.MBAstatus = ApplyStatus.cancle.value
# 是否修改库存
if not other_apply_info:
out_stock = OutStock.query.filter(
OutStock.isdelete == False,
OutStock.OSid == apply_info.OSid).first()
self._update_stock(out_stock.OSnum, skuid=apply_info.SKUid)
# 同时将正在进行的审批流改为取消
approval_info = Approval.query.filter_by_(
AVcontent=mbaid,
AVstartid=request.user.id,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.AVstatus = ApplyStatus.cancle.value
return Success('取消成功', {'mbaid': mbaid})
def shelves(self):
"""下架申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info(
'Supplizer {} delete magicbox apply'.format(sup.SUname))
elif is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} magicbox apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
if sup:
assert apply_info.SUid == usid, '供应商只能下架自己的申请'
if apply_info.MBAstatus != ApplyStatus.agree.value:
raise StatusError('只能下架已通过的申请')
apply_info.MBAstatus = ApplyStatus.reject.value
return Success('下架成功', {'mbaid': mbaid})
def cancel_commodity_apply(self):
"""撤销自己的申请"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} cancel commodity'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} cancel commodity'.format(
admin.ADname))
else:
raise AuthorityError()
data = parameter_required(('tcid', ))
tcid = data.get('tcid')
with db.auto_commit():
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('无此商品信息')
if commodity.TCstatus != TrialCommodityStatus.auditing.value:
raise StatusError('只有在审核状态的申请可以撤销')
if commodity.CreaterId != request.user.id:
raise AuthorityError('仅可撤销自己提交的申请')
commodity.TCstatus = TrialCommodityStatus.cancel.value
# 同时将正在进行的审批流改为取消
approval_info = Approval.query.filter_by_(
AVcontent=tcid,
AVstartid=request.user.id,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.AVstatus = ApplyStatus.cancle.value
return Success('取消成功', {'tcid': tcid})
def set_supplizeraccount(self):
if not is_supplizer():
raise AuthorityError
from flask import request
data = request.json
# todo 数据校验
sa = SupplizerAccount.query.filter(
SupplizerAccount.SUid == request.user.id,
SupplizerAccount.isdelete == False).first()
if sa:
for key in sa.__dict__:
if str(key).lower() in data:
if str(key).lower() == 'suid':
continue
setattr(sa, key, data.get(str(key).lower()))
else:
sa_dict = {}
for key in SupplizerAccount.__dict__:
if str(key).lower() in data:
if str(key).lower() == 'suid':
continue
if not data.get(str(key).lower()):
continue
sa_dict.setdefault(key, data.get(str(key).lower()))
sa_dict.setdefault('SAid', str(uuid.uuid1()))
sa_dict.setdefault('SUid', request.user.id)
sa = SupplizerAccount.create(sa_dict)
db.session.add(sa)
return Success('设置供应商账户信息成功')
def delete_apply(self):
"""删除申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info(
'Supplizer {} delete magicbox apply'.format(sup.SUname))
elif is_admin():
usid = request.user.id
admin = Admin.query.filter_by_(ADid=usid).first_('管理员信息错误')
current_app.logger.info('Admin {} magicbox apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
if sup:
assert apply_info.SUid == usid, '供应商只能删除自己提交的申请'
if apply_info.MBAstatus not in [
ApplyStatus.cancle.value, ApplyStatus.reject.value
]:
raise StatusError('只能删除已拒绝或已撤销状态下的申请')
apply_info.isdelete = True
return Success('删除成功', {'mbaid': mbaid})
def upload_delivery_file(self):
"""
订单批量发货，文件上传入口
:return:
"""
if is_admin():
Admin.query.filter_by(ADid=request.user.id,
ADstatus=AdminStatus.normal.value,
isdelete=False).first_('管理员账号错误')
elif is_supplizer():
Supplizer.query.filter_by(SUid=request.user.id,
SUstatus=UserStatus.usual.value,
isdelete=False).first_('供应商账号状态错误')
else:
raise TokenError('未登录')
file = request.files.get('file')
if not file:
raise ParamsError('未上传文件')
current_app.logger.info('Start Add Delivery Template {}'.format(
datetime.now()))
folder = 'xls'
# 接收数据保存到服务器
file_path = self._save_excel(file, folder)
# 进行订单发货
nrows = self._order_delivery(file_path)
if is_admin():
with db.auto_commit():
BASEADMIN().create_action(AdminActionS.insert.value, 'file',
file_path)
current_app.logger.info('End Add Delivery Template {}'.format(
datetime.now()))
return Success('批量发货成功, 共发货 {} 个订单'.format(nrows - 1))
def download(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
args = parameter_required(('type', ))
type = args.get('type')
try:
tp = getattr(ExcelTemplateType, type).value
except Exception:
raise ParamsError('type 参数错误')
current_app.logger.info('start download template')
template_path = os.path.join(current_app.config['BASEDIR'], 'img',
'xls')
current_app.logger.info('template path {}'.format(template_path))
if tp:
current_app.logger.info('is file {}'.format(
os.path.isfile(
os.path.join(template_path, 'deliverytemplate.xlsx'))))
return send_from_directory(template_path,
'deliverytemplate.xlsx',
as_attachment=True)
current_app.logger.info('is file {}'.format(
os.path.isfile(os.path.join(template_path, 'template.xlsx'))))
return send_from_directory(template_path,
'template.xlsx',
as_attachment=True)
def del_commodity(self):
"""删除试用商品"""
if is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {} delete commodity'.format(
sup.SUname))
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {} delete commodity'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(("tcid", ))
tcid = data.get('tcid')
commodity = TrialCommodity.query.filter_by_(
TCid=tcid).first_('未找到商品信息, tcid参数异常')
if sup:
assert commodity.CreaterId == usid, '供应商只能删除自己上传的商品'
if commodity.TCstatus not in [
TrialCommodityStatus.reject.value,
TrialCommodityStatus.cancel.value
]:
raise StatusError('只能删除已下架或已撤销的商品')
with db.auto_commit():
TrialCommodity.query.filter_by(TCid=tcid).delete_()
TrialCommodityImage.query.filter_by(TCid=tcid).delete_()
TrialCommoditySku.query.filter_by(TCid=tcid).delete_()
TrialCommoditySkuValue.query.filter_by(TCid=tcid).delete_()
return Success('删除成功', {'tcid': tcid})
def validate_suid(self, raw):
if is_supplizer():
self.suid.data = request.user.id
else:
if not raw.data:
raise ParamsError('供应商suid不可为空')
supplizer = Supplizer.query.filter(
Supplizer.SUid == raw.data,
Supplizer.isdelete == False).first_('供应商不存在')
self.supplizer = supplizer
def list(self):
"""拼团/商品列表"""
args = request.args.to_dict()
now = datetime.datetime.now()
option = args.get('option')
gpstatus = args.get('gpstatus')
starttime, endtime = args.get('starttime', '2019-01-01') or '2019-01-01', args.get('endtime', '2100-01-01') or '2100-01-01'
if is_admin() or is_supplizer():
return self._back_group_product_list(gpstatus, starttime, endtime)
if str(option) == 'my':
my_group = []
if common_user():
my_group = self._filter_joined_group().all_with_page()
list(map(lambda x: self._fill_single_group(x), my_group))
return Success(data=my_group)
elif str(option) == 'all':
all_group = self._filter_not_joined_group().all_with_page()
list(map(lambda x: self._fill_single_group(x), all_group))
return Success(data=all_group)
my_group = []
if common_user():
my_group = self._filter_joined_group().distinct().limit(2).all()
list(map(lambda x: self._fill_single_group(x), my_group))
all_group = self._filter_not_joined_group().distinct().limit(2).all()
list(map(lambda x: self._fill_single_group(x), all_group))
group_goods = GroupGoodsProduct.query.filter(GroupGoodsProduct.isdelete == False,
GroupGoodsProduct.GPstatus == ApplyStatus.agree.value,
GroupGoodsProduct.GPday == now.date()
).order_by(GroupGoodsProduct.createtime.desc()).all_with_page()
for gp in group_goods:
gp.hide('SUid', 'PRid', 'GPfreight')
product = Products.query.filter(Products.PRid == gp.PRid, Products.isdelete == False).first()
if not product:
continue
gps_list = GroupGoodsSku.query.filter_by(GPid=gp.GPid, isdelete=False).all()
gpsku_price = [gps.SKUPrice for gps in gps_list]
gp.fill('gpstatus_en', ApplyStatus(gp.GPstatus).name)
gp.fill('gpstatus_zh', ApplyStatus(gp.GPstatus).zh_value)
gp.fill('prmainpic', product['PRmainpic'])
gp.fill('prtitle', product.PRtitle)
gp.fill('gpdeposit', max(gpsku_price))
res = {'my_group': my_group,
'all_group': all_group,
'group_goods': group_goods
}
return Success(data=res)
def list(self):
form = BrandsListForm().valid_data()
pbstatus = dict(form.pbstatus.choices).get(form.pbstatus.data)
free = dict(form.free.choices).get(form.free.data)
time_order = dict(form.time_order.choices).get(form.time_order.data)
itid = form.itid.data
itid = itid.split('|') if itid else []
kw = form.kw.data
brand_query = ProductBrand.query.filter_(
ProductBrand.isdelete == False, ProductBrand.PBstatus == pbstatus)
if itid:
brand_query = brand_query.join(
BrandWithItems,
ProductBrand.PBid == BrandWithItems.PBid).filter(
BrandWithItems.isdelete == False,
BrandWithItems.ITid.in_(itid))
if is_supplizer():
current_app.logger.info('供应商查看品牌列表..')
brand_query = brand_query.filter(
ProductBrand.SUid == request.user.id)
if free is True:
brand_query = brand_query.filter(ProductBrand.SUid.is_(None))
elif free is False:
brand_query = brand_query.filter(ProductBrand.SUid.isnot(None))
if kw:
brand_query = brand_query.filter(ProductBrand.PBname.contains(kw))
brands = brand_query.order_by(time_order).all_with_page()
for brand in brands:
brand.fill('PBstatus_en', ProductBrandStatus(brand.PBstatus).name)
brand.fill('PBstatus_zh',
ProductBrandStatus(brand.PBstatus).zh_value)
brand.add('createtime')
# 标签
print(brand.PBid)
pb_items = Items.query.filter_by().join(
BrandWithItems, Items.ITid == BrandWithItems.ITid).filter_(
BrandWithItems.PBid == brand.PBid,
BrandWithItems.isdelete == False,
).all()
brand.fill('items', pb_items)
if is_admin() or brand.SUid:
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == brand.SUid).first()
if not supplizer:
with db.auto_commit():
brand.SUid = None
db.session.add(brand)
continue
supplizer.fields = [
'SUloginPhone', 'SUlinkPhone', 'SUname', 'SUlinkman',
'SUheader'
]
brand.fill('supplizer', supplizer)
return Success(data=brands)
def shelves(self):
"""下架申请"""
if is_supplizer():
usid = request.user.id
sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误')
current_app.logger.info('Supplizer {} shelf magicbox 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 magicbox apply'.format(
admin.ADname))
sup = None
else:
raise AuthorityError()
data = parameter_required(('mbaid', ))
mbaid = data.get('mbaid')
pending_box = MagicBoxJoin.query.filter(
MagicBoxJoin.isdelete == False,
MagicBoxJoin.MBJstatus == MagicBoxJoinStatus.pending.value,
MagicBoxJoin.MBSendtime >= datetime.now().date(),
MagicBoxJoin.MBAid == mbaid).first()
if pending_box:
current_app.logger.info('仍存在未完成礼盒 MBJid: {}'.format(
pending_box.MBJid))
raise StatusError('该商品仍有正在分享中的礼盒未完成，暂不能下架')
with db.auto_commit():
apply_info = MagicBoxApply.query.filter_by_(
MBAid=mbaid).first_('无此申请记录')
if sup and apply_info.SUid != usid:
raise StatusError('只能下架自己的申请')
if apply_info.MBAstatus != ApplyStatus.agree.value:
raise StatusError('只能下架已通过的申请')
apply_info.MBAstatus = ApplyStatus.shelves.value
if is_admin():
BASEADMIN().create_action(AdminActionS.update.value,
'MagicBoxApply', mbaid)
# 返回库存
product = Products.query.filter_by(PRid=apply_info.PRid,
isdelete=False).first_('商品信息出错')
mbs_old = MagicBoxApplySku.query.filter(
MagicBoxApplySku.MBAid == apply_info.MBAid,
MagicBoxApplySku.isdelete == False,
).all()
for sku in mbs_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)
return Success('下架成功', {'mbaid': mbaid})
def download(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
current_app.logger.info('start download template')
template_path = os.path.join(current_app.config['BASEDIR'], 'img',
'xls')
current_app.logger.info('template path {}'.format(template_path))
current_app.logger.info('is file {}'.format(
os.path.isfile(os.path.join(template_path, 'template.xlsx'))))
return send_from_directory(template_path,
'template.xlsx',
as_attachment=True)
def list(self):
"""商品列表"""
args = parameter_required()
prtitle = args.get('prtitle')
ipstatus = args.get('status')
try:
ipstatus = getattr(ApplyStatus, ipstatus).value
except Exception as e:
current_app.logger.error(
'integral list status error : {}'.format(e))
ipstatus = None
integral_balance = 0
if common_user():
ipstatus = ApplyStatus.agree.value
user = User.query.filter_by_(USid=request.user.id).first()
integral_balance = getattr(user, 'USintegral', 0)
elif is_tourist():
ipstatus = ApplyStatus.agree.value
filter_args = [
IntegralProduct.isdelete == False,
IntegralProduct.IPstatus == ipstatus, Products.isdelete == False,
Products.PRstatus == ProductStatus.usual.value
]
if is_supplizer():
filter_args.append(Products.CreaterId == request.user.id),
if prtitle:
filter_args.append(Products.PRtitle.ilike('%{}%'.format(prtitle)))
ips = IntegralProduct.query.outerjoin(
Products, Products.PRid == IntegralProduct.PRid).filter_(
*filter_args).order_by(
IntegralProduct.createtime.desc()).all_with_page()
for ip in ips:
pr = Products.query.filter(Products.PRid == ip.PRid).first()
pb = ProductBrand.query.filter(
ProductBrand.PBid == pr.PBid).first()
ip.fill('prtitle', pr.PRtitle)
ip.fill('prmainpic', pr['PRmainpic'])
ip.fill('ipstatus_zh', ApplyStatus(ip.IPstatus).zh_value)
ip.fill('ipstatus_en', ApplyStatus(ip.IPstatus).name)
ip.fill('pbname', pb.PBname)
res = dict(product=ips)
if common_user() or is_tourist():
cfg = ConfigSettings()
rule = cfg.get_item('integralrule', 'rule')
integral = dict(balance=integral_balance, rule=rule)
res['integral'] = integral
return Success(data=res)
def set_banner(self):
data = parameter_required({'pbid': '品牌唯一值缺失'})
pbid = data.get('pbid')
if is_supplizer():
supplizer = get_current_supplizer()
ProductBrand.query.filter(
ProductBrand.PBid == pbid, ProductBrand.SUid == supplizer.SUid).first_('只能修改自己的品牌')
elif is_admin():
ProductBrand.query.filter(
ProductBrand.PBid == pbid).first_('品牌不存在')
else:
raise AuthorityError()
bbid = data.get('bbid')
bbcontent = data.get('bbcontent')
if bbcontent:
try:
bbcontent = json.dumps(bbcontent)
except Exception as e:
current_app.logger.info('转置json 出错 bbcontent = {} e = {}'.format(bbcontent, e))
bbsort = data.get('bbsort')
if bbsort:
bbsort = self._check_sort(bbsort, model=BrandBanner, filter_args=[BrandBanner.PBid == pbid], default=1)
with db.auto_commit():
if bbid:
if data.get('delete'):
BrandBanner.query.filter(BrandBanner.BBid == bbid, BrandBanner.isdelete == false()).delete_(
synchronize_session=False)
return Success('删除成功')
bb = BrandBanner.query.filter(BrandBanner.BBid == bbid, BrandBanner.isdelete == false()).first()
if bb:
if bbsort:
bb.BBsort = bbsort
if bbcontent:
bb.BBcontent = bbcontent
return Success('更新成功', data=bbid)
bbid = str(uuid.uuid1())
if not bbcontent:
raise ParamsError('轮播图图片路由缺失')
bb = BrandBanner.create({
'BBid': bbid,
'PBid': pbid,
'BBsort': bbsort or 1,
'BBcontent': bbcontent
})
db.session.add(bb)
return Success('添加成功', data=bbid)
def del_news(self):
"""删除资讯"""
if is_tourist():
raise TokenError()
elif is_admin():
usid = request.user.id
admin = self._check_admin(usid)
current_app.logger.info('Admin {0} deleted a news'.format(
admin.ADname))
elif is_supplizer():
usid = request.user.id
sup = self._check_supplizer(usid)
current_app.logger.info('Supplizer {0} deleted a news'.format(
sup.SUname))
else:
usid = request.user.id
user = self.snews.get_user_by_id(usid)
current_app.logger.info('User {0} deleted a news'.format(
user.USname))
data = parameter_required(('neid', ))
neids = data.get('neid')
with db.auto_commit():
for neid in neids:
news = News.query.filter_by_(NEid=neid).first_('未找到该资讯或已被删除')
if is_admin():
if news.NEstatus != NewsStatus.refuse.value:
raise StatusError('只能删除已下架状态的资讯')
else:
if news.USid != usid:
raise StatusError('只能删除自己发布的资讯')
News.query.filter_by(NEid=neid, isdelete=False).delete_()
NewsTag.query.filter_by(NEid=neid).delete_() # 删除标签关联
NewsComment.query.filter_by(NEid=neid).delete_() # 删除评论
NewsFavorite.query.filter_by(NEid=neid).delete_() # 删除点赞
NewsTrample.query.filter_by(NEid=neid).delete_() # 删除点踩
# 如果在审核中，同时取消在进行的审批流
try:
if news.NEstatus == NewsStatus.auditing.value:
approval_info = Approval.query.filter_by_(
AVcontent=neid,
AVstartid=news.USid,
AVstatus=ApplyStatus.wait_check.value).first()
approval_info.update(
{'AVstatus': ApplyStatus.cancle.value})
db.session.add(approval_info)
except Exception as e:
current_app.logger.error('删除圈子相关审批流时出错: {}'.format(e))
return Success('删除成功', {'neid': neids})
def _coupon(self, coupon, **kwargs):
items = Items.query.join(CouponItem,
CouponItem.ITid == Items.ITid).filter(
CouponItem.COid == coupon.COid).all()
if not is_admin() and not is_supplizer():
coupon.COcanCollect = self._can_collect(coupon)
# 优惠券使用对象
coupon.fill('items', items)
coupon.fill('title_subtitle', self._title_subtitle(coupon))
usid = kwargs.get('usid')
if usid:
coupon_user = CouponUser.query.filter_by({
'USid': usid,
'COid': coupon.COid
}).first()
coupon.fill('ready_collected', bool(coupon_user))
def get(self):
if not is_admin() and not is_supplizer():
raise AuthorityError()
form = SupplizerGetForm().valid_data()
supplizer = form.supplizer
self._fill_supplizer(supplizer)
pbs = ProductBrand.query.filter(
ProductBrand.isdelete == False,
ProductBrand.SUid == supplizer.SUid).all()
for pb in pbs:
if pb:
pb.pbstatus_zh = ProductBrandStatus(pb.PBstatus).zh_value
pb.add('pbstatus_zh')
supplizer.fill('pbs', pbs)
supplizer.fill('SUbaseRate', supplizer.SUbaseRate or 0)
return Success(data=supplizer)
def get_system_notes(self):
if is_supplizer():
mn_list = ManagerSystemNotes.query.filter(
ManagerSystemNotes.MNstatus == NotesStatus.publish.value)
elif is_admin():
mn_list = ManagerSystemNotes.query.filter(
ManagerSystemNotes.isdelete == False)
else:
raise AuthorityError
mn_list = mn_list.order_by(ManagerSystemNotes.createtime.desc()).all()
for mn in mn_list:
mn.fill('mnstatus_zh', NotesStatus(mn.MNstatus).zh_value)
mn.fill('mnstatus', NotesStatus(mn.MNstatus).name)
return Success('获取通告成功', data=mn_list)
