def handle(self, *args, **options):
"""
从今年3月1日开始，当天有活跃就增加1天妈妈截止日期
"""
start_date = datetime.date(2016, 3, 1)
end_date = datetime.date(2016, 7, 10)
activites = ActiveValue.objects.filter(date_field__gte=start_date,
date_field__lte=end_date)
mms = XiaoluMama.objects.filter(status=XiaoluMama.EFFECT,
agencylevel__gte=XiaoluMama.VIP_LEVEL,
charge_status=XiaoluMama.CHARGED)
print "mama count is %s" % mms.count()
data_0 = []
data_1 = []
for mm in mms:
renewdays = len(
activites.filter(
mama_id=mm.id).values('date_field').distinct()) # 活跃天数
dic = {"mm": mm.id, "days": renewdays}
if mm.id % 100 == 0:
print 'mm id %s , old renew date is %s , renew days is %s .' % (
mm.id, mm.renew_time, renewdays)
data_1.append(dic) if renewdays > 0 else data_0.append(dic)
if isinstance(mm.renew_time, datetime.datetime) and renewdays > 0:
mm.renew_time = mm.renew_time + datetime.timedelta(
days=renewdays)
update_model_fields(mm, update_fields=['renew_time'])
print "0 days mm count %s" % len(data_0)
print "n days mm count %s" % len(data_1)
def task_Update_Weixin_Userinfo(openId, unionId=None, userinfo={}, accessToken=None):
""" 通过接口获取用户信息 """
_wx_api = WeiXinAPI()
if accessToken and not userinfo:
userinfo = options.get_weixin_snsuserinfo(openId, accessToken)
elif not userinfo:
userinfo = _wx_api.getUserInfo(openId)
wx_user, state = WeiXinUser.objects.get_or_create(openid=openId)
pre_subscribe_time = wx_user.subscribe_time
pre_nickname = wx_user.nickname
for k, v in userinfo.iteritems():
if hasattr(wx_user, k) and v:
setattr(wx_user, k, v or getattr(wx_user, k))
wx_user.nickname = pre_nickname or replace_utf8mb4(wx_user.nickname.decode('utf8'))
wx_user.unionid = wx_user.unionid or unionId or ''
subscribe_time = userinfo.get('subscribe_time', None)
if subscribe_time:
wx_user.subscribe_time = pre_subscribe_time or datetime.datetime \
.fromtimestamp(int(subscribe_time))
key_list = ['openid', 'sex', 'language', 'headimgurl', 'country', 'province', 'nickname', 'unionid',
'subscribe_time', 'sceneid']
update_model_fields(wx_user, update_fields=key_list)
if not wx_user.unionid:
return
app_key = _wx_api._wx_account.app_id
WeixinUnionID.objects.get_or_create(openid=openId, app_key=app_key, unionid=wx_user.unionid)
def task_notify_package_post(package_order):
"""
:param package_order: PackageOrder instance
功能: 用户的订单发货了, 发送发货的短信通知 , package_order 称重的时候触发此任务执行.
"""
package_sku_item = package_order.package_sku_items.filter(
assign_status=2).first()
if not package_sku_item:
return
now = datetime.datetime.now()
delay_days = (now - package_sku_item.pay_time).days
if delay_days <= 3:
sms_notify_type = SMS_TYPE.SMS_NOTIFY_POST
else:
sms_notify_type = SMS_TYPE.SMS_NOTIFY_DELAY_POST
mobiles = package_order.receiver_mobile
params = {
'sms_title': package_sku_item.title.split("/")[0],
'sms_delay': '%d' % delay_days,
'sms_logistic': package_order.logistics_company.name,
'sms_logistic_no': package_order.out_sid,
'sms_tips': '',
}
success = send_sms_message(mobiles, msg_type=sms_notify_type, **params)
if success:
package_order.is_send_sms = True
update_model_fields(package_order, update_fields=['is_send_sms'])
def updatePubTime(self, userId, trade, modified):
if not isinstance(trade, self.model):
trade = self.get(user__visitor_id=userId, tid=trade)
trade.modified = modified
update_model_fields(trade, update_fields=['modified'])
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG INIT:%s' % merge_trade)
log_action(merge_trade.user.user.id, merge_trade, ADDITION, u'订单入库')
merge_trade.ware_by = merge_trade.get_trade_assign_ware()
merge_trade.sys_status = pcfg.REGULAR_REMAIN_STATUS
if merge_trade.ware_by == WARE_NONE:
merge_trade.sys_memo += '，请选择所属仓库'
merge_trade.append_reason_code(pcfg.NEW_MEMO_CODE)
update_model_fields(
merge_trade, update_fields=['sys_status', 'ware_by', 'sys_memo'])
def releaseRegularOutstockTrade(trade, num_maps=None):
""" 释放特卖定时订单 """
trade_out_stock = False
full_out_stock = True
tnum_maps = {}
ware_set = set()
code_defect = False
for order in trade.normal_orders:
try:
bar_code = order.outer_id + order.outer_sku_id
tnum_maps[bar_code] = tnum_maps.get(bar_code, 0) + order.num
plus_num = num_maps.get(bar_code, 0) + tnum_maps[bar_code]
out_stock = not Product.objects.isProductOutingStockEnough(
order.outer_id,
order.outer_sku_id,
plus_num)
order.out_stock = out_stock
order.save()
trade_out_stock |= out_stock
full_out_stock &= out_stock
prduct_ware = Product.objects.get(outer_id=order.outer_id).ware_by
ware_set.add(prduct_ware)
except Product.ProductCodeDefect:
code_defect = True
continue
t = MergeTrade.objects.get(id=trade.id)
if trade_out_stock:
t.append_reason_code(pcfg.OUT_GOOD_CODE)
if len(ware_set) == 1:
t.ware_by = ware_set.pop()
else:
t.ware_by = WARE_NONE
t.sys_memo += u'[物流：请拆单或选择始发仓]'
t.append_reason_code(pcfg.DISTINCT_RULE_CODE)
if t.reason_code:
if not code_defect and full_out_stock:
t.sys_status = pcfg.REGULAR_REMAIN_STATUS
else:
t.sys_status = pcfg.WAIT_AUDIT_STATUS
for code, num in tnum_maps.iteritems():
num_maps[code] = num_maps.get(code, 0) + num
else:
t.sys_status = pcfg.WAIT_PREPARE_SEND_STATUS
update_model_fields(t, update_fields=['sys_status', 'sys_memo', 'ware_by'])
if t.sys_status in (pcfg.WAIT_AUDIT_STATUS, pcfg.WAIT_PREPARE_SEND_STATUS):
oauser = User.getSystemOAUser()
log_action(oauser.id, t, CHANGE, u'到货释放订单')
return t
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG DEFECT:%s' % merge_trade)
merge_trade.append_reason_code(pcfg.TRADE_DEFECT_CODE)
for order in merge_trade.inuse_orders:
if MergeTrade.objects.isOrderDefect(order.outer_id,
order.outer_sku_id):
order.is_rule_match = True
update_model_fields(order, update_fields=['is_rule_match'])
post_save.send(sender=MergeOrder, instance=order)
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG STOCKOUT:%s' % merge_trade)
merge_trade.append_reason_code(pcfg.OUT_GOOD_CODE)
for order in merge_trade.inuse_orders:
if Product.objects.isProductOutOfStock(order.outer_id,
order.outer_sku_id) or \
self.isOutStockByTitle(order):
order.out_stock = True
update_model_fields(order, update_fields=['out_stock'])
post_save.send(sender=MergeOrder, instance=order)
def handle(self, *args, **options):
"""
更新（不能使用保存） 交易统计明细列表 中的选品字段
"""
from statistics.tasks import get_product
records = SaleOrderStatsRecord.objects.all()
print "records count is %s:" % records.count()
for record in records:
product = get_product(record.outer_id)
if product:
record.sale_product = product.sale_product
update_model_fields(record, update_fields=['sale_product'])
else:
print "record %s product not found" % record.id
def mergeRemover(trade):
from shopapp.memorule.services import ruleMatchPayment
if not isinstance(trade, MergeTrade):
trade = MergeTrade.objects.get(id=trade)
trade_id = trade.id
if not trade.has_merge:
return False
trade.remove_reason_code(pcfg.NEW_MERGE_TRADE_CODE)
trade.has_merge = False
trade.merge_orders.filter(is_merge=True).delete()
sub_merges = MergeBuyerTrade.objects.filter(main_tid=trade_id)
for sub_merge in sub_merges:
sub_trade = MergeTrade.objects.get(id=sub_merge.sub_tid)
sub_trade.remove_reason_code(pcfg.NEW_MERGE_TRADE_CODE)
trade.remove_buyer_message(sub_merge.sub_tid)
trade.remove_seller_memo(sub_merge.sub_tid)
sub_trade.sys_status = pcfg.WAIT_AUDIT_STATUS
update_model_fields(sub_trade, update_fields=['sys_status'])
log_action(trade.user.user.id, sub_trade, CHANGE, u'取消合并')
trade.payment -= sub_trade.payment
trade.post_fee -= sub_trade.post_fee
update_model_fields(trade,
update_fields=['payment', 'post_fee', 'has_merge'])
mbts = MergeBuyerTrade.objects.filter(main_tid=trade_id)
for mbt in mbts:
mbt.delete()
log_action(trade.user.user.id, trade, CHANGE, u'取消合并')
recalc_fee_signal.send(sender=MergeTrade, trade_id=trade_id)
ruleMatchPayment(trade)
return True
def isTradeNewRefund(self, trade):
if not isinstance(trade, self.model):
trade = self.get(id=trade)
refund_orders_num = trade.merge_orders.filter(
gift_type=pcfg.REAL_ORDER_GIT_TYPE,
is_merge=False) \
.exclude(refund_status__in=(pcfg.NO_REFUND,
pcfg.REFUND_CLOSED,
pcfg.EMPTY_STATUS)).count()
if refund_orders_num > trade.refund_num:
trade.refund_num = refund_orders_num
update_model_fields(trade, update_fields=['refund_num'])
return True
return False
def ShipTrade(self, oid, *args, **kwargs):
self.bservice.shipTrade(oid, *args, **kwargs)
self.trade.merge_orders.filter(oid=oid) \
.update(status=pcfg.WAIT_BUYER_CONFIRM_GOODS)
if self.trade.merge_orders.filter(
sys_status=pcfg.IN_EFFECT,
gift_type=pcfg.REAL_ORDER_GIT_TYPE,
status=pcfg.WAIT_SELLER_SEND_GOODS).count() > 0:
return
self.trade.merge_orders.filter(sys_status=pcfg.IN_EFFECT) \
.update(status=pcfg.WAIT_BUYER_CONFIRM_GOODS)
self.trade.status = pcfg.WAIT_BUYER_CONFIRM_GOODS
self.trade.consign_time = datetime.datetime.now()
update_model_fields(self.trade,
update_fields=['status', 'consign_time'])
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG RULE MATCH:%s' % merge_trade)
merge_trade.append_reason_code(pcfg.RULE_MATCH_CODE)
match_reason_list = []
for order in merge_trade.inuse_orders:
if MergeTrade.objects.isOrderRuleMatch(order):
order.is_rule_match = True
update_model_fields(order, update_fields=['is_rule_match'])
match_reason_list.append(
Product.objects.getProductMatchReason(
order.outer_id, order.outer_sku_id))
merge_trade.sys_memo = u'%s,匹配原因:%s' % (merge_trade.sys_memo,
','.join(match_reason_list))
update_model_fields(merge_trade, update_fields=['sys_memo'])
post_save.send(sender=MergeOrder, instance=order)
def _createAndCalcOrderFee(trade, sub_trade):
payment = 0
total_fee = 0
discount_fee = 0
adjust_fee = 0
for order in sub_trade.merge_orders.all():
merge_order, state = MergeOrder.objects.get_or_create(
oid=order.oid, merge_trade=trade)
for field in order._meta.fields:
if field.name not in ('id', 'oid', 'merge_trade'):
setattr(merge_order, field.name, getattr(order, field.name))
if state:
merge_order.is_merge = state
if MergeOrder.NORMAL in (order.sys_status, merge_order.sys_status):
merge_order.sys_status = MergeOrder.NORMAL
else:
merge_order.sys_status = MergeOrder.DELETE
merge_order.is_reverse_order = trade.isPostScan()
merge_order.created = order.created
merge_order.pay_time = order.pay_time
merge_order.save()
if order.isEffect():
payment += order.payment
total_fee += order.total_fee
discount_fee += order.discount_fee
adjust_fee += order.adjust_fee
trade.payment += payment
trade.total_fee += total_fee
trade.discount_fee += discount_fee
trade.adjust_fee += adjust_fee
trade.post_fee = sub_trade.post_fee + trade.post_fee
update_model_fields(trade,
update_fields=[
'payment', 'total_fee', 'discount_fee',
'adjust_fee', 'post_fee'
])
def handle(self, *args, **options):
"""
更新（不能使用保存） 交易统计明细列表 中的pay_time字段
"""
date_froms = options.get('date_from')
date_tos = options.get('date_to')
if date_froms and date_tos:
date_from = date_froms[0]
date_to = date_tos[0]
from flashsale.pay.models import SaleOrder
orders = SaleOrder.objects.filter(created__gte=date_from,
created__lte=date_to)
print "orders count is %s:" % orders.count()
records = SaleOrderStatsRecord.objects.all()
for order in orders:
record = records.filter(oid=order.oid).first()
if record:
record.pay_time = order.pay_time if order.pay_time else order.created
update_model_fields(record, ['pay_time'])
else:
print "record not found order id %s" % order.id
def task_update_mamafortune_mama_level(relationship):
#print "%s, mama_id: %s" % (get_cur_info(), mama_id)
from flashsale.xiaolumm.models import XiaoluMama
from_mama_id = relationship.referal_from_grandma_id
invite_num = ReferalRelationship.objects.filter(
referal_from_mama_id=from_mama_id,
referal_type__gte=XiaoluMama.HALF).count()
group_num = ReferalRelationship.objects.filter(
referal_from_grandma_id=from_mama_id,
referal_type__gte=XiaoluMama.HALF).exclude(
referal_to_mama_id=relationship.referal_to_mama_id).count()
total = invite_num + group_num + 1
level = 0
if invite_num >= 15 or total >= 50:
level = 1
if total >= 200:
level = 2
if total >= 500:
level = 3
if total >= 1000:
level = 4
mama = MamaFortune.objects.filter(mama_id=from_mama_id).first()
if mama:
if mama.mama_level != level:
mama.mama_level = level
update_model_fields(mama, update_fields=['mama_level'])
else:
try:
create_mamafortune_with_integrity(from_mama_id, mama_level=level)
except IntegrityError as exc:
logger.warn(
"IntegrityError - MamaFortune mamalevel | mama_id: %s" %
(from_mama_id))
raise task_update_mamafortune_mama_level.retry(exc=exc)
def createMergeTrade(cls, trade, *args, **kwargs):
tid = trade.id
update_address = False
merge_trade, state = MergeTrade.objects.get_or_create(
user=trade.user, tid=tid, type=pcfg.TAOBAO_TYPE)
update_fields = [
'buyer_nick', 'is_force_wlb', 'seller_cod_fee', 'buyer_cod_fee',
'cod_fee', 'cod_status', 'seller_flag', 'created', 'pay_time',
'modified', 'consign_time', 'send_time', 'status', 'is_brand_sale',
'is_lgtype', 'lg_aging', 'lg_aging_type', 'buyer_rate',
'seller_rate', 'seller_can_rate', 'is_part_consign',
'step_paid_fee', 'step_trade_status'
]
if not merge_trade.receiver_name and trade.receiver_name:
update_address = True
address_fields = [
'receiver_name', 'receiver_state', 'receiver_city',
'receiver_district', 'receiver_address', 'receiver_zip',
'receiver_mobile', 'receiver_phone'
]
update_fields.extend(address_fields)
for k in update_fields:
setattr(merge_trade, k, getattr(trade, k))
merge_trade.is_cod = trade.type == pcfg.COD_TYPE
merge_trade.payment = merge_trade.payment or trade.payment
merge_trade.total_fee = merge_trade.total_fee or trade.total_fee
merge_trade.discount_fee = merge_trade.discount_fee or trade.discount_fee
merge_trade.adjust_fee = merge_trade.adjust_fee or trade.adjust_fee
merge_trade.post_fee = merge_trade.post_fee or trade.post_fee
merge_trade.trade_from = MergeTrade.objects.mapTradeFromToCode(
trade.trade_from)
merge_trade.shipping_type = (merge_trade.shipping_type
or pcfg.SHIPPING_TYPE_MAP.get(
trade.shipping_type,
pcfg.EXPRESS_SHIPPING_TYPE))
update_model_fields(
merge_trade,
update_fields=update_fields + [
'is_cod', 'shipping_type', 'payment', 'total_fee',
'discount_fee', 'adjust_fee', 'post_fee', 'trade_from'
])
for order in trade.trade_orders.all():
cls.createMergeOrder(merge_trade, order)
trade_handler.proccess(
merge_trade, **{
'origin_trade':
trade,
'update_address':
(update_address
and merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS),
'first_pay_load':
(merge_trade.sys_status == pcfg.EMPTY_STATUS
and merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS)
})
return merge_trade
def process_trade_notify_task(id):
""" 处理交易主动通知信息 """
try:
notify = TradeNotify.objects.get(id=id)
# 如果是分销部分订单，主动通知不做处理
if notify.type != pcfg.FENXIAO_TYPE:
# 订单创建，修改，关闭，则重新下载该订单，并对订单价格进行修改
if notify.status in ('TradeCreate',
'TradeCloseAndModifyDetailOrder'):
if (notify.type != pcfg.COD_TYPE
and MergeTrade.judge_need_pull(notify.tid,
notify.modified)):
response = apis.taobao_trade_get(tid=notify.tid,
tb_user_id=notify.user_id)
trade_dict = response['trade_get_response']['trade']
trade_modify = datetime.datetime.strptime(
trade_dict['modified'], '%Y-%m-%d %H:%M:%S')
if MergeTrade.judge_need_pull(notify.tid, trade_modify):
trade = Trade.save_trade_through_dict(
notify.user_id, trade_dict)
# 货到付款处理
elif notify.type == pcfg.COD_TYPE:
response = apis.taobao_trade_fullinfo_get(
tid=notify.tid, tb_user_id=notify.user_id)
trade_dict = response['trade_fullinfo_get_response'][
'trade']
trade = Trade.save_trade_through_dict(
notify.user_id, trade_dict)
if notify.type != pcfg.COD_TYPE:
# 修改订单价格
modify_fee_signal.send(sender='modify_post_fee',
user_id=notify.user_id,
trade_id=notify.tid)
# 修改交易备注
elif notify.status == 'TradeMemoModified':
try:
trade = MergeTrade.objects.get(tid=notify.tid)
except MergeTrade.DoesNotExist, exc:
response = apis.taobao_trade_fullinfo_get(
tid=notify.tid, tb_user_id=notify.user_id)
trade_dict = response['trade_fullinfo_get_response'][
'trade']
trade = Trade.save_trade_through_dict(
notify.user_id, trade_dict)
else:
# 如果交易存在，并且等待卖家发货
response = apis.taobao_trade_fullinfo_get(
tid=notify.tid,
fields='tid,buyer_message,seller_memo,seller_flag',
tb_user_id=notify.user_id)
trade_dict = response['trade_fullinfo_get_response'][
'trade']
buyer_message = trade_dict.get('buyer_message', '')
seller_memo = trade_dict.get('seller_memo', '')
seller_flag = trade_dict.get('seller_flag', 0)
# 如果消息没有抓取到，则重试
if trade.status in (pcfg.WAIT_BUYER_PAY, pcfg.WAIT_SELLER_SEND_GOODS, pcfg.WAIT_BUYER_CONFIRM_GOODS) \
and trade.buyer_message == buyer_message and trade.seller_memo == seller_memo and not seller_memo:
raise EmptyMemo('empty memo modified notify:%d' %
notify.tid)
Trade.objects.filter(id=notify.tid).update(
modified=notify.modified,
buyer_message=buyer_message,
seller_memo=seller_memo,
seller_flag=seller_flag)
merge_type = MergeBuyerTrade.get_merge_type(trade.tid)
trade.modified = notify.modified
trade.seller_flag = seller_flag
trade.buyer_message = buyer_message
if merge_type == 0:
trade.seller_memo = seller_memo
trade.save()
elif merge_type == 2:
trade.save()
trade.update_seller_memo(notify.tid, seller_memo)
elif merge_type == 1:
trade.seller_memo = seller_memo
try:
main_tid = MergeBuyerTrade.objects.get(
sub_tid=notify.tid).main_tid
except MergeBuyerTrade.DoesNotExist:
pass
else:
main_trade = MergeTrade.objects.get(tid=main_tid)
main_trade.update_seller_memo(
notify.tid, seller_memo)
main_trade.has_memo = True
update_model_fields(main_trade,
update_fields=[
'has_memo',
])
main_trade.append_reason_code(pcfg.NEW_MEMO_CODE)
if trade.seller_memo:
trade.has_memo = True
update_model_fields(trade,
update_fields=[
'has_memo', 'seller_memo',
'seller_flag', 'modified'
])
trade.append_reason_code(pcfg.NEW_MEMO_CODE)
# 交易关闭
elif notify.status == 'TradeClose':
Trade.objects.filter(id=notify.tid).update(
status=pcfg.TRADE_CLOSED, modified=notify.modified)
Order.objects.filter(trade=notify.tid).update(
status=pcfg.TRADE_CLOSED)
MergeTrade.objects.filter(tid=notify.tid).update(
status=pcfg.TRADE_CLOSED, modified=notify.modified)
MergeTrade.objects.filter(tid=notify.tid).exclude(
sys_status__in=('', pcfg.FINISHED_STATUS)).update(
sys_status=pcfg.INVALID_STATUS)
MergeOrder.objects.filter(tid=notify.tid).update(
status=pcfg.TRADE_CLOSED)
try:
merge_trade = MergeTrade.objects.get(tid=notify.tid)
except:
pass
else:
if merge_trade.sys_status == pcfg.INVALID_STATUS and merge_trade.has_merge:
merge_order_remover(notify.tid)
# 买家付款
elif notify.status == 'TradeBuyerPay':
response = apis.taobao_trade_fullinfo_get(
tid=notify.tid, tb_user_id=notify.user_id)
trade_dict = response['trade_fullinfo_get_response']['trade']
trade = Trade.save_trade_through_dict(notify.user_id,
trade_dict)
# 卖家发货
elif notify.status == 'TradeSellerShip':
Trade.objects.filter(id=notify.tid).update(
status=pcfg.WAIT_BUYER_CONFIRM_GOODS,
modified=notify.modified,
consign_time=notify.modified)
Order.objects.filter(
trade=notify.tid,
status=pcfg.WAIT_SELLER_SEND_GOODS).update(
status=pcfg.WAIT_BUYER_CONFIRM_GOODS)
MergeTrade.objects.filter(tid=notify.tid).update(
status=pcfg.WAIT_BUYER_CONFIRM_GOODS,
modified=notify.modified)
MergeTrade.objects.filter(
tid=notify.tid,
sys_status__in=(pcfg.WAIT_AUDIT_STATUS,
pcfg.WAIT_PREPARE_SEND_STATUS,
pcfg.REGULAR_REMAIN_STATUS),
out_sid='').exclude(
shipping_type=pcfg.EXTRACT_SHIPPING_TYPE).update(
sys_status=pcfg.INVALID_STATUS)
MergeOrder.objects.filter(
tid=notify.tid, status=pcfg.WAIT_SELLER_SEND_GOODS).update(
status=pcfg.WAIT_BUYER_CONFIRM_GOODS)
try:
merge_trade = MergeTrade.objects.get(tid=notify.tid)
except:
pass
else:
if merge_trade.sys_status == pcfg.INVALID_STATUS and merge_trade.has_merge:
merge_order_remover(notify.tid)
# 交易成功
elif notify.status == 'TradeSuccess':
Trade.objects.filter(id=notify.tid).update(
status=pcfg.TRADE_FINISHED, modified=notify.modified)
Order.objects.filter(
trade=notify.tid,
status=pcfg.WAIT_BUYER_CONFIRM_GOODS).update(
status=pcfg.TRADE_FINISHED)
MergeTrade.objects.filter(tid=notify.tid).update(
status=pcfg.TRADE_FINISHED, modified=notify.modified)
MergeTrade.objects.filter(
tid=notify.tid,
sys_status__in=pcfg.WAIT_DELIVERY_STATUS).update(
sys_status=pcfg.INVALID_STATUS)
MergeOrder.objects.filter(
tid=notify.tid,
status=pcfg.WAIT_BUYER_CONFIRM_GOODS).update(
status=pcfg.TRADE_FINISHED)
# 修改地址
elif notify.status == 'TradeLogisticsAddressChanged':
trade = MergeTrade.objects.get(tid=notify.tid)
response = apis.taobao_logistics_orders_get(
tid=notify.tid, tb_user_id=notify.user_id)
ship_dict = response['logistics_orders_get_response'][
'shippings']['shipping'][0]
Logistics.save_logistics_through_dict(notify.user_id,
ship_dict)
trade.append_reason_code(pcfg.ADDR_CHANGE_CODE)
MergeTrade.objects.filter(tid=notify.tid).update(
receiver_name=ship_dict['receiver_name'],
receiver_state=ship_dict['receiver_state'],
receiver_city=ship_dict['receiver_city'],
receiver_district=ship_dict['receiver_district'],
receiver_address=ship_dict['receiver_address'],
receiver_zip=ship_dict['receiver_zip'],
receiver_mobile=ship_dict['receiver_mobile'],
receiver_phone=ship_dict['receiver_phone'])
try:
main_tid = MergeBuyerTrade.objects.filter(
sub_tid=trade.tid).main_tid
except:
pass
else:
main_trade = MergeTrade.objects.get(tid=main_tid)
main_trade.append_reason_code(pcfg.ADDR_CHANGE_CODE)
except Exception, exc:
raise process_trade_notify_task.retry(exc=exc, countdown=60)
def remindTrade(self, *args, **kwargs):
self.trade.priority = pcfg.PRIORITY_HIG
update_model_fields(self.trade, update_fields=['priority'])
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG FINAL:%s' % merge_trade)
if (merge_trade.sys_status != pcfg.EMPTY_STATUS
and not merge_trade.logistics_company):
merge_trade.append_reason_code(pcfg.LOGISTIC_ERROR_CODE)
if (merge_trade.logistics_company
and merge_trade.has_reason_code(pcfg.LOGISTIC_ERROR_CODE)):
merge_trade.remove_reason_code(pcfg.LOGISTIC_ERROR_CODE)
if ((merge_trade.reason_code and not merge_trade.is_locked
and merge_trade.sys_status == pcfg.WAIT_PREPARE_SEND_STATUS)
or (merge_trade.sys_status == pcfg.REGULAR_REMAIN_STATUS
and merge_trade.remind_time == None)):
merge_trade.sys_status = pcfg.WAIT_AUDIT_STATUS
if (not merge_trade.reason_code
and (merge_trade.sys_status == pcfg.WAIT_AUDIT_STATUS or
(merge_trade.sys_status == pcfg.REGULAR_REMAIN_STATUS
and merge_trade.remind_time == None)) and
merge_trade.type not in (pcfg.DIRECT_TYPE, pcfg.EXCHANGE_TYPE,
pcfg.REISSUE_TYPE)):
merge_trade.sys_status = pcfg.WAIT_PREPARE_SEND_STATUS
if kwargs.get('first_pay_load', None):
for order in merge_trade.inuse_orders:
### we should comment the following line in order to retire updating waitpostnum
Product.objects.updateWaitPostNumByCode(
order.outer_id, order.outer_sku_id, order.num)
if (merge_trade.status
in (pcfg.TRADE_FINISHED, pcfg.TRADE_BUYER_SIGNED,
pcfg.TRADE_CLOSED, pcfg.TRADE_CLOSED_BY_TAOBAO)
and merge_trade.sys_status
not in (pcfg.FINISHED_STATUS, pcfg.INVALID_STATUS)):
merge_trade.append_reason_code(pcfg.INVALID_END_CODE)
if not merge_trade.is_locked:
merge_type = MergeBuyerTrade.getMergeType(merge_trade.id)
if merge_type == pcfg.SUB_MERGE_TYPE:
main_tid = MergeBuyerTrade.objects.get(
sub_tid=merge_trade.id).main_tid
main_trade = MergeTrade.objects.get(id=main_tid)
main_trade.append_reason_code(pcfg.INVALID_END_CODE)
sub_oids = [
o[0]
for o in merge_trade.merge_orders.values_list('oid')
]
main_trade.merge_orders.filter(oid__in=sub_oids) \
.update(sys_status=pcfg.INVALID_STATUS)
elif merge_type == pcfg.MAIN_MERGE_TYPE:
MergeTrade.objects.mergeRemover(merge_trade.id)
merge_trade.sys_status = pcfg.INVALID_STATUS
update_model_fields(merge_trade, update_fields=['sys_status'])
def mergeMaker(trade, sub_trade):
if not isinstance(trade, MergeTrade):
trade = MergeTrade.objects.get(id=trade)
if not isinstance(sub_trade, MergeTrade):
sub_trade = MergeTrade.objects.get(id=sub_trade)
if MergeBuyerTrade.objects.filter(sub_tid=trade.id).count() > 0:
return False
try:
mt = MergeBuyerTrade.objects.get(sub_tid=sub_trade.id)
except:
MergeBuyerTrade.objects.get_or_create(sub_tid=sub_trade.id,
main_tid=trade.id)
else:
mt.main_tid = trade.id
mt.save()
trade.append_reason_code(pcfg.MULTIPLE_ORDERS_CODE)
if (not trade.is_locked
and trade.sys_status == pcfg.WAIT_PREPARE_SEND_STATUS):
trade.sys_status = pcfg.WAIT_AUDIT_STATUS
update_model_fields(trade, update_fields=['sys_status'])
_createAndCalcOrderFee(trade, sub_trade)
if sub_trade.buyer_message or sub_trade.seller_memo or sub_trade.sys_memo:
trade.update_buyer_message(sub_trade.id, sub_trade.buyer_message)
trade.update_seller_memo(sub_trade.id,
sub_trade.seller_memo + sub_trade.sys_memo)
trade.append_reason_code(pcfg.NEW_MEMO_CODE)
if sub_trade.has_merge:
strades = MergeBuyerTrade.objects.filter(main_tid=sub_trade.id)
for strade in strades:
MergeBuyerTrade.objects.filter(sub_tid=strade.sub_tid).update(
main_tid=trade.id)
MergeOrder.objects.filter(merge_trade=sub_trade.id,
is_merge=True).delete()
for scode in sub_trade.reason_code.split(','):
trade.append_reason_code(scode)
sub_trade.append_reason_code(pcfg.NEW_MERGE_TRADE_CODE)
# 判断是否还有订单需要合并,如果没有，则去掉需合单问题编号
queryset = MergeTrade.objects.getMergeQueryset(
trade.buyer_nick,
trade.receiver_name,
trade.receiver_mobile,
trade.receiver_phone,
)
if (trade.type == MergeTrade.WX_TYPE
or queryset.filter(sys_status__in=(pcfg.WAIT_AUDIT_STATUS,
pcfg.REGULAR_REMAIN_STATUS)) \
.exclude(id__in=(sub_trade.id, trade.id)).count() == 0):
trade.remove_reason_code(pcfg.MULTIPLE_ORDERS_CODE)
log_action(trade.user.user.id, trade, CHANGE, u'合并订单（%s）' % (sub_trade.id))
if (not trade.reason_code and not trade.is_locked
and trade.sys_status == pcfg.WAIT_AUDIT_STATUS):
trade.sys_status = pcfg.WAIT_PREPARE_SEND_STATUS
else:
trade.append_reason_code(pcfg.NEW_MERGE_TRADE_CODE)
log_action(sub_trade.user.user.id, sub_trade, CHANGE,
u'并入订单（%s）' % (trade.id))
sub_trade.sys_status = pcfg.ON_THE_FLY_STATUS
update_model_fields(sub_trade, update_fields=['sys_status'])
trade.has_merge = True
update_model_fields(trade, update_fields=['has_merge', 'sys_status'])
return True
def syncStockByWxShopTask(wx_product):
from shopback.items.models import Product, ProductSku, ItemNumTaskLog
from shopback.trades.models import MergeOrder
from shopback.users.models import User
if not isinstance(wx_product, WXProduct):
wx_product = WXProduct.objects.get(product_id=wx_product)
if not wx_product.sync_stock:
return
wx_api = WeiXinAPI()
wx_openid = wx_api.getAccountId()
wx_user = User.objects.get(visitor_id=wx_openid)
user_percent = wx_user.stock_percent
skus = wx_product.sku_list or []
for sku in skus:
if not sku.get('product_code', None):
continue
try:
outer_id, outer_sku_id = Product.objects.trancecode('',
sku['product_code'],
sku_code_prior=True)
# 特卖商品暂不同步库存
if outer_id.startswith(('1', '8', '9')) and len(outer_id) >= 9:
continue
product = Product.objects.get(outer_id=outer_id)
product_sku = ProductSku.objects.get(outer_id=outer_sku_id,
product__outer_id=outer_id)
except:
continue
if not (wx_user.sync_stock and product.sync_stock and product_sku.sync_stock):
continue
wait_nums = (product_sku.wait_post_num > 0 and
product_sku.wait_post_num or 0)
remain_nums = product_sku.remain_num or 0
real_num = product_sku.quantity
sync_num = real_num - wait_nums - remain_nums
# 如果自动更新库存状态开启，并且计算后库存不等于在线库存，则更新
if sync_num > 0 and user_percent > 0:
sync_num = int(user_percent * sync_num)
elif sync_num > 0 and sync_num <= product_sku.warn_num:
total_num, user_order_num = MergeOrder.get_yesterday_orders_totalnum(wx_user.id,
outer_id,
outer_sku_id)
if total_num > 0 and user_order_num > 0:
sync_num = int(float(user_order_num) / float(total_num) * sync_num)
else:
sync_num = (real_num - wait_nums) > 10 and 2 or 0
elif sync_num > 0:
product_sku.is_assign = False
update_model_fields(product_sku, update_fields=['is_assign'])
else:
sync_num = 0
# #针对小小派，测试线上库存低量促销效果
# if product.outer_id == '3116BG7':
# sync_num = product_sku.warn_num > 0 and min(sync_num,product_sku.warn_num+10) or min(sync_num,15)
#
if product_sku.is_assign:
sync_num = 0
# 同步库存数不为0，或者没有库存警告，同步数量不等于线上库存，并且店铺，商品，规格同步状态正确
if (sync_num != sku['quantity']):
vector_num = sync_num - sku['quantity']
if vector_num > 0:
wx_api.addMerchantStock(wx_product.product_id,
vector_num,
sku_info=sku['sku_id'])
else:
wx_api.reduceMerchantStock(wx_product.product_id,
abs(vector_num),
sku_info=sku['sku_id'])
ItemNumTaskLog.objects.get_or_create(user_id=wx_user.user.id,
outer_id=outer_id,
sku_outer_id='wx%s' % outer_sku_id,
num=sync_num,
end_at=datetime.datetime.now())
def createMergeTrade(cls, trade, *args, **kwargs):
from shopback.trades.handlers import trade_handler
from shopback.trades.models import MergeTrade
from shopback.users.models import User
seller = User.getOrCreateSeller(trade.shop.vender_id, seller_type=User.SHOP_TYPE_JD)
merge_trade, state = MergeTrade.objects.get_or_create(tid=trade.order_id,
user=seller)
update_fields = ['buyer_nick', 'created', 'pay_time', 'modified', 'status']
merge_trade.buyer_nick = trade.pin
merge_trade.created = trade.order_start_time
merge_trade.modified = trade.modified
merge_trade.pay_time = trade.payment_confirm_time
merge_trade.status = JDOrder.mapTradeStatus(trade.order_state)
update_address = False
if not merge_trade.receiver_name and trade.consignee_info:
update_address = True
receiver_info = json.loads(trade.consignee_info)
merge_trade.receiver_name = receiver_info['fullname']
merge_trade.receiver_state = receiver_info['province']
merge_trade.receiver_city = receiver_info['city']
merge_trade.receiver_district = receiver_info['county']
merge_trade.receiver_address = receiver_info['full_address']
merge_trade.receiver_mobile = receiver_info['mobile']
merge_trade.receiver_phone = receiver_info['telephone']
address_fields = ['receiver_name', 'receiver_state',
'receiver_city', 'receiver_address',
'receiver_district', 'receiver_mobile',
'receiver_phone']
update_fields.extend(address_fields)
merge_trade.payment = merge_trade.payment or float(trade.order_payment)
merge_trade.total_fee = merge_trade.total_fee or float(trade.order_total_price)
merge_trade.post_fee = merge_trade.post_fee or float(trade.freight_price)
merge_trade.trade_from = 0
merge_trade.shipping_type = pcfg.EXPRESS_SHIPPING_TYPE
merge_trade.type = pcfg.JD_TYPE
update_model_fields(merge_trade, update_fields=update_fields
+ ['shipping_type', 'type', 'payment',
'total_fee', 'post_fee', 'trade_from'])
if trade.item_info_list:
item_list = json.loads(trade.item_info_list)
for item in item_list:
cls.createMergeOrder(merge_trade, item)
trade_handler.proccess(merge_trade,
**{'origin_trade': trade,
'update_address': (update_address and
merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS),
'first_pay_load': (
merge_trade.sys_status == pcfg.EMPTY_STATUS and
merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS)})
return merge_trade
def createMergeTrade(cls, trade, *args, **kwargs):
tid = trade.id
merge_trade, state = MergeTrade.objects.get_or_create(
user=trade.user, tid=tid, type=pcfg.FENXIAO_TYPE)
update_fields = [
'buyer_nick', 'payment', 'shipping_type', 'total_fee', 'post_fee',
'created', 'trade_from', 'pay_time', 'modified', 'consign_time',
'seller_flag', 'priority', 'status'
]
if not merge_trade.receiver_name and \
trade.status not in ('',
pcfg.TRADE_NO_CREATE_PAY,
pcfg.WAIT_BUYER_PAY,
pcfg.TRADE_CLOSED,
pcfg.TRADE_CLOSED_BY_TAOBAO):
logistics = Logistics.get_or_create(trade.user.visitor_id, tid)
location = json.loads(logistics.location or 'null')
merge_trade.receiver_name = logistics.receiver_name
merge_trade.receiver_zip = location.get('zip',
'') if location else ''
merge_trade.receiver_mobile = logistics.receiver_mobile
merge_trade.receiver_phone = logistics.receiver_phone
merge_trade.receiver_state = location.get('state',
'') if location else ''
merge_trade.receiver_city = location.get('city',
'') if location else ''
merge_trade.receiver_district = location.get(
'district', '') if location else ''
merge_trade.receiver_address = location.get('address',
'') if location else ''
address_fields = [
'receiver_name', 'receiver_state', 'receiver_city',
'receiver_district', 'receiver_address', 'receiver_zip',
'receiver_mobile', 'receiver_phone'
]
update_fields.extend(address_fields)
merge_trade.payment = merge_trade.payment or trade.distributor_payment
merge_trade.total_fee = merge_trade.total_fee or trade.total_fee
merge_trade.post_fee = merge_trade.post_fee or trade.post_fee
merge_trade.buyer_nick = trade.distributor_username
merge_trade.shipping_type = merge_trade.shipping_type or \
pcfg.SHIPPING_TYPE_MAP.get(trade.shipping, pcfg.EXPRESS_SHIPPING_TYPE)
merge_trade.created = trade.created
merge_trade.pay_time = trade.created
merge_trade.modified = trade.modified
merge_trade.consign_time = trade.consign_time
merge_trade.seller_flag = trade.supplier_flag
merge_trade.priority = 0
merge_trade.status = trade.status
merge_trade.trade_from = MergeTrade.objects.mapTradeFromToCode(
pcfg.TF_TAOBAO)
update_model_fields(merge_trade, update_fields=update_fields)
# 保存分销订单到抽象全局抽象订单表
for order in trade.sub_purchase_orders.all():
cls.createMergeOrder(merge_trade, order)
trade_handler.proccess(
merge_trade, **{
'origin_trade':
trade,
'first_pay_load':
(merge_trade.sys_status == pcfg.EMPTY_STATUS
and merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS)
})
return merge_trade
def createMergeTrade(cls, trade, *args, **kwargs):
user = cls.getOrCreateSeller(trade)
merge_trade, state = MergeTrade.objects.get_or_create(
user=user, tid=trade.order_id)
update_fields = [
'buyer_nick', 'created', 'pay_time', 'modified', 'status'
]
merge_trade.buyer_nick = trade.buyer_nick or trade.receiver_name
merge_trade.created = trade.order_create_time
merge_trade.modified = trade.order_create_time
merge_trade.pay_time = trade.order_create_time
merge_trade.status = WXOrder.mapTradeStatus(trade.order_status)
update_address = False
if not merge_trade.receiver_name and trade.receiver_name:
update_address = True
merge_trade.receiver_name = trade.receiver_name
merge_trade.receiver_state = trade.receiver_province
merge_trade.receiver_city = trade.receiver_city
merge_trade.receiver_district = trade.receiver_zone
merge_trade.receiver_address = trade.receiver_address
merge_trade.receiver_mobile = trade.receiver_mobile
merge_trade.receiver_phone = trade.receiver_phone
address_fields = [
'receiver_name', 'receiver_state', 'receiver_district',
'receiver_city', 'receiver_address', 'receiver_mobile',
'receiver_phone'
]
update_fields.extend(address_fields)
merge_trade.payment = (merge_trade.payment
or round(trade.order_total_price / 100.0, 2))
merge_trade.total_fee = (merge_trade.total_fee
or round(trade.product_price / 100.0, 2) *
trade.product_count)
merge_trade.post_fee = (merge_trade.post_fee
or round(trade.order_express_price / 100.0, 2))
merge_trade.trade_from = MergeTrade.trade_from
merge_trade.shipping_type = pcfg.EXPRESS_SHIPPING_TYPE
merge_trade.type = pcfg.WX_TYPE
update_model_fields(merge_trade,
update_fields=update_fields + [
'shipping_type', 'type', 'payment',
'total_fee', 'post_fee', 'trade_from'
])
cls.createMergeOrder(merge_trade, trade)
_params = {
'origin_trade':
trade,
'update_address':
(update_address
and merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS),
'first_pay_load':
(merge_trade.sys_status == pcfg.EMPTY_STATUS
and merge_trade.status == pcfg.WAIT_SELLER_SEND_GOODS)
}
_params.update(kwargs)
if _params.get('first_pay_load'):
trade.confirm_payment()
trade_handler.proccess(merge_trade, *args, **_params)
return merge_trade