Example #1
0
    def get(self):
        caller = self.get_argument('caller').encode('utf-8')
        coupon_sn = self.get_argument('coupon').encode('utf-8')
        sign = self.get_argument('sign').encode('utf-8')
        timestamp = self.get_argument('timestamp').encode('utf-8')
        logging.info('telephone verify. caller: %s, coupon_sn: %s, sign: %s, timestamp: %s',
                     caller, coupon_sn, sign, timestamp)

        if not caller:
            logging.error('telephone verify failed: empty caller.')
            self.write('1|主叫号码无效')
            return
        if not coupon_sn:
            logging.error('telephone verify failed: empty coupon.')
            self.write('2|券号为空')
            return
        if not sign:
            logging.error('telephone verify failed: empty sign.')
            self.write('3|签名无效')
            return
        if not timestamp:
            logging.error('telephone verify failed: empty timestamp.')
            self.write('3|时间戳无效')
            return

        if abs(int(time.time()) - int(timestamp)) > 300:
            logging.error('telephone verify failed: request timeout.')
            self.write('3|请求超时')
            return
        # 暂不检查签名
        # todo

        # 查找电话
        supplier_shop = self.db.get('select * from supplier_shop where deleted=0 and verify_phones like %s', '%'+caller+'%')
        #if not supplier_shop:
        #    #部分商家使用分机,出口线很多,不能一一录入,这里可以使用电话号码的前面一部分进行识别。
        #    #尝试模糊查找验证电话机
        #    supplier_user_list = self.db.query('select * from supplier_user where type="ANDROID"')
        #    for su in supplier_user_list:
        #        if caller.startswith(su.loginname):
        #            supplier_shop = su
        #            break
        if not supplier_shop:
            logging.error('telehphone verify failed. can not found valid supplier_user %s.', caller)
            self.write('1|您的电话还未绑定')
            return

        coupon = self.db.get('select id, sn, mobile from item_coupon where sn=%s', coupon_sn)
        if not coupon:
            if len(coupon_sn) == 9:
                for i in range(10):
                    coupon = self.db.get('select id, sn, mobile from item_coupon where sn=%s', '%s%s' % (i, coupon_sn))

        if coupon:
            #我们自己的券
            check_result = local_check(self.db, coupon.sn, supplier_shop.id)
            if not check_result.ok:
                ok, msg = (False, check_result.msg)
            else:
                #  合作伙伴API验证
                api_result = yield partner_api_verify(self.db, coupon.sn)
                if not api_result.ok:
                    ok, msg = (False, api_result.msg)
                else:
                    #  本地验证
                    verify_result = local_verify(self.db, coupon.sn, supplier_shop.id, '电话验证')
                    if verify_result.ok:
                        ok, msg = (True, verify_result.msg)
                    else:
                        ok, msg = (False, verify_result.msg)
        else:
            results = yield partner_browser_verify(self.db, [coupon_sn], supplier_shop.id)
            # 记录外部订单
            for result in results:
                if result.ok:
                    goods_info = self.db.get('select g.* from goods g where id=%s', result.goods_id)
                    verify_infos = {'goods_id': result.goods_id, 'shop_id': supplier_shop.id}
                    #创建分销订单
                    distributor_order_id = self.db.execute(
                        'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                        'values (%s, %s, %s, NOW())', result.coupon_sn, json_dumps(verify_infos),
                        result.distributor_shop_id)
                    order_id, order_no = new_distributor_order(self.db, result.distributor_shop_id,
                                                               goods_info.sales_price, goods_info.sales_price, '')
                    #记录订单信息
                    new_order = new_distributor_item(
                        db=self.db,
                        order_id=order_id,
                        order_no=order_no,
                        sales_price=None,
                        count=1,
                        goods_info=goods_info,
                        mobile='',
                        distributor_shop_id=result.distributor_shop_id,
                        distributor_goods_id='',
                        distributor_coupons=[{'coupon_sn': result.coupon_sn, 'coupon_pwd': result.coupon_pwd or ''}],
                        use_distributor_coupon=True
                    )
                    if new_order.ok:
                        #更新分销订单id
                        self.db.execute('update orders set distributor_order_id=%s where id = %s',
                                        distributor_order_id, order_id)
                        #更新订单id
                        self.db.execute('update distributor_order set order_id=%s where id=%s',
                                        order_id, distributor_order_id)
                        #更新该券验证的门店
                        self.db.execute('update item set sp_shop_id = %s where order_id=%s', supplier_shop.id, order_id)
                        self.redis.lpush(options.queue_coupon_local_verify, json_dumps({'coupon': result.coupon_sn,
                                                                                        'shop_id': supplier_shop.id,
                                                                                        'retry': 0,
                                                                                        'used_at': datetime.now()}))
            ok, msg = (results[0].ok, results[0].msg)

        if not ok:
            logging.error('telephone verify failed. %s', msg)
            self.write('2|验证失败')
        else:
            logging.info('telephone verify ok. caller: %s, coupon_sn: %s, sign: %s, timestamp: %s',
                         caller, coupon_sn, sign, timestamp)

            # 发送验证确认短信
            CouponConsumedMessage(self.redis, [coupon.sn], supplier_shop.name, coupon.mobile).send()

            if coupon:
                face_value = self.db.get('select face_value from item i, item_coupon c where i.id=c.item_id '
                                         'and c.id=%s', coupon.id).face_value
                self.write('0|券尾号%s验证成功,面值%s' % (coupon_sn[-4:], upper(face_value).encode('utf-8')))
            else:
                self.write('0|券尾号%s验证成功' % coupon_sn[-4:])
