def on_committing_expire(order):
"""
卖家的确认已经过期
:param order:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onCommittingExpire')
consumer_id = order['consumerId']
order_status = order['status']
amount = order['totalPrice'] - order['discount']
if order_status == 'paid':
# 给用户发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'系统自动退款：￥%.2f' % amount,
'commodity': order['commodity']['title'],
'message': u'卖家未确认订单，系统将在两个工作日内将%.2f元退还给您。如有疑问，请咨询客服派派。' % amount
})
seller_id = order['commodity']['seller']['sellerId']
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'系统自动退款：￥%.2f' % amount,
'commodity': order['commodity']['title'],
'message': u'您未在预期时间内确认订单，系统已将%.2f元退还给买家。' % amount
})
# paid状态下的expire 需要做
apply_action(order['orderId'], consumer_id, 'paid', 'expire')
def on_refund_expire(order):
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onRefundExpire')
consumer_id = order['consumerId']
order_status = order['status']
amount = order['totalPrice'] - order['discount']
if order_status == 'refundApplied':
seller_id = order['commodity']['seller']['sellerId']
# 给买家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'系统自动退款：￥%.2f' % amount,
'commodity': order['commodity']['title'],
'message': u'卖家未处理退款申请，系统将在两个工作日内将%.2f元退还给您。如有疑问，请咨询客服派派。' % amount
})
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'系统自动退款：￥%.2f' % amount,
'commodity': order['commodity']['title'],
'message': u'您未在预期时间内处理退款申请，系统已将%.2f元退还给买家。' % amount
})
# refund_appled 状态下的 expire
apply_action(order['orderId'], consumer_id, 'refunded', 'expire')
def on_create_order(order):
"""
买家创建了订单
:param order: 订单对象
(参考:https://doc.lvxingpai.com/pages/viewpage.action?pageId=12451934#id-订单相关接口-SimpleOrder简单)
:return:
"""
consumer_id = order['consumerId']
# 订单信息
order = get_order(order['orderId'], consumer_id)
# 买家信息
consumer = get_user_info(consumer_id)
_log_order(order, 'onCreateOrder')
# 是否为开发环境
is_dev = _is_developer(consumer_id)
# 设置超时任务
now = long(time.time() * 1000)
payment_expire = now + settings.EVENT_PAYMENT_EXPIRE_TIMEOUT * 1000 \
if hasattr(settings, 'EVENT_PAYMENT_EXPIRE_TIMEOUT') and is_dev else order['expireTime']
# 过期前半小时
payment_will_expire = now + settings.EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT * 1000 \
if hasattr(settings, 'EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT') and is_dev else order['expireTime'] - 1800 * 1000
# 支付即将超时提醒
handler_url = urljoin(VIAE_GATEWAY_BASE_URL, '/tasks')
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onPaymentWillExpire',
'kwargs': {
'order': order
},
'countdown': (payment_will_expire - now) / 1000
})
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onPaymentExpire',
'kwargs': {
'order': order
},
'countdown': (payment_expire - now) / 1000
})
# 发送邮件提醒
commodity = order['commodity']
seller = commodity['seller']
send_email_to_group.apply_async(kwargs={
'groups': 'MARKETPLACE',
'subject': u'用户已创建新订单',
'body': u'订单号: #%d, 订单金额: %.2f, 商品: %d / %s, 商家: %d / %s, 买家: %d / %s' % (
order['orderId'], order['totalPrice'] - order.get('discount', 0),
commodity['commodityId'], commodity['title'],
seller['sellerId'], seller['name'],
consumer_id, consumer['nickName']
)})
def on_commit_order(order):
"""
卖家确认订单
:param order:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onCommitOrder')
consumer_id = order['consumerId']
# 给买家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'卖家已确认订单',
'commodity': order['commodity']['title'],
'message': u'卖家已确认订单，订单可使用，请于预约的出行日期前往消费。'
})
# 预约时间两天后订单完成
from pytz import timezone
rendezvous = datetime.strptime(order['rendezvousTime'], '%Y-%m-%d').replace(
tzinfo=timezone('Asia/Shanghai'))
now = long(time.time() * 1000)
epoch = datetime.utcfromtimestamp(0).replace(tzinfo=timezone('UTC'))
# 预约时间后两天
order_finish = now + settings.EVENT_PAYMENT_EXPIRE_TIMEOUT * 1000 if hasattr(
settings, 'EVENT_PAYMENT_EXPIRE_TIMEOUT') else long(
(rendezvous + timedelta(days=2) - epoch).total_seconds() * 1000)
# 预约时间之前一天
order_will_finish = now + settings.EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT * 1000 if hasattr(
settings, 'EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT') else long(
(rendezvous - timedelta(days=1) - epoch).total_seconds() * 1000)
# 订单完成的超时任务
handler_url = urljoin(VIAE_GATEWAY_BASE_URL, '/tasks')
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onOrderFinish',
'kwargs': {
'order': order
},
'countdown': (order_finish - now) / 1000
})
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onOrderWillFinish',
'kwargs': {
'order': order
},
'countdown': (order_will_finish - now) / 1000
})
def on_refund_apply(order, reason=None, memo=None):
"""
买家提出退款申请
:param order:
:param reason:
:param memo:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onRefundApply: reason=%s, memo=%s' % (reason, memo))
seller_id = order['commodity']['seller']['sellerId']
amount = order['totalPrice'] - order['discount']
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'买家申请退款（支付总额￥%.2f）' % amount,
'commodity': order['commodity']['title'],
'message': u'买家已提交退款申请（订单总额%.2f元）。请于%s前处理申请，超过处理期限系统将自动退款给买家。%s%s' %
(amount, datetime_format(order['expireTime']),
u'\n\n退款原因：%s' % reason if reason else '', u'\n\n买家留言：%s' % memo if memo else '')
})
is_dev = _is_developer(order['consumerId'])
# 设置超时任务
now = long(time.time() * 1000)
refund_expire = now + (EVENT_PAYMENT_EXPIRE_TIMEOUT if is_dev else EVENT_REFUND_EXPIRE_TIMEOUT) * 1000
# 超时前4小时
refund_will_expire = now + (EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT if is_dev else
EVENT_REFUND_WILL_EXPIRE_TIMEOUT) * 1000
# 退款即将超时提醒
handler_url = urljoin(VIAE_GATEWAY_BASE_URL, '/tasks')
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onRefundWillExpire',
'kwargs': {
'order': order,
'refund_expire': refund_expire
},
'countdown': (refund_will_expire - now) / 1000
})
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onRefundExpire',
'kwargs': {
'order': order
},
'countdown': (refund_expire - now) / 1000
})
def on_refund_deny(order, reason=None):
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onRefundDeny')
consumer_id = order['consumerId']
# 给买家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'卖家已拒绝退款申请',
'commodity': order['commodity']['title'],
'message': u'卖家已拒绝退款申请，订单可使用。请于预约的出行日期前往消费。如有疑问，请与卖家联系。%s' %
(u'\n\n卖家：%s' % reason if reason else '')
})
def on_refund_will_expire(order, refund_expire):
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onRefundWillExpire')
seller_id = order['commodity']['seller']['sellerId']
order_status = order['status']
if order_status == 'refundApplied':
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'退款处理提醒',
'commodity': order['commodity']['title'],
'message': u'该退款申请将于%s过期，超过处理期限系统将自动退款给买家，请尽快处理。' %
datetime_format(refund_expire)
})
def on_refund_approve(order, amount, with_application, memo=None):
"""
:param order: 订单
:param amount: 最终退款的金额
:param with_application: 表示这一次退款, 是买家发起的(通过提交退款申请)
:param memo:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onRefundApprove: amount=%f' % amount)
consumer_id = order['consumerId']
seller_id = order['commodity']['seller']['sellerId']
amount *= 0.01
# 给买家的文案
if with_application:
title2consumer = u'卖家已同意退款申请：￥%.2f' % amount
text2consumer = u'卖家已同意退款申请，系统将在两个工作日内将%.2f元退还给您。如有疑问，请与卖家联系。%s' % \
(amount, u'\n\n卖家：%s' % memo if memo else '')
else:
title2consumer = u'卖家已取消订单'
text2consumer = u'卖家已取消订单，系统将在两个工作日内将%.2f元退还给您。如有疑问，请与卖家联系。%s' % \
(amount, u'\n\n卖家：%s' % memo if memo else '')
# 给买家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': title2consumer,
'commodity': order['commodity']['title'],
'message': text2consumer
})
# 如果是买家提出的退款申请
if with_application:
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'退款处理完成：￥%.2f' % amount,
'commodity': order['commodity']['title'],
'message': u'您同意了买家的退款申请，系统已将%.2f元退还给买家。' % amount
})
def on_order_will_finish(order):
"""
订单即将完成
:param order:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onOrderWillFinish')
consumer_id = order['consumerId']
order_status = order['status']
if order_status == 'committed':
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'消费提醒',
'commodity': order['commodity']['title'],
'message': u'您预约了%s的特色体验，请前往消费。' % rendezvous_date_format(order['rendezvousTime'])
})
def on_payment_will_expire(order):
"""
尚未支付订单，支付流程即将超时。
:param order: 订单对象
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onPaymentWillExpire')
consumer_id = order['consumerId']
order_status = order['status']
if order_status == 'pending':
# 如果用户还没支付, 给用户发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'支付提醒',
'commodity': order['commodity']['title'],
'message': u'您的订单将于%s过期，请尽快完成支付。' % datetime_format(order['expireTime'])
})
def on_cancel_order(order, is_seller, reason=None):
"""
订单被取消
:param order:
:param is_seller:
:param reason:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onCancelOrder: %s' % is_seller)
consumer_id = order['consumerId']
if is_seller:
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'卖家已取消订单',
'commodity': order['commodity']['title'],
'message': u'卖家已取消订单。如有疑问，请与卖家联系。%s' % (u'\n\n卖家：%s' % reason if reason else '')
})
def on_committing_will_expire(order):
"""
卖家的确认将要过期
:param order: 订单对象
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onCommittingWillExpire')
seller_id = order['commodity']['seller']['sellerId']
# 给商家发送通知
order_status = order['status']
if order_status == 'paid':
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'订单确认提醒',
'commodity': order['commodity']['title'],
'message': u'该订单将于%s到期，超过退款期限系统将自动退款给买家，请尽快确认订单。' %
(datetime_format(order['expireTime']))
})
def on_order_finish(order):
"""
订单已经完成
:param order:
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onOrderFinish')
apply_action(order['orderId'], order['consumerId'], 'committed', 'finish')
seller_id = order['commodity']['seller']['sellerId']
order_status = order['status']
if order_status == 'committed':
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'订单完成',
'commodity': order['commodity']['title'],
'message': u'订单已完成，系统将在7个工作日内将%.2f元转到您的账户。' % (order['totalPrice'] - order['discount'])
})
def on_payment_expire(order):
"""
订单支付流程已超时。
:param order: 支付流程已经超时
:return:
"""
order = get_order(order['orderId'], order['consumerId'])
_log_order(order, 'onPaymentExpire')
consumer_id = order['consumerId']
order_status = order['status']
if order_status == 'pending':
# 给用户发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': consumer_id,
'order_id': order['orderId'],
'title': u'支付提醒',
'commodity': order['commodity']['title'],
'message': u'哎呀，您的订单已经过期，被系统取消。'
})
# 给骆驼发超时通知,需要panding状态下的expire 需要做.
apply_action(order['orderId'], consumer_id, 'pending', 'expire')
def on_pay_order(order):
"""
买家支付了订单
:param order: 订单对象
:return:
"""
consumer_id = order['consumerId']
# 订单信息
order = get_order(order['orderId'], consumer_id)
# 买家信息
consumer = get_user_info(consumer_id)
# 卖家信息
seller_id = order['commodity']['seller']['sellerId']
# 金额
amount = order['totalPrice'] - order['discount']
_log_order(order, 'onPayOrder')
# 是否为开发环境
is_dev = _is_developer(consumer_id)
# 给商家发送通知
send_order_message.apply_async(kwargs={
'sender': 10002,
'receiver': seller_id,
'order_id': order['orderId'],
'title': u'买家已付款：￥%.2f' % amount,
'commodity': order['commodity']['title'],
'message': u'买家已支付%s元。请于%s前确认订单，超过确认期限系统将自动退款给买家。' %
(amount, datetime_format(order['expireTime']))
})
# 设置超时任务
now = long(time.time() * 1000)
committing_expire = now + settings.EVENT_PAYMENT_EXPIRE_TIMEOUT * 1000 \
if hasattr(settings, 'EVENT_PAYMENT_EXPIRE_TIMEOUT') and is_dev else order['expireTime']
# 4小时
committing_will_expire = now + settings.EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT * 1000 \
if hasattr(settings, 'EVENT_PAYMENT_WILL_EXPIRE_TIMEOUT') and is_dev else order['expireTime'] - 4 * 3600 * 1000
# 支付即将超时提醒
handler_url = urljoin(VIAE_GATEWAY_BASE_URL, '/tasks')
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onCommittingWillExpire',
'kwargs': {
'order': order,
},
'countdown': (committing_will_expire - now) / 1000
})
requests.post(handler_url, json={
'task': 'viae.event.marketplace.onCommittingExpire',
'kwargs': {
'order': order
},
'countdown': (committing_expire - now) / 1000
})
# 发送邮件提醒
commodity = order['commodity']
seller = commodity['seller']
send_email_to_group.apply_async(kwargs={
'groups': 'MARKETPLACE',
'subject': u'用户已支付订单',
'body': u'订单号: #%d, 订单金额: %.2f, 商品: %d / %s, 商家: %d / %s, 买家: %d / %s' % (
order['orderId'], order['totalPrice'] - order.get('discount', 0),
commodity['commodityId'], commodity['title'],
seller['sellerId'], seller['name'],
consumer_id, consumer['nickName']
)})
