def check_qualification(self, opid=None, omid=None): if omid: om = OrderMain.query.filter(OrderMain.OMid == omid, OrderMain.isdelete == False).first() if not om: raise ParamsError('订单已删除') if om.OMinRefund == False: raise ParamsError('请对已发起售后的商品订单发起仲裁') ora = OrderRefundApply.query.filter( OrderRefundApply.isdelete == False, OrderRefundApply.OMid == omid, OrderRefundApply.ORAstatus == ApplyStatus.reject.value).first() if not ora: raise StatusError('该售后处理中,请等待处理结果') if opid: op = OrderPart.query.filter(OrderPart.OPid == opid, OrderPart.isdelete == False).first() if not op: raise ParamsError('副单已删除') if op.OPisinORA == False: raise StatusError('请对已发起售后的订单发起仲裁') ora = OrderRefundApply.query.filter( OrderRefundApply.OPid == opid, OrderRefundApply.isdelete == False, OrderRefundApply.ORAstatus == ApplyStatus.reject.value).first() if not ora: raise StatusError('该订单售后处理中,请等待处理结果')
def send(self): """发货""" data = parameter_required(('omid', 'olcompany', 'olexpressno')) omid = data.get('omid') olcompany = data.get('olcompany') olexpressno = data.get('olexpressno') with self.strade.auto_commit() as s: s_list = [] order_main_instance = s.query(OrderMain).filter_by_({ 'OMid': omid, }).first_('订单不存在') if order_main_instance.OMfrom == OrderFrom.guess_group.value: guess_group = GuessGroup.query.outerjoin( OrderPart, OrderPart.PRid == GuessGroup.GPid ).outerjoin(OrderMain, OrderMain.OMid == OrderPart.OMid ).filter(OrderMain.isdelete == False, OrderMain.OMstatus == OrderMainStatus.wait_send.value, OrderPart.OMid == order_main_instance.OMid, ).first() if not guess_group or (guess_group.GGstatus != GuessGroupStatus.completed.value): raise StatusError('该拼团订单尚未完成, 不能提前发货') # if order_main_instance.OMstatus != OrderMainStatus.wait_send.value: # raise StatusError('订单状态不正确') if order_main_instance.OMinRefund is True: raise StatusError('商品在售后状态') s.query(LogisticsCompnay).filter_by_({ 'LCcode': olcompany }).first_('快递公司不存在') # 之前物流记录判断 order_logistics_instance_old = OrderLogistics.query.filter( OrderLogistics.OMid == omid, OrderLogistics.isdelete == False, ).first() if order_logistics_instance_old: order_logistics_instance_old.isdelete = True # 添加物流记录 order_logistics_instance = OrderLogistics.create({ 'OLid': str(uuid.uuid1()), 'OMid': omid, 'OLcompany': olcompany, 'OLexpressNo': olexpressno, }) s_list.append(order_logistics_instance) # 更改主单状态 order_main_instance.OMstatus = OrderMainStatus.wait_recv.value s_list.append(order_main_instance) s.add_all(s_list) return Success('发货成功')
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 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 create_code(self): data = parameter_required(('coid', 'conum')) coid = data.get('coid') conum = data.get('conum') with db.auto_commit(): coupon = Coupon.query.filter_by(COid=coid, isdelete=False, COcode=1).first_('该优惠券不能生成兑换码') # 校验剩余数量 if coupon.COlimitNum: if int(coupon.COremainNum) < int(conum): raise StatusError('兑换数量超过剩余数量') coupon.update( {'COremainNum': int(coupon.COremainNum) - int(conum)}) # isinstance_list = [coupon] db.session.add(coupon) for _ in range(int(data.get('conum'))): ccid = str(uuid.uuid1()) cccode = self.coupen_code() coupon_code = CouponCode.create({ 'CCid': ccid, 'COid': coid, 'CCcode': cccode }) db.session.add(coupon_code) BASEADMIN().create_action(AdminActionS.insert.value, 'CouponCode', coid) db.session.flush() return Success('生成激活码成功', data={'coid': coid, 'conum': conum})
def get(self): """商品详情""" args = request.args.to_dict() gpid, ggid, gg = args.get('gpid'), args.get('ggid'), None if not gpid and not ggid: raise ParamsError('gpid | ggid 至少需要其一') if ggid: gg = GuessGroup.query.filter(GuessGroup.isdelete == False, GuessGroup.GGid == ggid, # GuessGroup.GGendtime >= datetime.datetime.now() ).first_('该拼团已结束') gpid = gg.GPid agree_status = GroupGoodsProduct.GPstatus == ApplyStatus.agree.value filter_args = [GroupGoodsProduct.isdelete == False, GroupGoodsProduct.GPid == gpid] if common_user() or is_tourist(): filter_args.append(agree_status) try: if gg and gg.GGstatus == GuessGroupStatus.completed.value and agree_status in filter_args: filter_args.remove(agree_status) gp = GroupGoodsProduct.query.filter(*filter_args).first_() product = self._fill_gp(gp, gg) except Exception as e : current_app.logger.error('The error is {}'.format(e)) raise StatusError("该拼团活动已结束") return Success('获取成功', data=product)
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 _pay_to_bankcard(self, cn): """ 付款到银行卡号 :param cn: :return: """ try: enc_bank_no = self._to_encrypt(cn.CNcardNo) enc_true_name = self._to_encrypt(cn.CNcardName) bank_code = WexinBankCode(cn.CNbankName).zh_value except Exception as e: current_app.logger.error('提现到银行卡,参数加密出错:{}'.format(e)) raise ParamsError('服务器繁忙,请稍后再试') try: result = self.wx_pay.pay_individual_to_card( partner_trade_no=self.wx_pay.nonce_str, enc_bank_no=enc_bank_no, enc_true_name=enc_true_name, bank_code=bank_code, amount=int( Decimal(cn.CNcashNum).quantize(Decimal('0.00')) * 100)) current_app.logger.info('微信提现到银行卡, response: {}'.format(request)) except Exception as e: current_app.logger.error('微信提现返回错误:{}'.format(e)) raise StatusError('微信商户平台: {}'.format(e)) return result
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 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 = 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 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 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 set_award(self): """设置中奖""" data = parameter_required('tsoid') tsoid = data.get('tsoid') ticket_order = TicketsOrder.query.filter(TicketsOrder.isdelete == false(), TicketsOrder.TSOid == tsoid, TicketsOrder.TSOstatus == TicketsOrderStatus.pending.value ).first_('状态错误') ticket = Ticket.query.filter(Ticket.isdelete == false(), Ticket.TIid == ticket_order.TIid).first() if not ticket or ticket.TIstatus != TicketStatus.over.value: raise ParamsError('抢票尚未结束') award_num = self._query_award_num(ticket.TIid) current_app.logger.info('已中奖数:{} / {}'.format(award_num, ticket.TInum)) if award_num >= ticket.TInum: raise StatusError('已达最大发放票数') with db.auto_commit(): update_dict = {'TSOqrcode': 'https://play.bigxingxing.com/img/qrcode/2019/9/3/QRCODE.png', 'TSOstatus': TicketsOrderStatus.has_won.value} if ticket.TIdeposit == ticket.TIprice: # 第二次支付押金0元的情况 update_dict['TSOstatus'] = TicketsOrderStatus.completed.value ticket_order.update(update_dict) db.session.add(ticket_order) db.session.flush() awarded_num = self._query_award_num(ticket.TIid) current_app.logger.info('设置后中奖数:{} / {}'.format(awarded_num, ticket.TInum)) if awarded_num == ticket.TInum: # 未中奖退钱 other_to = self._query_not_won(ticket.TIid) total_row_count = 0 for oto in other_to: row_count = self._deposit_refund(oto) total_row_count += row_count current_app.logger.info('共{}条未中奖'.format(total_row_count)) return Success('设置成功', data=tsoid)
def send(self): """买家发货""" form = RefundSendForm().valid_data() oraid = form.oraid.data orlogisticcompany = form.orlogisticcompany.data orlogisticsn = form.orlogisticsn.data with self.strade.auto_commit() as s: # 判断 s.query(LogisticsCompnay).filter_by_({ 'LCcode': orlogisticcompany }).first_('物流公司不存在') order_refund_instance = s.query(OrderRefund).filter_by_({ 'ORAid': oraid }).first_('申请未同意或不存在') if order_refund_instance.ORstatus > OrderRefundOrstatus.wait_send.value: raise StatusError('重复发货') # 写入退货表 order_refund_instance.update({ 'ORlogisticCompany': orlogisticcompany, 'ORlogisticsn': orlogisticsn, 'ORstatus': OrderRefundOrstatus.wait_recv.value, }) s.add(order_refund_instance) return Success('发货成功')
def delete(self): """删除""" data = parameter_required(('suid', )) suid = data.get('suid') with db.auto_commit(): supplizer = Supplizer.query.filter( Supplizer.isdelete == False, Supplizer.SUid == suid).first_('供应商不存在') if self._check_lasting_order(suid=suid): raise StatusError('供应商部分订单正在进行') supplizer.isdelete = True db.session.add(supplizer) BASEADMIN().create_action(AdminActionS.delete.value, 'Supplizer', suid) # 品牌删除 productbrands = ProductBrand.query.filter( ProductBrand.isdelete == False, ProductBrand.SUid == suid).all() current_app.logger.info('删除供应商{}'.format(supplizer.SUname)) for pb in productbrands: pb.isdelete = True db.session.add(pb) # 商品删除 delete_product = Products.query.filter( Products.isdelete == False, Products.PBid == pb.PBid).update( {'PRstatus': ProductStatus.off_shelves.value}) return Success('删除成功')
def delete(self): """删除申请""" # if is_supplizer(): # usid = request.user.id # sup = Supplizer.query.filter_by_(SUid=usid).first_('供应商信息错误') # suid = sup.SUid # current_app.logger.info('Supplizer {} delete 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 {} delete integral apply'.format( admin.ADname)) sup = None suid = None else: raise AuthorityError() data = parameter_required(('ipid', )) ipid = data.get('ipid') with db.auto_commit(): apply_info = IntegralProduct.query.filter_by( IPid=ipid, isdelete=False).first_('没有该商品记录') if sup and apply_info.SUid != suid: raise ParamsError('只能删除自己提交的申请') if apply_info.IPstatus not in [ ApplyStatus.cancle.value, ApplyStatus.reject.value, ApplyStatus.shelves.value ]: raise StatusError('只能删除已下架或已撤销状态下的申请') apply_info.isdelete = True IntegralProductSku.query.filter( IntegralProductSku.IPid == apply_info.IPid).delete_() if is_admin(): BASEADMIN().create_action(AdminActionS.delete.value, 'IntegralProduct', apply_info.IPid) return Success('删除成功', {'ipid': ipid})
def create_comment(self): usid = request.user.id user = self.snews.get_user_by_id(usid) usname, usheader = user.USname, user.USheader current_app.logger.info('User {0} created a news commentary'.format( user.USname)) data = parameter_required(('neid', 'nctext')) neid = data.get('neid') new_info = self.snews.get_news_content({ 'NEid': neid, 'isdelete': False }) if new_info.NEstatus != NewsStatus.usual.value: raise StatusError('该资讯当前状态不允许进行评论') ncid = data.get('ncid') comment_ncid = str(uuid.uuid1()) reply_ncid = str(uuid.uuid1()) # 直接评论资讯 if ncid in self.empty: with self.snews.auto_commit() as nc: comment = NewsComment.create({ 'NCid': comment_ncid, 'NEid': neid, 'USid': usid, 'USname': usname, 'USheader': usheader, 'NCtext': data.get('nctext'), }) nc.add(comment) # 评论后返回刷新结果 news_comment = NewsComment.query.filter_by_( NCid=comment_ncid).first() self._get_one_comment(news_comment, neid, usid) else: # 回复资讯评论 ori_news_comment = NewsComment.query.filter( NewsComment.NCid == ncid, NewsComment.isdelete == False).first() if not ori_news_comment: raise NotFound('该评论已删除') ncrootid = ori_news_comment.NCrootid if not ncrootid: ncrootid = ncid with self.snews.auto_commit() as r: reply = NewsComment.create({ 'NCid': reply_ncid, 'NEid': neid, 'USid': usid, 'USname': usname, 'USheader': usheader, 'NCtext': data.get('nctext'), 'NCparentid': ncid, 'NCrootid': ncrootid, }) r.add(reply) # 评论后返回刷新结果 news_comment = NewsComment.query.filter_by_(NCid=ncrootid).first() self._get_one_comment(news_comment, neid, usid) return Success('评论成功', data=news_comment)
def code(self): """兑换码领优惠劵""" usid = request.user.id data = parameter_required(('cccode', )) CCcode = data.get('cccode') with self.strade.auto_commit() as s: s_list = [] couponcode = s.query(CouponCode).filter_by_({ 'CCcode': CCcode }).first_('兑换码不存在') if couponcode.CCused: raise ParamsError('兑换码已被使用') coid = couponcode.COid coupon = s.query(Coupon).filter_by_({'COid': coid}).first_() # 优惠券状态是否可领取 coupon_user_count = s.query(CouponUser).filter_by_({ 'COid': coid, 'USid': usid }).count() # 领取过多 if coupon.COcollectNum and coupon_user_count >= coupon.COcollectNum: raise StatusError('已经领取过') # 发放完毕或抢空 # 2019-4-27 兑换码创建时保证库存 # if coupon.COlimitNum: # # 共领取的数量 # if not coupon.COremainNum: # raise StatusError('已发放完毕') # coupon.COremainNum = coupon.COremainNum - 1 # 剩余数量减1 # s_list.append(coupon) if coupon.COsendStarttime and coupon.COsendStarttime > datetime.now( ): raise StatusError('未开抢') if coupon.COsendEndtime and coupon.COsendEndtime < datetime.now(): raise StatusError('来晚了') # 写入couponuser coupon_user_dict = { 'UCid': str(uuid.uuid4()), 'COid': coid, 'USid': usid, } coupon_user_instance = CouponUser.create(coupon_user_dict) # 优惠券减1 s_list.append(coupon_user_instance) s.add_all(s_list) return Success('领取成功')
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 fetch(self): """领取优惠券""" form = CouponFetchForm().valid_data() coid = form.coid.data usid = request.user.id with self.strade.auto_commit() as s: s_list = [] # 优惠券状态是否可领取 coupon = s.query(Coupon).filter_by_({ 'COid': coid, 'COcanCollect': True }).first_('优惠券不存在或不可领取') coupon_user_count = s.query(CouponUser).filter_by_({ 'COid': coid, 'USid': usid }).count() # 领取过多 if coupon.COcollectNum and coupon_user_count > coupon.COcollectNum: raise StatusError('已经领取过') # 发放完毕或抢空 if coupon.COlimitNum: # 共领取的数量 if not coupon.COremainNum: raise StatusError('已发放完毕') coupon.COremainNum = coupon.COremainNum - 1 # 剩余数量减1 s_list.append(coupon) if coupon.COsendStarttime and coupon.COsendStarttime > datetime.now( ): raise StatusError('未开抢') if coupon.COsendEndtime and coupon.COsendEndtime < datetime.now(): raise StatusError('来晚了') # 写入couponuser coupon_user_dict = { 'UCid': str(uuid.uuid4()), 'COid': coid, 'USid': usid, } coupon_user_instance = CouponUser.create(coupon_user_dict) # 优惠券减1 s_list.append(coupon_user_instance) s.add_all(s_list) return Success('领取成功')
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 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 _patch_ticket_order(self, tsoid, user, opayno, instance_list, tscode_list): tso = TicketsOrder.query.filter(TicketsOrder.isdelete == false(), TicketsOrder.TSOid == tsoid, TicketsOrder.USid == user.USid).first_('未找到该信息') if tso.TSOstatus != TicketsOrderStatus.has_won.value: raise StatusError('支付条件未满足') ticket = Ticket.query.filter(Ticket.isdelete == false(), Ticket.TIid == tso.TIid ).first_('未找到该门票信息') mount_price = ticket.TIprice - ticket.TIdeposit ticket_deposit = self._creat_ticket_deposit(tsoid, TicketDepositType.patch.value, mount_price, opayno) instance_list.append(ticket_deposit) tscode_list.append(tso.TSOcode) return ticket, mount_price, instance_list, tscode_list
def update(self): """修改标签""" form = ItemUpdateForm().valid_data() psid = form.psid.data itid = form.itid.data itname = form.itname # 这里不要在后面加data isdelete = form.isdelete.data if itid in ['planet_featured', 'index_hot', 'news_bind_product', 'news_bind_coupon', 'index_brand', 'index_brand_product', 'index_recommend_product_for_you', 'upgrade_product', 'mynews' ] and isdelete is True: raise StatusError('系统默认标签不能被删除') Items.query.filter_by_(ITid=itid).first_("未找到该标签") if not isdelete and Items.query.filter(Items.ITid != itid, Items.ITname == itname, Items.ITtype == form.ittype.data, Items.isdelete == False).first(): raise DumpliError("您输入的标签名已存在") with db.auto_commit(): itsort = self._check_itsort(form.itsort.data, form.ittype.data) item_dict = {'ITname': itname, 'ITsort': itsort, 'ITdesc': form.itdesc.data, 'ITtype': form.ittype.data, 'ITrecommend': form.itrecommend.data, 'isdelete': isdelete } # item_dict = {k: v for k, v in item_dict.items() if v is not None} Items.query.filter_by_(ITid=itid).update(item_dict) BASEADMIN().create_action(AdminActionS.update.value, 'Items', itid) # 标签场景标签表 if psid: old_psids = list() scene_items = SceneItem.query.filter_by_(ITid=itid).all() [old_psids.append(scene_item.PSid) for scene_item in scene_items] # 获取已存在的关联psid for psi in psid: ProductScene.query.filter_by_({'PSid': psi}).first_('不存在的场景') if psi not in old_psids: scene_item_dict = { 'PSid': psi, 'ITid': itid, 'SIid': str(uuid.uuid1()) } scene_item_instance = SceneItem.create(scene_item_dict) db.session.add(scene_item_instance) BASEADMIN().create_action(AdminActionS.insert.value, 'SceneItem', psi) else: old_psids.remove(psi) [SceneItem.query.filter_by(PSid=droped_psid, ITid=itid).delete_() for droped_psid in old_psids] else: SceneItem.query.filter_by(ITid=itid).delete_() # psid = [] 为空时,删除所有该标签场景的关联 BASEADMIN().create_action(AdminActionS.delete.value, 'SceneItem', itid) return Success('修改成功', {'itid': itid})
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 _pay_to_user(self, cn): """ 付款到用户微信零钱 :return: """ user = User.query.filter_by_(USid=cn.USid).first_("提现用户状态异常,请检查后重试") try: result = self.wx_pay.pay_individual( partner_trade_no=self.wx_pay.nonce_str, openid=user.USopenid2, amount=int( Decimal(cn.CNcashNum).quantize(Decimal('0.00')) * 100), desc="大行星零钱转出", spbill_create_ip=self.wx_pay.remote_addr) current_app.logger.info('微信提现到零钱, response: {}'.format(request)) except Exception as e: current_app.logger.error('微信提现返回错误:{}'.format(e)) raise StatusError('微信商户平台: {}'.format(e)) return result
def _deposit_refund(self, to_info): usid, tiid, tsoids = to_info tsoids = tsoids.split(',') current_app.logger.info('deposit refund, TSOids:{}'.format(tsoids)) td_info = db.session.query(TicketDeposit.OPayno, func.sum(TicketDeposit.TDdeposit) ).filter(TicketDeposit.isdelete == false(), TicketDeposit.TSOid.in_(tsoids)).group_by(TicketDeposit.OPayno).all() current_app.logger.info('td_info:{}'.format(td_info)) for td in td_info: opayno, return_price = td current_app.logger.info('found refund opayno: {}, mount:{}'.format(opayno, return_price)) mount_price = db.session.query(func.sum(TicketDeposit.TDdeposit)).filter( TicketDeposit.isdelete == false(), TicketDeposit.OPayno == opayno).scalar() current_app.logger.info('refund mount: {}; total deposit:{}'.format(return_price, mount_price)) current_app.logger.info('refund usid: {}'.format(usid)) if API_HOST != 'https://www.bigxingxing.com': mount_price = 0.01 return_price = 0.01 trr = TicketRefundRecord.create({'TRRid': str(uuid.uuid1()), 'USid': usid, 'TRRredund': return_price, 'TRRtotal': mount_price, 'OPayno': opayno}) db.session.add(trr) try: super(CTicket, self)._refund_to_user( out_trade_no=opayno, out_request_no=trr.TRRid, mount=return_price, old_total_fee=mount_price ) except Exception as e: raise StatusError('微信商户平台:{}'.format(e)) row_count = TicketsOrder.query.filter(TicketsOrder.isdelete == false(), TicketsOrder.TSOid.in_(tsoids) ).update({'TSOstatus': TicketsOrderStatus.not_won.value}, synchronize_session=False) current_app.logger.info('change status to not won, count: {}'.format(row_count)) return row_count
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})