Example #2
0
    def post(self):
        """ 开始导入"""
        if not self.request.files:
            self.render('real/import_outer_order.html', message=u'请选择文件')

        #读取文件
        order_file = self.request.files['order_file'][0]
        book = xlrd.open_workbook(file_contents=order_file['body'])
        try:
            sheet = book.sheet_by_index(0)
        except:
            self.render('real/import_outer_order.html', message=u'文件格式错误,请检查')
            return
        partner = self.get_argument('partner').lower()
        distributor_shop_id = {
            'dp': 40,
            'mt': 44,
            'ls': '45',
            'nm': 42,
            'ww': 37
        }.get(partner)
        #读取工作表的所有行数据内容
        rows = [sheet.row_values(i) for i in range(1, sheet.nrows)]
        #转换数据
        col_names = ('coupon_sn', 'goods_id')
        coupon_list = [
            dict([(col_names[i], row[i]) for i in range(len(col_names))])
            for row in rows
        ]
        existed_orders = []
        need_convert_orders = []
        goods_id = -1
        for order in coupon_list:
            current_goods_id = order['goods_id']
            if goods_id != current_goods_id:
                goods_id = current_goods_id
                goods_info = self.db.get(
                    'select g.* ,ss.id shop_id from goods g,supplier_shop ss ,supplier s '
                    'where ss.deleted=0 and s.id=ss.supplier_id and s.id=g.supplier_id '
                    'and g.id=%s limit 1', goods_id)
            verify_infos = {
                'goods_id': goods_id,
                'shop_id': goods_info.shop_id
            }
            if isinstance(order['coupon_sn'], int) or isinstance(
                    order['coupon_sn'], float):
                need_convert_orders.append(str(order['coupon_sn']))
                continue

            #判断是不是已经导入过的外部订单
            distributor_order = self.db.get(
                'select * from distributor_order where distributor_shop_id=%s and '
                'order_no=%s', distributor_shop_id, order['coupon_sn'])
            if distributor_order:
                existed_orders.append(str(order['coupon_sn']))
                continue

            created_at = datetime.now() - timedelta(days=1)
            #创建分销订单
            distributor_order_id = self.db.execute(
                'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                'values (%s, %s, %s, %s)', order['coupon_sn'],
                json_dumps(verify_infos), distributor_shop_id, created_at)
            order_id, order_no = new_distributor_order(self.db,
                                                       distributor_shop_id,
                                                       goods_info.sales_price,
                                                       goods_info.sales_price,
                                                       "")
            # 改时间
            self.db.execute(
                'update orders set created_at=%s, paid_at=%s where id=%s',
                created_at, created_at, order_id)
            self.db.execute(
                'update journal set created_at=%s where type=1 and iid=%s',
                created_at, order_id)

            #记录订单信息
            new_order = new_distributor_item(
                db=self.db,
                order_id=order_id,
                order_no=order_no,
                sales_price=None,
                count=1,
                goods_info=goods_info,
                mobile='',
                distributor_shop_id=distributor_shop_id,
                distributor_goods_id='',
                distributor_coupons=[{
                    'coupon_sn': order['coupon_sn'],
                    'coupon_pwd': ''
                }],
                use_distributor_coupon=True)
            if new_order.ok:
                #更新分销订单id
                self.db.execute(
                    'update orders set distributor_order_id=%s where id = %s',
                    distributor_order_id, order_id)
                #更新订单id
                self.db.execute(
                    'update distributor_order set order_id=%s where id=%s',
                    order_id, distributor_order_id)
                #更新该券验证的门店
                self.db.execute(
                    'update item set sp_shop_id = %s where order_id=%s',
                    goods_info.shop_id, order_id)
                #设定时间为前一天
                self.db.execute(
                    'update item set created_at=%s where order_id=%s',
                    created_at, order_id)
                #自动验证
                self.redis.lpush(
                    options.queue_coupon_local_verify,
                    json_dumps({
                        'coupon': order['coupon_sn'],
                        'shop_id': goods_info.shop_id,
                        'retry': 0,
                        'used_at': created_at
                    }))

        self.render('order/import_outer_order.html',
                    message='success',
                    existed_orders=existed_orders,
                    need_convert_orders=need_convert_orders)
Example #3
0
def yihaodian_order(db, redis, distributor_order_id, message_raw):
    """
    一号店分销订单处理
    :param db:
    :param redis:
    :param distributor_order_id:
    :param message_raw:
    :type db:torndb.Connection
    :type redis:redis.client.StrictRedis
    :type distributor_order_id: int
    """
    distributor_order = db.get('select * from distributor_order where id=%s', distributor_order_id)
    distributor_order_no = distributor_order.order_no

    # 分销订单号不存在,结束
    if not distributor_order:
        logging.error('yihaodian job consume cannot find distributor order: order_no=%s', distributor_order_no)
        return

    # 重新刷新订单信息
    yihaodian = Yihaodian('yhd.order.detail.get')
    response = yihaodian.sync_fetch(orderCode=distributor_order_no)
    logging.info('yihaodian response for distributor_order_no %s : %s' % (distributor_order_no, response))
    yihaodian.parse_response(response)

    # 一号店请求失败,结束
    if not yihaodian.is_ok():
        logging.error('yihaodian job consume fetch order failed, distributor order_no=%s', distributor_order_no)
        return

    order_status = yihaodian.message.findtext('./orderInfo/orderDetail/orderStatus').strip()

    # 一号店订单已取消,从队列移除,结束
    if order_status == 'ORDER_CANCEL':
        # 队列移除
        redis.lrem(options.queue_distributor_order_processing, 0, message_raw)
        logging.info(' yihaodian order_no %s cancelled ', distributor_order_no)
        return
    # 一号店订单状态为‘可以发货’, 则处理该订单
    elif order_status == 'ORDER_TRUNED_TO_DO':
        # 更新分销订单message, 如果distributor_order表中message为空,则该分销订单已在分销商处取消
        db.execute('update distributor_order set message=%s where order_no=%s', response, distributor_order_no)

        # 筛选电子券订单
        order_items = yihaodian.message.findall('./orderInfo/orderItemList/orderItem')
        coupon_items = []
        for item in order_items:
            goods_link_id = item.findtext('./outerId')
            if goods_link_id:
                goods = db.get('select g.* from goods as g, goods_distributor_shop as gds '
                               'where g.id = gds.goods_id and gds.distributor_shop_id=%s and gds.goods_link_id=%s',
                               options.shop_id_yihaodian, goods_link_id)
                if not goods and int(goods_link_id) < 20000:
                    goods = db.get('select g.* from goods g where g.type="E" and g.id=%s', goods_link_id)
                # 当商品类型为电子券时,才处理
                if goods and goods.type == options.goods_type_electronic:
                    coupon_items.append((item, goods))
                else:
                    logging.warning('yihaodian job consume warning: goods_link_id=%s not found or goods type is real'
                                    % goods_link_id)

        if len(coupon_items) == 0:
            # 分销订单没有电子券,从处理队列移除
            redis.lrem(options.queue_distributor_order_processing, 0, message_raw)
            logging.info('yihaodian job consume exits for no real goods, distributor order_no: %s' % distributor_order_no)
            return

        # 生成一百券订单
        if distributor_order.order_id == 0 and check_stock(coupon_items):
            mobile = yihaodian.message.findtext('./orderInfo/orderDetail/goodReceiverMoblie')
            order_amount = yihaodian.message.findtext('./orderInfo/orderDetail/orderAmount')
            payment = Decimal(yihaodian.message.findtext('./orderInfo/orderDetail/realAmount'))
            order_id, order_no = new_distributor_order(db, options.shop_id_yihaodian, order_amount, payment, mobile)

            # 生成订单项
            for item in coupon_items:
                order_item = item[0]
                goods_info = item[1]
                sales_price = Decimal(order_item.findtext('./orderItemPrice'))
                count = int(order_item.findtext('./orderItemNum'))
                distributor_goods_id = order_item.findtext('./productId')
                result = new_distributor_item(db, order_id, order_no, sales_price, count, goods_info, mobile,
                                              options.shop_id_yihaodian, distributor_goods_id, [], False)
                if not result.ok:
                    logging.error('failed to generate order items for distributor_order_id=%s of goods_id=%s'
                                  % (distributor_order_id, goods_info.id))
                    return
                logging.info('create new yibaiquan order id=%s for yihaodian distributor order id=%s'
                             % (order_id, distributor_order_id))

            # 相互更新分销订单和订单
            db.execute('update orders set distributor_order_id=%s where id = %s',
                       distributor_order_id, order_id)
            db.execute('update distributor_order set order_id=%s where id=%s',
                       order_id, distributor_order_id)

            # 按order_item发送券短信
            all_order_items = db.query('select * from order_item where order_id=%s', order_id)
            for item in all_order_items:
                CouponSMSMessage(db, redis, order_item=item).remark('一号店订单发送券号短信').send()

            # 通知一号店,已发货
            yihaodian = Yihaodian('yhd.logistics.order.shipments.update')
            response = yihaodian.sync_fetch(orderCode=distributor_order_no,
                                            deliverySupplierId=options.yhd_delivery,
                                            expressNbr=distributor_order_no
                                            )
            yihaodian.parse_response(response)

            if yihaodian.is_ok():
                # 分销订单处理完成,从处理队列移除
                redis.lrem(options.queue_distributor_order_processing, 0, message_raw)
                logging.info('yihaodian distributor order (id=%s) finish' % distributor_order_id)
            else:
                logging.error('update yihaodian distributor order (id=%s) shipments failed' % distributor_order_id)
Example #4
0
    def post(self):
        self.set_header('Content-Type', 'application/xml; charset=UTF-8')

        # 解析京东请求
        logging.info('jingdong api. send_order %s', self.request.body)
        request = JdToUs(self.request.body)
        distr_shop = self.db.get('select id, taobao_api_info from distributor_shop '
                                 'where distributor_id=%s and taobao_seller_id=%s',
                                 options.distributor_id_jingdong, request.vender_id)

        api_info = json.loads(distr_shop.taobao_api_info, object_hook=json_hook)
        request.set_key(api_info.vender_key, api_info.secret_key)
        request.parse()

        # 查找分销订单
        jd_order_id = request.message.findtext('JdOrderId')
        order = self.db.get('select * from distributor_order where '
                            'distributor_shop_id=%s and order_no=%s',
                            distr_shop.id, jd_order_id)
        order_message = ElementTree.tostring(request.message, encoding='utf-8', method='xml')
        logging.info('jingdong api. send_order decrypted %s', order_message)

        if order:
            return self.write(request.response('send_order', 212, 'the order has been processed'))
        else:
            # 保存分销订单信息
            distributor_order_id = self.db.execute(
                'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                'values (%s, %s, %s, NOW())',
                jd_order_id, order_message, distr_shop.id)

        count = int(request.message.findtext('Count'))
        goods_link_id = request.message.findtext('VenderTeamId')
        order_amount = Decimal(request.message.findtext('Origin'))/100
        sales_price = Decimal(request.message.findtext('TeamPrice'))/100
        jd_goods_id = request.message.findtext('JdTeamId')
        mobile = request.message.findtext('Mobile')

        jd_coupons = [{'coupon_sn': c.findtext('CouponId'), 'coupon_pwd': c.findtext('CouponPwd')}
                      for c in request.message.findall('Coupons/Coupon')]

        # 找到关联的商品
        goods_info = self.db.get('select g.* from goods g, goods_distributor_shop gds '
                                 'where g.id = gds.goods_id and distributor_shop_id=%s and goods_link_id=%s',
                                 distr_shop.id, goods_link_id)
        if not goods_info and int(goods_link_id) < 20000:
            goods_info = self.db.get('select g.* from goods g where g.type="E" and g.id=%s', goods_link_id)

        if not goods_info:
            self.write(request.response('send_order', 213, 'goods not found'))
            return

        order_id, order_no = new_distributor_order(self.db, distr_shop.id, order_amount, order_amount, mobile)
        result = new_distributor_item(self.db, order_id, order_no, sales_price, count, goods_info,
                                      mobile, distr_shop.id, jd_goods_id, jd_coupons, False)

        if not result.ok:
            self.write(request.response('send_order', 213, result.msg))
            return
        else:
            self.db.execute('update orders set distributor_order_id=%s where id = %s',
                            distributor_order_id, result.order_id)
            self.db.execute('update distributor_order set order_id=%s where id = %s',
                            result.order_id, distributor_order_id)

        ## 按order_item发送券短信
        #all_order_items = self.db.query('select * from order_item where order_id=%s', order_id)
        #for item in all_order_items:
        #    CouponSMSMessage(self.db, self.redis, order_item=item).remark('京东订单短信发送').send()

        query_coupons = self.db.query('select ic.sn, ic.distr_sn from item_coupon ic, item i '
                                      'where ic.item_id=i.id and i.order_id=%s', order_id)
        result_coupon = []
        for jd_coupon in jd_coupons:
            for query_coupon in query_coupons:
                if query_coupon.distr_sn == jd_coupon['coupon_sn']:
                    result_coupon.append(query_coupon.sn)
                    break

        self.write(request.response('send_order', 200, 'ok',
                                    jd_team_id=jd_goods_id, vender_team_id=goods_link_id,
                                    sell_count=count, vender_order_id=order_no, coupons=result_coupon))
Example #5
0
    def post(self):
        self.set_header('Content-Type', 'application/json; charset=UTF-8')
        coupon_list = [i.strip() for i in self.get_argument('coupons', '').split(',') if i.strip()]
        if len(coupon_list) == 0:
            self.write({'ok': False, 'msg': u'请输入券号'})
            return
        shop_id = self.get_argument('shop_id', 0)
        #这一步是检查该操作员是否有权限验证券
        all_shops = self.db.query('select ss.* from supplier_shop ss, supplier_user su where ss.supplier_id=%s and '
                                  'ss.deleted=0 and su.id=%s and su.supplier_id=ss.supplier_id and '
                                  ' (su.shop_id=0 or ss.id=su.shop_id)',
                                  self.current_user.supplier_id, self.current_user.id)
        if int(shop_id) not in [i.id for i in all_shops]:
            self.write({'ok': False, 'msg': u'对不起,您无权执行此操作'})
            return

        is_our_coupon = False
        coupon_length = 0
        messages = PropDict()  # 用来存不同的手机号对应的券号
        #检测长度是否相同、是否是我们的券
        for coupon_sn in coupon_list:
            coupon = self.db.get('select id, sn, mobile from item_coupon where sn=%s', coupon_sn)
            if coupon:
                is_our_coupon = True
            if coupon_length == 0:
                coupon_length = len(coupon_sn)
            elif coupon_length != len(coupon_sn):
                coupon_length = -1
        if coupon_length == -1:
            self.write({'ok': False, 'msg': u'券号长度必须一致'})
            return

        result_list = []
        if is_our_coupon:
            # 我们自己的券
            for coupon_sn in coupon_list:
                #  本地检测
                check_result = local_check(self.db, coupon_sn, shop_id)
                if not check_result.ok:
                    ok, msg = (False, check_result.msg)
                else:
                    #  合作伙伴API验证
                    api_result = yield partner_api_verify(self.db, coupon_sn)
                    if not api_result.ok:
                        ok, msg = (False, api_result.msg)
                    else:
                        #  本地验证
                        verify_result = local_verify(self.db, coupon_sn, shop_id, self.current_user.name)
                        ok, msg = (verify_result.ok, verify_result.msg)
                        # 验证通过,记录需要发送确认短信的券
                        if ok:
                            if messages.get(str(check_result.coupon.mobile)):
                                # 手机号已存在,添加券号到对应手机号
                                messages.get(str(check_result.coupon.mobile)).append(str(coupon_sn))
                            else:
                                # 手机号不存在,新建K-V对
                                messages.update({str(check_result.coupon.mobile): [str(coupon_sn)]})

                result_list.append({'coupon_sn': coupon_sn, 'ok': ok, 'msg': msg})
        else:
            mobile = self.get_argument('mobile', '')
            # 检查手机号合法性
            mobile_ptn = re.compile('^1[\d+]{10}$')
            if not re.match(mobile_ptn, mobile):
                # 不合法手机号,不记录
                mobile = ''

            # 尝试外部验证
            results = yield partner_browser_verify(self.db, coupon_list, shop_id)
            for result in results:
                if result.ok:
                    goods_info = self.db.get('select g.* from goods g where id=%s', result.goods_id)
                    verify_infos = {'goods_id': result.goods_id, 'shop_id': shop_id}
                    #创建分销订单
                    distributor_order_id = self.db.execute(
                        'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                        'values (%s, %s, %s, NOW())', result.coupon_sn, json_dumps(verify_infos), result.distributor_shop_id)
                    order_id, order_no = new_distributor_order(self.db, result.distributor_shop_id,
                                                               goods_info.sales_price, goods_info.sales_price, mobile)
                    #记录订单信息
                    new_order = new_distributor_item(
                        db=self.db,
                        order_id=order_id,
                        order_no=order_no,
                        sales_price=None,
                        count=1,
                        goods_info=goods_info,
                        mobile=mobile,
                        distributor_shop_id=result.distributor_shop_id,
                        distributor_goods_id='',
                        distributor_coupons=[{'coupon_sn': result.coupon_sn, 'coupon_pwd': result.coupon_pwd or ''}],
                        use_distributor_coupon=True
                    )
                    if new_order.ok:
                        #更新分销订单id
                        self.db.execute('update orders set distributor_order_id=%s where id = %s',
                                        distributor_order_id, order_id)
                        #更新订单id
                        self.db.execute('update distributor_order set order_id=%s where id=%s',
                                        order_id, distributor_order_id)
                        #更新该券验证的门店
                        self.db.execute('update item set sp_shop_id = %s where order_id=%s', shop_id, order_id)
                        self.redis.lpush(options.queue_coupon_local_verify, json_dumps({'coupon': result.coupon_sn,
                                         'shop_id': shop_id, 'retry': 0, 'used_at': datetime.now()}))
                result_list.append({'coupon_sn': result.coupon_sn, 'coupon_pwd': result.coupon_pwd or '',
                                    'ok': result.ok, 'msg': result.msg})

        # 如果有合法券号,发送确认短信
        if messages:
            shop_name = self.db.get('select name from supplier_shop where id=%s', shop_id).name
            for mobile, coupon_sns in messages.items():
                CouponConsumedMessage(self.redis, coupon_sns, shop_name, mobile).send()

        self.write({'ok': True, 'result': result_list})
Example #6
0
    def post(self):

        # 解密58请求参数
        json_text = decrypt(self.get_argument('param'), options.wuba_secret_key)  # '2a6f8f2c')#
        params = json.loads(json_text, object_hook=json_hook)
        logging.info('wuba new order request : %s', json_dumps(params))

        # 获得参数
        try:
            wuba_order_no = params.orderId                      # 58 订单号
            sales_price = Decimal(params.prodPrice)             # 商品售价
            product_count = int(params.prodCount)               # 购买数量
            mobile = params.mobile                              # 订单券号接受手机号
            goods_link_id = int(params.groupbuyIdThirdpart)     # 伪商品ID
        except AttributeError:
            logging.info('wuba request failed: wrong params')
            return self.write('{"status":"10201", "msg": "参数解析错误"}')

        # 检查参数格式
        if int(product_count) <= 0 or sales_price.compare(Decimal(0)) < 0 or not check_phone(mobile):
            logging.info('wuba request failed: invalid params')
            return self.write('{"status":"20210", "msg": "输入参数错误"}')

        # 查找分销订单
        wuba_order = self.db.get('select * from distributor_order where '
                                 'distributor_shop_id=%s and order_no=%s',
                                 options.shop_id_wuba, wuba_order_no)

        if wuba_order:
            # 分销订单重复
            logging.info('wuba request failed: duplicated wuba order no')
            return self.write('{"status":"10100", "msg": "订单已存在"}')
        else:
            # 分销订单不存在, 生成分销订单
            distributor_order_id = self.db.execute(
                'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                'values (%s, %s, %s, NOW())',
                wuba_order_no, json_text, options.shop_id_wuba)
            #放入处理队列
            self.redis.lpush(options.queue_distributor_failed_order, "%s-%s" % (wuba_order_no, goods_link_id))

        # 根据伪商品找到关联的商品
        goods_info = self.db.get('select g.* from goods g, goods_distributor_shop gds '
                                 'where g.id = gds.goods_id and distributor_shop_id=%s and goods_link_id=%s',
                                 options.shop_id_wuba, goods_link_id)
        # 如果商品不存在,根据真实商品ID查找
        if not goods_info and goods_link_id < 20000:
            goods_info = self.db.get('select g.* from goods g where g.type="E" and g.id=%s', goods_link_id)
        # 商品不存在, 返回错误信息
        if not goods_info:
            logging.info('wuba request failed: can not find goods')
            return self.write('{"status":"10100", "msg": "未找到商品"}')
        
        # 生成订单
        order_id, order_no = new_distributor_order(self.db, options.shop_id_wuba,
                                                   sales_price*product_count, sales_price*product_count, mobile)
        result = new_distributor_item(self.db, order_id, order_no, sales_price, product_count, goods_info,
                                      mobile, options.shop_id_wuba, "", [], False)

        if not result.ok:
            # 生成订单失败,返回
            logging.info('wuba request failed: generate order failed msg %s' % result.msg)
            return self.write('{"status":"10100", "msg": %s}' % result.msg)
        else:
            # 生成订单成功,更新id
            self.db.execute('update orders set distributor_order_id=%s where id = %s',
                            distributor_order_id, result.order_id)
            self.db.execute('update distributor_order set order_id=%s where id = %s',
                            result.order_id, distributor_order_id)
            # 从处理队列移除
            self.redis.lrem(options.queue_distributor_failed_order, 0, "%s-%s" % (wuba_order_no, goods_link_id))

        # 发送短信
        all_order_items = self.db.query('select * from order_item where order_id=%s', order_id)
        for item in all_order_items:
            CouponSMSMessage(self.db, self.redis, order_item=item).remark('58订单短信发送').send()

        tickets = []
        # 添加券信息到需要返回的tickets
        for coupon in result.coupons:
            coupon_sn = coupon['coupon_sn']
            created_at = self.db.get('select * from item i, item_coupon c where i.id=c.item_id and c.sn=%s', coupon_sn).created_at
            ticket = {
                "ticketId": int(coupon['id']),
                "ticketCode": str(coupon_sn),
                "ticketCount": 1,
                "createTime": str(created_at),
                "endTime": str(goods_info.expire_at),
            }
            tickets.append(ticket)

        # 生成合法的json返回
        data = {'orderId': wuba_order_no, 'orderIdThirdpart': order_no, 'tickets': tickets}
        result_json = {'status': '10000', 'msg': 'ok', 'data': encrypt(str(data), options.wuba_secret_key)}  # '2a6f8f2c')
        logging.info('wuba request success: %s tickets generated' % product_count)
        return self.write(json_dumps(result_json))
Example #7
0
def yihaodian_order(db, redis, distributor_order_id, message_raw):
    """
    一号店分销订单处理
    :param db:
    :param redis:
    :param distributor_order_id:
    :param message_raw:
    :type db:torndb.Connection
    :type redis:redis.client.StrictRedis
    :type distributor_order_id: int
    """
    distributor_order = db.get('select * from distributor_order where id=%s',
                               distributor_order_id)
    distributor_order_no = distributor_order.order_no

    # 分销订单号不存在,结束
    if not distributor_order:
        logging.error(
            'yihaodian job consume cannot find distributor order: order_no=%s',
            distributor_order_no)
        return

    # 重新刷新订单信息
    yihaodian = Yihaodian('yhd.order.detail.get')
    response = yihaodian.sync_fetch(orderCode=distributor_order_no)
    logging.info('yihaodian response for distributor_order_no %s : %s' %
                 (distributor_order_no, response))
    yihaodian.parse_response(response)

    # 一号店请求失败,结束
    if not yihaodian.is_ok():
        logging.error(
            'yihaodian job consume fetch order failed, distributor order_no=%s',
            distributor_order_no)
        return

    order_status = yihaodian.message.findtext(
        './orderInfo/orderDetail/orderStatus').strip()

    # 一号店订单已取消,从队列移除,结束
    if order_status == 'ORDER_CANCEL':
        # 队列移除
        redis.lrem(options.queue_distributor_order_processing, 0, message_raw)
        logging.info(' yihaodian order_no %s cancelled ', distributor_order_no)
        return
    # 一号店订单状态为‘可以发货’, 则处理该订单
    elif order_status == 'ORDER_TRUNED_TO_DO':
        # 更新分销订单message, 如果distributor_order表中message为空,则该分销订单已在分销商处取消
        db.execute('update distributor_order set message=%s where order_no=%s',
                   response, distributor_order_no)

        # 筛选电子券订单
        order_items = yihaodian.message.findall(
            './orderInfo/orderItemList/orderItem')
        coupon_items = []
        for item in order_items:
            goods_link_id = item.findtext('./outerId')
            if goods_link_id:
                goods = db.get(
                    'select g.* from goods as g, goods_distributor_shop as gds '
                    'where g.id = gds.goods_id and gds.distributor_shop_id=%s and gds.goods_link_id=%s',
                    options.shop_id_yihaodian, goods_link_id)
                if not goods and int(goods_link_id) < 20000:
                    goods = db.get(
                        'select g.* from goods g where g.type="E" and g.id=%s',
                        goods_link_id)
                # 当商品类型为电子券时,才处理
                if goods and goods.type == options.goods_type_electronic:
                    coupon_items.append((item, goods))
                else:
                    logging.warning(
                        'yihaodian job consume warning: goods_link_id=%s not found or goods type is real'
                        % goods_link_id)

        if len(coupon_items) == 0:
            # 分销订单没有电子券,从处理队列移除
            redis.lrem(options.queue_distributor_order_processing, 0,
                       message_raw)
            logging.info(
                'yihaodian job consume exits for no real goods, distributor order_no: %s'
                % distributor_order_no)
            return

        # 生成一百券订单
        if distributor_order.order_id == 0 and check_stock(coupon_items):
            mobile = yihaodian.message.findtext(
                './orderInfo/orderDetail/goodReceiverMoblie')
            order_amount = yihaodian.message.findtext(
                './orderInfo/orderDetail/orderAmount')
            payment = Decimal(
                yihaodian.message.findtext(
                    './orderInfo/orderDetail/realAmount'))
            order_id, order_no = new_distributor_order(
                db, options.shop_id_yihaodian, order_amount, payment, mobile)

            # 生成订单项
            for item in coupon_items:
                order_item = item[0]
                goods_info = item[1]
                sales_price = Decimal(order_item.findtext('./orderItemPrice'))
                count = int(order_item.findtext('./orderItemNum'))
                distributor_goods_id = order_item.findtext('./productId')
                result = new_distributor_item(db, order_id, order_no,
                                              sales_price, count, goods_info,
                                              mobile,
                                              options.shop_id_yihaodian,
                                              distributor_goods_id, [], False)
                if not result.ok:
                    logging.error(
                        'failed to generate order items for distributor_order_id=%s of goods_id=%s'
                        % (distributor_order_id, goods_info.id))
                    return
                logging.info(
                    'create new yibaiquan order id=%s for yihaodian distributor order id=%s'
                    % (order_id, distributor_order_id))

            # 相互更新分销订单和订单
            db.execute(
                'update orders set distributor_order_id=%s where id = %s',
                distributor_order_id, order_id)
            db.execute('update distributor_order set order_id=%s where id=%s',
                       order_id, distributor_order_id)

            # 按order_item发送券短信
            all_order_items = db.query(
                'select * from order_item where order_id=%s', order_id)
            for item in all_order_items:
                CouponSMSMessage(db, redis,
                                 order_item=item).remark('一号店订单发送券号短信').send()

            # 通知一号店,已发货
            yihaodian = Yihaodian('yhd.logistics.order.shipments.update')
            response = yihaodian.sync_fetch(
                orderCode=distributor_order_no,
                deliverySupplierId=options.yhd_delivery,
                expressNbr=distributor_order_no)
            yihaodian.parse_response(response)

            if yihaodian.is_ok():
                # 分销订单处理完成,从处理队列移除
                redis.lrem(options.queue_distributor_order_processing, 0,
                           message_raw)
                logging.info('yihaodian distributor order (id=%s) finish' %
                             distributor_order_id)
            else:
                logging.error(
                    'update yihaodian distributor order (id=%s) shipments failed'
                    % distributor_order_id)
Example #8
0
    def get(self):
        caller = self.get_argument('caller').encode('utf-8')
        coupon_sn = self.get_argument('coupon').encode('utf-8')
        sign = self.get_argument('sign').encode('utf-8')
        timestamp = self.get_argument('timestamp').encode('utf-8')
        logging.info(
            'telephone verify. caller: %s, coupon_sn: %s, sign: %s, timestamp: %s',
            caller, coupon_sn, sign, timestamp)

        if not caller:
            logging.error('telephone verify failed: empty caller.')
            self.write('1|主叫号码无效')
            return
        if not coupon_sn:
            logging.error('telephone verify failed: empty coupon.')
            self.write('2|券号为空')
            return
        if not sign:
            logging.error('telephone verify failed: empty sign.')
            self.write('3|签名无效')
            return
        if not timestamp:
            logging.error('telephone verify failed: empty timestamp.')
            self.write('3|时间戳无效')
            return

        if abs(int(time.time()) - int(timestamp)) > 300:
            logging.error('telephone verify failed: request timeout.')
            self.write('3|请求超时')
            return
        # 暂不检查签名
        # todo

        # 查找电话
        supplier_shop = self.db.get(
            'select * from supplier_shop where deleted=0 and verify_phones like %s',
            '%' + caller + '%')
        #if not supplier_shop:
        #    #部分商家使用分机,出口线很多,不能一一录入,这里可以使用电话号码的前面一部分进行识别。
        #    #尝试模糊查找验证电话机
        #    supplier_user_list = self.db.query('select * from supplier_user where type="ANDROID"')
        #    for su in supplier_user_list:
        #        if caller.startswith(su.loginname):
        #            supplier_shop = su
        #            break
        if not supplier_shop:
            logging.error(
                'telehphone verify failed. can not found valid supplier_user %s.',
                caller)
            self.write('1|您的电话还未绑定')
            return

        coupon = self.db.get(
            'select id, sn, mobile from item_coupon where sn=%s', coupon_sn)
        if not coupon:
            if len(coupon_sn) == 9:
                for i in range(10):
                    coupon = self.db.get(
                        'select id, sn, mobile from item_coupon where sn=%s',
                        '%s%s' % (i, coupon_sn))

        if coupon:
            #我们自己的券
            check_result = local_check(self.db, coupon.sn, supplier_shop.id)
            if not check_result.ok:
                ok, msg = (False, check_result.msg)
            else:
                #  合作伙伴API验证
                api_result = yield partner_api_verify(self.db, coupon.sn)
                if not api_result.ok:
                    ok, msg = (False, api_result.msg)
                else:
                    #  本地验证
                    verify_result = local_verify(self.db, coupon.sn,
                                                 supplier_shop.id, '电话验证')
                    if verify_result.ok:
                        ok, msg = (True, verify_result.msg)
                    else:
                        ok, msg = (False, verify_result.msg)
        else:
            results = yield partner_browser_verify(self.db, [coupon_sn],
                                                   supplier_shop.id)
            # 记录外部订单
            for result in results:
                if result.ok:
                    goods_info = self.db.get(
                        'select g.* from goods g where id=%s', result.goods_id)
                    verify_infos = {
                        'goods_id': result.goods_id,
                        'shop_id': supplier_shop.id
                    }
                    #创建分销订单
                    distributor_order_id = self.db.execute(
                        'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                        'values (%s, %s, %s, NOW())', result.coupon_sn,
                        json_dumps(verify_infos), result.distributor_shop_id)
                    order_id, order_no = new_distributor_order(
                        self.db, result.distributor_shop_id,
                        goods_info.sales_price, goods_info.sales_price, '')
                    #记录订单信息
                    new_order = new_distributor_item(
                        db=self.db,
                        order_id=order_id,
                        order_no=order_no,
                        sales_price=None,
                        count=1,
                        goods_info=goods_info,
                        mobile='',
                        distributor_shop_id=result.distributor_shop_id,
                        distributor_goods_id='',
                        distributor_coupons=[{
                            'coupon_sn':
                            result.coupon_sn,
                            'coupon_pwd':
                            result.coupon_pwd or ''
                        }],
                        use_distributor_coupon=True)
                    if new_order.ok:
                        #更新分销订单id
                        self.db.execute(
                            'update orders set distributor_order_id=%s where id = %s',
                            distributor_order_id, order_id)
                        #更新订单id
                        self.db.execute(
                            'update distributor_order set order_id=%s where id=%s',
                            order_id, distributor_order_id)
                        #更新该券验证的门店
                        self.db.execute(
                            'update item set sp_shop_id = %s where order_id=%s',
                            supplier_shop.id, order_id)
                        self.redis.lpush(
                            options.queue_coupon_local_verify,
                            json_dumps({
                                'coupon': result.coupon_sn,
                                'shop_id': supplier_shop.id,
                                'retry': 0,
                                'used_at': datetime.now()
                            }))
            ok, msg = (results[0].ok, results[0].msg)

        if not ok:
            logging.error('telephone verify failed. %s', msg)
            self.write('2|验证失败')
        else:
            logging.info(
                'telephone verify ok. caller: %s, coupon_sn: %s, sign: %s, timestamp: %s',
                caller, coupon_sn, sign, timestamp)

            # 发送验证确认短信
            CouponConsumedMessage(self.redis, [coupon.sn], supplier_shop.name,
                                  coupon.mobile).send()

            if coupon:
                face_value = self.db.get(
                    'select face_value from item i, item_coupon c where i.id=c.item_id '
                    'and c.id=%s', coupon.id).face_value
                self.write('0|券尾号%s验证成功,面值%s' %
                           (coupon_sn[-4:], upper(face_value).encode('utf-8')))
            else:
                self.write('0|券尾号%s验证成功' % coupon_sn[-4:])
Example #9
0
    def post(self):
        distributor_shop_id = self.get_argument('distributor_id').encode(
            'utf-8')
        goods_id = self.get_argument('goods_id').encode('utf-8')
        num = int(self.get_argument('num').encode('utf-8'))

        # 参数错误返回
        if not distributor_shop_id or not goods_id or not num:
            return self.render('coupon/export_result.html',
                               result="出错了!!参数错误, 请重新操作",
                               coupons=[],
                               goods_name='',
                               order_id='')

        # 没有商品,返回
        goods_info = self.db.get(
            'select * from goods where id=%s and deleted=0', goods_id)
        if not goods_info:
            return self.render('coupon/export_result.html',
                               result="出错了!!找不到商品",
                               coupons=[],
                               goods_name='',
                               order_id='')

        # 检查库存,如果库存不足,返回
        if int(goods_info.stock) < num:
            return self.render('coupon/export_result.html',
                               result="出错了!!库存不足",
                               coupons=[],
                               goods_name='',
                               order_id='')

        # 生成订单
        order_amount = goods_info.sales_price * num
        order_id, order_no = new_distributor_order(self.db,
                                                   distributor_shop_id,
                                                   order_amount, order_amount,
                                                   "")
        result = new_distributor_item(self.db, order_id, order_no,
                                      goods_info.sales_price, num, goods_info,
                                      "", distributor_shop_id, "", [], False)
        # 生成分销订单
        self.db.execute(
            'insert into distributor_order (order_no, created_at, message, distributor_shop_id, order_id) '
            'values (%s, NOW(), %s, %s, %s)', 'EXPORT%s' % int(time.time()),
            '批量导出电子券', distributor_shop_id, order_id)

        if not result.ok:
            return self.render('coupon/export_result.html',
                               result=result.msg,
                               goods_name=goods_info.short_name,
                               coupons=[],
                               order_id='')
        else:
            # 写日志,订单记一个,商品记一个
            operator = self.get_current_user().name
            message = "批量导出电子券, 分销商店铺id:%s, 数量:%s, 商品:%s" % (
                distributor_shop_id, num, goods_info.short_name)
            self.db.execute(
                'insert into journal (created_at, type, created_by, message, iid) values '
                '(NOW(), 1, %s, %s, %s)', operator, message, order_id)
            self.db.execute(
                'insert into journal (created_at, type, created_by, message, iid) values '
                '(NOW(), 3, %s, %s, %s)', operator, message, goods_id)
            coupons = [c['coupon_sn'] for c in result.coupons]
            self.render('coupon/export_result.html',
                        result=result.msg,
                        coupons=coupons,
                        goods_name=goods_info.short_name,
                        order_id=order_id)
Example #10
0
    def post(self):
        """ 开始导入"""
        if not self.request.files:
            self.render('real/import_outer_order.html', message=u'请选择文件')

         #读取文件
        order_file = self.request.files['order_file'][0]
        book = xlrd.open_workbook(file_contents=order_file['body'])
        try:
            sheet = book.sheet_by_index(0)
        except:
            self.render('real/import_outer_order.html', message=u'文件格式错误,请检查')
            return
        partner = self.get_argument('partner').lower()
        distributor_shop_id = {'dp': 40, 'mt': 44, 'ls': '45', 'nm': 42, 'ww': 37}.get(partner)
        #读取工作表的所有行数据内容
        rows = [sheet.row_values(i) for i in range(1, sheet.nrows)]
        #转换数据
        col_names = ('coupon_sn', 'goods_id')
        coupon_list = [dict([(col_names[i], row[i]) for i in range(len(col_names))]) for row in rows]
        existed_orders = []
        need_convert_orders = []
        goods_id = -1
        for order in coupon_list:
            current_goods_id = order['goods_id']
            if goods_id != current_goods_id:
                goods_id = current_goods_id
                goods_info = self.db.get('select g.* ,ss.id shop_id from goods g,supplier_shop ss ,supplier s '
                                         'where ss.deleted=0 and s.id=ss.supplier_id and s.id=g.supplier_id '
                                         'and g.id=%s limit 1', goods_id)
            verify_infos = {'goods_id': goods_id, 'shop_id': goods_info.shop_id}
            if isinstance(order['coupon_sn'], int) or isinstance(order['coupon_sn'], float):
                need_convert_orders.append(str(order['coupon_sn']))
                continue

            #判断是不是已经导入过的外部订单
            distributor_order = self.db.get('select * from distributor_order where distributor_shop_id=%s and '
                                            'order_no=%s', distributor_shop_id, order['coupon_sn'])
            if distributor_order:
                existed_orders.append(str(order['coupon_sn']))
                continue

            created_at = datetime.now() - timedelta(days=1)
            #创建分销订单
            distributor_order_id = self.db.execute(
                'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                'values (%s, %s, %s, %s)', order['coupon_sn'], json_dumps(verify_infos), distributor_shop_id, created_at)
            order_id, order_no = new_distributor_order(self.db, distributor_shop_id,
                                                       goods_info.sales_price, goods_info.sales_price, "")
            # 改时间
            self.db.execute('update orders set created_at=%s, paid_at=%s where id=%s', created_at, created_at, order_id)
            self.db.execute('update journal set created_at=%s where type=1 and iid=%s', created_at, order_id)

            #记录订单信息
            new_order = new_distributor_item(
                db=self.db,
                order_id=order_id,
                order_no=order_no,
                sales_price=None,
                count=1,
                goods_info=goods_info,
                mobile='',
                distributor_shop_id=distributor_shop_id,
                distributor_goods_id='',
                distributor_coupons=[{'coupon_sn': order['coupon_sn'], 'coupon_pwd': ''}],
                use_distributor_coupon=True
            )
            if new_order.ok:
                #更新分销订单id
                self.db.execute('update orders set distributor_order_id=%s where id = %s',
                                distributor_order_id, order_id)
                #更新订单id
                self.db.execute('update distributor_order set order_id=%s where id=%s',
                                order_id, distributor_order_id)
                #更新该券验证的门店
                self.db.execute('update item set sp_shop_id = %s where order_id=%s', goods_info.shop_id, order_id)
                #设定时间为前一天
                self.db.execute('update item set created_at=%s where order_id=%s', created_at, order_id)
                #自动验证
                self.redis.lpush(options.queue_coupon_local_verify, json_dumps({'coupon': order['coupon_sn'],
                                 'shop_id': goods_info.shop_id, 'retry': 0, 'used_at': created_at}))

        self.render('order/import_outer_order.html', message='success', existed_orders=existed_orders,
                    need_convert_orders=need_convert_orders)
Example #11
0
    def post(self):
        self.set_header('Content-Type', 'application/json; charset=UTF-8')
        coupon_list = [
            i.strip() for i in self.get_argument('coupons', '').split(',')
            if i.strip()
        ]
        if len(coupon_list) == 0:
            self.write({'ok': False, 'msg': u'请输入券号'})
            return
        shop_id = self.get_argument('shop_id', 0)
        #这一步是检查该操作员是否有权限验证券
        all_shops = self.db.query(
            'select ss.* from supplier_shop ss, supplier_user su where ss.supplier_id=%s and '
            'ss.deleted=0 and su.id=%s and su.supplier_id=ss.supplier_id and '
            ' (su.shop_id=0 or ss.id=su.shop_id)',
            self.current_user.supplier_id, self.current_user.id)
        if int(shop_id) not in [i.id for i in all_shops]:
            self.write({'ok': False, 'msg': u'对不起,您无权执行此操作'})
            return

        is_our_coupon = False
        coupon_length = 0
        messages = PropDict()  # 用来存不同的手机号对应的券号
        #检测长度是否相同、是否是我们的券
        for coupon_sn in coupon_list:
            coupon = self.db.get(
                'select id, sn, mobile from item_coupon where sn=%s',
                coupon_sn)
            if coupon:
                is_our_coupon = True
            if coupon_length == 0:
                coupon_length = len(coupon_sn)
            elif coupon_length != len(coupon_sn):
                coupon_length = -1
        if coupon_length == -1:
            self.write({'ok': False, 'msg': u'券号长度必须一致'})
            return

        result_list = []
        if is_our_coupon:
            # 我们自己的券
            for coupon_sn in coupon_list:
                #  本地检测
                check_result = local_check(self.db, coupon_sn, shop_id)
                if not check_result.ok:
                    ok, msg = (False, check_result.msg)
                else:
                    #  合作伙伴API验证
                    api_result = yield partner_api_verify(self.db, coupon_sn)
                    if not api_result.ok:
                        ok, msg = (False, api_result.msg)
                    else:
                        #  本地验证
                        verify_result = local_verify(self.db, coupon_sn,
                                                     shop_id,
                                                     self.current_user.name)
                        ok, msg = (verify_result.ok, verify_result.msg)
                        # 验证通过,记录需要发送确认短信的券
                        if ok:
                            if messages.get(str(check_result.coupon.mobile)):
                                # 手机号已存在,添加券号到对应手机号
                                messages.get(str(
                                    check_result.coupon.mobile)).append(
                                        str(coupon_sn))
                            else:
                                # 手机号不存在,新建K-V对
                                messages.update({
                                    str(check_result.coupon.mobile):
                                    [str(coupon_sn)]
                                })

                result_list.append({
                    'coupon_sn': coupon_sn,
                    'ok': ok,
                    'msg': msg
                })
        else:
            mobile = self.get_argument('mobile', '')
            # 检查手机号合法性
            mobile_ptn = re.compile('^1[\d+]{10}$')
            if not re.match(mobile_ptn, mobile):
                # 不合法手机号,不记录
                mobile = ''

            # 尝试外部验证
            results = yield partner_browser_verify(self.db, coupon_list,
                                                   shop_id)
            for result in results:
                if result.ok:
                    goods_info = self.db.get(
                        'select g.* from goods g where id=%s', result.goods_id)
                    verify_infos = {
                        'goods_id': result.goods_id,
                        'shop_id': shop_id
                    }
                    #创建分销订单
                    distributor_order_id = self.db.execute(
                        'insert into distributor_order(order_no, message, distributor_shop_id, created_at) '
                        'values (%s, %s, %s, NOW())', result.coupon_sn,
                        json_dumps(verify_infos), result.distributor_shop_id)
                    order_id, order_no = new_distributor_order(
                        self.db, result.distributor_shop_id,
                        goods_info.sales_price, goods_info.sales_price, mobile)
                    #记录订单信息
                    new_order = new_distributor_item(
                        db=self.db,
                        order_id=order_id,
                        order_no=order_no,
                        sales_price=None,
                        count=1,
                        goods_info=goods_info,
                        mobile=mobile,
                        distributor_shop_id=result.distributor_shop_id,
                        distributor_goods_id='',
                        distributor_coupons=[{
                            'coupon_sn':
                            result.coupon_sn,
                            'coupon_pwd':
                            result.coupon_pwd or ''
                        }],
                        use_distributor_coupon=True)
                    if new_order.ok:
                        #更新分销订单id
                        self.db.execute(
                            'update orders set distributor_order_id=%s where id = %s',
                            distributor_order_id, order_id)
                        #更新订单id
                        self.db.execute(
                            'update distributor_order set order_id=%s where id=%s',
                            order_id, distributor_order_id)
                        #更新该券验证的门店
                        self.db.execute(
                            'update item set sp_shop_id = %s where order_id=%s',
                            shop_id, order_id)
                        self.redis.lpush(
                            options.queue_coupon_local_verify,
                            json_dumps({
                                'coupon': result.coupon_sn,
                                'shop_id': shop_id,
                                'retry': 0,
                                'used_at': datetime.now()
                            }))
                result_list.append({
                    'coupon_sn': result.coupon_sn,
                    'coupon_pwd': result.coupon_pwd or '',
                    'ok': result.ok,
                    'msg': result.msg
                })

        # 如果有合法券号,发送确认短信
        if messages:
            shop_name = self.db.get(
                'select name from supplier_shop where id=%s', shop_id).name
            for mobile, coupon_sns in messages.items():
                CouponConsumedMessage(self.redis, coupon_sns, shop_name,
                                      mobile).send()

        self.write({'ok': True, 'result': result_list})
Example #12
0
def taobao_order(db, redis, distributor_order_id, message_raw):
    """
    处理淘宝的分销订单队列
    :param db
    :param redis
    :param distributor_order_id: 分销订单id
    :param message_raw: redis 队列元素值
    :type db:torndb.Connection
    :type redis:redis.client.StrictRedis
    :type distributor_order_id: int
    """

    distributor_order = db.get('select * from distributor_order where id=%s', distributor_order_id)
    params = json.loads(distributor_order.message, object_hook=json_hook)
    shop = db.get('select * from distributor_shop where taobao_seller_id=%s', params.taobao_sid)
    api_info = json.loads(shop.taobao_api_info, object_hook=json_hook)
    if not distributor_order.order_id:
        # 如果还没生成一百券订单
        goods_link_id = int(params.outer_iid)
        # 找到关联的商品
        goods_info = db.get('select g.* from goods g, goods_distributor_shop gds '
                            'where g.id = gds.goods_id and distributor_shop_id=%s and goods_link_id=%s',
                            shop.id, goods_link_id)
        if not goods_info and goods_link_id < 20000:
            goods_info = db.get('select g.* from goods g where g.type="E" and g.id=%s', goods_link_id)

        if not goods_info:
            logging.error('taobao order consume failed: goods not found. link_id: %s', goods_link_id)
            return

        taobao = Taobao('taobao.trade.get')
        taobao.set_app_info(api_info.app_key, api_info.app_secret_key)
        taobao.set_session(api_info.session)
        response = taobao.sync_fetch(tid=distributor_order.order_no,
                                     fields='total_fee,payment,orders.payment,orders.num,'
                                            'orders.sku_properties_name,orders.price')
        taobao.parse_response(response)

        order_payment = Decimal(taobao.message.trade.payment)
        # 创建订单
        order_id, order_no = new_distributor_order(db, shop.id, Decimal(taobao.message.trade.total_fee),
                                                   order_payment, params.mobile)
        result = new_distributor_item(db, order_id, order_no, order_payment / int(params.num),
                                      int(params.num), goods_info, params.mobile, shop.id, params.num_iid, None, False)

        if not result.ok:
            logging.error('taobao order consume failed. %s', result.msg)
            return
        else:
            db.execute('update orders set distributor_order_id=%s where id = %s',
                       distributor_order_id, result.order_id)
            db.execute('update distributor_order set order_id=%s where id=%s',
                       result.order_id, distributor_order_id)
        ktv_order_result = create_ktv_order(db, order_id, params)
    else:
        order_id = distributor_order.order_id
        ktv_order_result = []

    coupons = db.query('select c.sn as coupon_sn from item i, item_coupon c where i.id=c.item_id and i.order_id=%s',
                       order_id)

    # 告诉淘宝我们已发货
    taobao = Taobao('taobao.vmarket.eticket.send')
    taobao.set_app_info(api_info.app_key, api_info.app_secret_key)
    if api_info.app_key == options.taobao_kunran_app_key:  # 如果是码商,要加上码商的信息
        taobao.add_field('codemerchant_id', options.taobao_kunran_id)
        taobao.set_session(api_info.merchant_session)
    else:
        taobao.set_session(api_info.session)
    response = taobao.sync_fetch(order_id=params.order_id, token=params.token,
                                 verify_codes=','.join(['%s:1' % item.coupon_sn for item in coupons]))
    logging.info('tell taobao coupon send response: %s', response)
    taobao.parse_response(response)

    if taobao.is_ok():
        logging.info('taobao order complete. distributor_order_id: %s', distributor_order_id)
        all_order_items = db.query('select * from order_item where order_id=%s', order_id)
        for item in all_order_items:
            CouponSMSMessage(db, redis, order_item=item).remark('淘宝订单短信发送').send()
        redis.lrem(options.queue_distributor_order_processing, 0, message_raw)
        #只要ktv预订时间有,就给门店经理发送ktv预订的包厢信息
        for ktv_info in ktv_order_result:
            sku = ktv_info['sku']
            phone_numbers = ktv_info['manager_mobile']
            for phone in (phone_numbers.split(',') if phone_numbers else []):
                content = str(sku.date) + ktv_info['shop_name'] + '预订【' + str(params.mobile) + \
                    sku.room_name + " (" + str(params.num) + "间)" + sku.human_time_range + "】"
                #给经理发送短信告知预订信息
                logging.info('send message to manager,phone:%s,content:%s', phone, content)
                SMSMessage(content, phone).send(redis)
    else:
        logging.error('tell taobao coupon send failed: %s', taobao.error)