def ruleMatchGifts(trade):
try:
split_orders = trade.normal_orders.filter(
gift_type=pcfg.ITEM_GIFT_TYPE,
is_merge=False,
status=MergeOrder.NORMAL)
for sorder in split_orders:
# ComposeRule.objects.filter(
# outer_id__in=(sorder.outer_id,ComposeRule.PRODUCT_ALL),
# outer_sku_id__in=(sorder.outer_sku_id,ComposeRule.PRODUCT_ALL),
# type=ComposeRule.RULE_GIFTS_TYPE,
# ).update(gif_count=F('gif_count')-1,scb_count=F('scb_count')+1)
sorder.delete()
orders = trade.merge_orders.filter(
gift_type=pcfg.REAL_ORDER_GIT_TYPE,
status__in=(pcfg.WAIT_SELLER_SEND_GOODS,
pcfg.WAIT_BUYER_CONFIRM_GOODS),
is_merge=False).exclude(refund_status=pcfg.REFUND_SUCCESS)
for order in orders:
try:
compose_rule = ComposeRule.objects.get(
outer_id__in=(order.outer_id, ComposeRule.PRODUCT_ALL),
outer_sku_id__in=(order.outer_sku_id,
ComposeRule.PRODUCT_ALL),
type=ComposeRule.RULE_GIFTS_TYPE,
seller_id__in=(ComposeRule.DEFAULT_SELLER_CODE,
trade.user.id),
start_time__lte=trade.pay_time,
end_time__gte=trade.pay_time,
status=True)
except Exception, exc:
logger.debug('ruleMatchGifts:%s' % exc.message)
continue
else:
rules = compose_rule.compose_items.all()
for rule in rules:
gifts_num = rule.num * order.num
if compose_rule.gif_count >= gifts_num:
MergeOrder.gen_new_order(trade.id,
rule.outer_id,
rule.outer_sku_id,
gifts_num,
gift_type=pcfg.ITEM_GIFT_TYPE,
payment=0,
created=order.created,
pay_time=order.pay_time)
compose_rule.gif_count -= gifts_num
ComposeRule.objects.filter(id=compose_rule.id).update(
gif_count=F('gif_count') - gifts_num,
scb_count=F('scb_count') + gifts_num)
msg = u'买(oid:%s)就送(%s)' % (order.id, ','.join(
['%s-%s' % (r.outer_id, r.outer_sku_id) for r in rules]))
log_action(trade.user.user.id, trade, CHANGE, msg)
except Exception, exc:
logger.error(exc.message or 'rule gifts error', exc_info=True)
trade.append_reason_code(pcfg.COMPOSE_RULE_ERROR_CODE)
def rule_match_gifts(sender, trade_id, *args, **kwargs):
try:
trade = MergeTrade.objects.get(id=trade_id)
except MergeTrade.DoesNotExist:
pass
else:
trade.merge_orders.filter(gift_type=pcfg.ITEM_GIFT_TYPE).delete()
try:
orders = trade.merge_orders.filter(
gift_type=pcfg.REAL_ORDER_GIT_TYPE,
status__in=(pcfg.WAIT_SELLER_SEND_GOODS,
pcfg.WAIT_BUYER_CONFIRM_GOODS)).exclude(
refund_status=pcfg.REFUND_SUCCESS)
for order in orders:
outer_id = order.outer_id
outer_sku_id = order.outer_sku_id
order_num = order.num
prod = Product.objects.getProductByOuterid(outer_id)
prod_sku = Product.objects.getProductSkuByOuterid(outer_sku_id)
if not (prod and prod.is_split) or not (prod_sku
and prod_sku.is_split):
continue
try:
compose_rule = ComposeRule.objects.get(
outer_id=outer_id,
outer_sku_id=outer_sku_id,
type=ComposeRule.RULE_GIFTS_TYPE)
except Exception, exc:
pass
else:
rules = compose_rule.compose_items.all()
for rule in rules:
if rule.gif_count > 0:
MergeOrder.gen_new_order(
trade.id,
rule.outer_id,
rule.outer_sku_id,
rule.num * order_num,
gift_type=pcfg.ITEM_GIFT_TYPE,
payment=0)
ComposeRule.objects.filter(id=rule.id).update(
gif_count=F('gif_count') - 1)
msg = u'买(oid:%s)就送(%s)' % str(
order.id, ','.join([
'%s-%s' % (r.outer_id, r.outer_sku_id)
for r in rules
]))
log_action(trade.user.user.id, trade, CHANGE, msg)
except Exception, exc:
logger.error(exc.message or 'combose split error', exc_info=True)
trade.append_reason_code(pcfg.COMPOSE_RULE_ERROR_CODE)
def rule_match_payment(sender, trade_id, *args, **kwargs):
"""
赠品规则:
1,针对实付订单，不能根据有效来计算，由于需拆分的实付订单拆分后会变成无效；
2，赠品是根据最大匹配金额来赠送；
3，该规则执行前，应先将所以满就送的订单删除；
"""
try:
trade = MergeTrade.objects.get(id=trade_id)
except MergeTrade.DoesNotExist:
pass
else:
trade.merge_orders.filter(
gift_type=pcfg.OVER_PAYMENT_GIT_TYPE).delete()
try:
orders = trade.merge_orders.filter(
gift_type=pcfg.REAL_ORDER_GIT_TYPE,
status__in=(pcfg.WAIT_SELLER_SEND_GOODS,
pcfg.WAIT_BUYER_CONFIRM_GOODS)).exclude(
refund_status=pcfg.REFUND_SUCCESS)
payment = orders.aggregate(
total_payment=Sum('payment'))['total_payment'] or 0
post_fee = trade.post_fee or 0
real_payment = payment - float(post_fee)
self_rule = None
payment_rules = ComposeRule.objects.filter(
type='payment').order_by('-payment')
for rule in payment_rules:
if real_payment >= rule.payment and rule.gif_count > 0:
for item in rule.compose_items.all():
MergeOrder.gen_new_order(
trade.id,
item.outer_id,
item.outer_sku_id,
item.num,
gift_type=pcfg.OVER_PAYMENT_GIT_TYPE)
msg = u'交易金额匹配（实付:%s）' % str(real_payment)
log_action(trade.user.user.id, trade, CHANGE, msg)
ComposeRule.objects.filter(id=rule.id).update(
gif_count=F('gif_count') - 1)
break
MergeTrade.objects.filter(id=trade_id).update(
order_num=orders.filter(sys_status=pcfg.IN_EFFECT).count(),
payment=payment)
except Exception, exc:
logger.error(exc.message or 'payment rule error', exc_info=True)
trade.append_reason_code(pcfg.PAYMENT_RULE_ERROR_CODE)
def ruleMatchSplit(trade):
try:
trade.merge_orders.filter(
gift_type=pcfg.COMBOSE_SPLIT_GIT_TYPE).delete()
for order in trade.split_orders:
try:
if not Product.objects.isProductRuleSplit(
order.outer_id, order.outer_sku_id):
continue
compose_rule = ComposeRule.objects.get(
outer_id=order.outer_id,
outer_sku_id=order.outer_sku_id,
type=pcfg.RULE_SPLIT_TYPE,
seller_id__in=(ComposeRule.DEFAULT_SELLER_CODE,
trade.user.id),
status=True)
except Exception, exc:
logger.debug('ruleMatchSplit:%s' % exc.message)
continue
else:
items = compose_rule.compose_items.all()
total_cost = 0 # 计算总成本
for item in items:
total_cost += Product.objects.getPrudocutCostByCode(
item.outer_id, item.outer_sku_id)
for item in items:
cost = Product.objects.getPrudocutCostByCode(
item.outer_id, item.outer_sku_id)
payment = total_cost and '%.2f' % (
float(cost / total_cost) * float(order.payment)) or 0
MergeOrder.gen_new_order(
trade.id,
item.outer_id,
item.outer_sku_id,
item.num * order.num,
gift_type=pcfg.COMBOSE_SPLIT_GIT_TYPE,
payment=payment,
created=order.created,
pay_time=order.pay_time)
order.sys_status = pcfg.INVALID_STATUS
order.save()
log_action(
trade.user.user.id, trade, CHANGE, u'拆分订单(%d,%s,%s)' %
(order.id, order.outer_id, order.outer_sku_id))
except Exception, exc:
trade.append_reason_code(pcfg.COMPOSE_RULE_ERROR_CODE)
logger.error(u'组合拆分出错：%s' % exc.message, exc_info=True)
def ruleMatchPayment(trade):
"""
满就送规则:
1,针对实付订单，不能根据有效来计算，由于需拆分的实付订单拆分后会变成无效；
2，赠品是根据最大匹配金额来赠送；
3，该规则执行前，应先将所以满就送的订单删除；
"""
try:
if trade.isSplit(): # 如果订单属于拆分后的订单，则不进行金额规则匹配
return
trade.merge_orders.filter(
is_merge=False, gift_type=pcfg.OVER_PAYMENT_GIT_TYPE).delete()
real_payment = trade.merge_orders.filter(
sys_status=pcfg.IN_EFFECT, is_merge=False).aggregate(
total_payment=Sum('payment'))['total_payment'] or 0
payment_rules = ComposeRule.objects.filter(type=pcfg.RULE_PAYMENT_TYPE, status=True) \
.order_by('-payment')
for rule in payment_rules:
if (real_payment < rule.payment or rule.gif_count <= 0
or rule.seller_id
not in (ComposeRule.DEFAULT_SELLER_CODE, trade.user.id)
or rule.start_time > trade.pay_time
or rule.end_time < trade.pay_time):
continue
for item in rule.compose_items.all():
MergeOrder.gen_new_order(trade.id,
item.outer_id,
item.outer_sku_id,
item.num,
created=trade.created,
pay_time=trade.pay_time,
gift_type=pcfg.OVER_PAYMENT_GIT_TYPE)
log_action(trade.user.user.id, trade, CHANGE,
u'满就送（实付:%s）' % str(real_payment))
ComposeRule.objects.filter(id=rule.id).update(
gif_count=F('gif_count') - 1, scb_count=F('scb_count') + 1)
break
except Exception, exc:
trade.append_reason_code(pcfg.PAYMENT_RULE_ERROR_CODE)
logger.error(u'满就送规则错误:%s' % exc.message, exc_info=True)
def split_merge_trade(merger_order_id, modify_user):
"""
批量拆单功能实现
参数为order_id 以逗号拼接的字串
"""
from shopback.trades.handlers import trade_handler
order_list = merger_order_id.split(",")
len_of_chai = len(order_list)
if len(order_list) == 0:
return u"error"
m = MergeOrder.objects.filter(Q(id=order_list[0], sys_status=IN_EFFECT))
if m.count() == 0:
return u"有无效的订单"
m_trade = MergeOrder.objects.filter(merge_trade=m[0].merge_trade,
sys_status=IN_EFFECT)
if m_trade.count() == len_of_chai:
return u"至少留一个有效的订单"
parent_trade = m[0].merge_trade
if parent_trade.has_merge and parent_trade.sys_status != pcfg.WAIT_CHECK_BARCODE_STATUS:
return u"有合单"
parent_trade_tid = parent_trade.tid.split("-")[0]
first_p = Product.objects.filter(outer_id=m[0].outer_id)
if first_p.count() == 0:
return u"未发现商品"
payment = 0
for order_id in order_list:
m = MergeOrder.objects.filter(Q(id=order_id, sys_status=IN_EFFECT))
if m.count() == 0:
return u"没有有效的订单"
if parent_trade.id != m[0].merge_trade.id:
return u"不在一个父订单"
p = Product.objects.filter(outer_id=m[0].outer_id)
if p.count() == 0:
return u"未发现商品"
if first_p[0].ware_by != p[0].ware_by:
return u"不在一个仓库"
payment += m[0].payment
count = 1
while True:
temp_merge = MergeTrade.objects.filter(
Q(tid=parent_trade_tid + "-" + str(count)))
if temp_merge.count() == 0:
break
count += 1
parent_trade_dict = parent_trade.__dict__
new_trade = MergeTrade(tid=parent_trade_tid + "-" + str(count),
user=parent_trade.user)
# 复制原来的订单的信息
for k, v in parent_trade_dict.items():
if not (k == u"tid" or k == u"id"):
if k == u"payment":
new_trade.payment = payment
elif k == u"ware_by":
new_trade.ware_by = p[0].ware_by
else:
hasattr(new_trade, k) and setattr(new_trade, k, v)
new_trade.is_part_consign = True
new_trade.is_part_consign = True
new_trade.buyer_message = parent_trade.buyer_message
new_trade.seller_memo = parent_trade.seller_memo
new_trade.sys_memo = parent_trade.sys_memo
new_trade.save()
log_action(modify_user.id, new_trade, ADDITION,
u'从订单{0}拆过来'.format(parent_trade.id))
# 将新的order合入新的订单
for order_id in order_list:
mergeorder = MergeOrder.objects.get(id=order_id, sys_status=IN_EFFECT)
mergeorder_dict = mergeorder.__dict__
new_order = MergeOrder()
for k1, v1 in mergeorder_dict.items():
if not k1 == u"id":
if k1 == u'merge_trade_id':
new_order.merge_trade_id = new_trade.id
else:
hasattr(new_order, k1) and setattr(new_order, k1, v1)
new_order.save()
mergeorder.sys_status = INVALID_STATUS
mergeorder.save()
log_action(modify_user.id, mergeorder, CHANGE, u'被拆单')
parent_trade.sys_memo += u"拆单到{0}".format(new_trade.id)
parent_trade.is_part_consign = True
parent_trade.save()
trade_handler.proccess(parent_trade, **{"update_logistic": True})
trade_handler.proccess(new_trade, **{"update_logistic": True})
log_action(modify_user.id, parent_trade, CHANGE,
u'拆到订单{0}'.format(new_trade.id))
return "OK"
def create_refund_exchange_trade(request, seller_id, tid):
try:
origin_trade = MergeTrade.objects.get(tid=tid.strip(), user=seller_id)
except MergeTrade.DoesNotExist:
return HttpResponseNotFound('<h1>订单未找到 404<h1>')
refunds = Refund.objects.filter(tid=tid)
rfprods = RefundProduct.objects.filter(trade_id=tid.strip())
if rfprods.count() == 0:
return HttpResponseNotFound('<h1>未找到退货商品 404<h1>')
dt = datetime.datetime.now()
merge_trade = MergeTrade.objects.create(
user=origin_trade.user,
buyer_nick=origin_trade.buyer_nick,
type=pcfg.EXCHANGE_TYPE,
shipping_type=origin_trade.shipping_type,
logistics_company=origin_trade.logistics_company,
receiver_name=origin_trade.receiver_name,
receiver_state=origin_trade.receiver_state,
receiver_city=origin_trade.receiver_city,
receiver_district=origin_trade.receiver_district,
receiver_address=origin_trade.receiver_address,
receiver_zip=origin_trade.receiver_zip,
receiver_mobile=origin_trade.receiver_mobile,
receiver_phone=origin_trade.receiver_phone,
sys_status=pcfg.WAIT_AUDIT_STATUS,
status=pcfg.WAIT_SELLER_SEND_GOODS,
created=dt,
pay_time=dt,
modified=dt)
for prod in rfprods.filter(can_reuse=True):
merge_order = MergeOrder()
merge_order.merge_trade = merge_trade
merge_order.title = prod.title
merge_order.sku_properties_name = prod.property
merge_order.outer_id = prod.outer_id
merge_order.outer_sku_id = prod.outer_sku_id
merge_order.num = prod.num
merge_order.seller_nick = origin_trade.user.nick
merge_order.buyer_nick = origin_trade.buyer_nick
merge_order.gift_type = pcfg.RETURN_GOODS_GIT_TYPE
merge_order.sys_status = pcfg.IN_EFFECT
merge_order.status = pcfg.WAIT_SELLER_SEND_GOODS
merge_order.created = dt
merge_order.save()
refunds.update(is_reissue=True)
rfprods.update(is_finish=True)
for refund in refunds:
try:
refund.confirm_refund()
except Exception, exc:
logger.error(exc.message, exc_info=True)
def syncWareStockByJDShopTask(jd_ware):
"""
"""
from shopback.items.models import Product, ProductSku, ItemNumTaskLog
from shopback.trades.models import MergeOrder
from shopback.users.models import User
if not isinstance(jd_ware, JDProduct):
jd_ware = JDProduct.objects.get(ware_id=jd_ware)
if not jd_ware.sync_stock:
return
jd_user = User.objects.get(visitor_id=jd_ware.vender_id)
user_percent = jd_user.stock_percent
skus = jd_ware.skus and json.loads(jd_ware.skus) or []
sku_stock_list = []
for sku in skus:
if sku['status'] != JDProduct.VALID or not sku.get('outer_id', None):
continue
outer_id, outer_sku_id = Product.objects.trancecode(
'', sku['outer_id'])
product = Product.objects.get(outer_id=outer_id)
product_sku = ProductSku.objects.get(outer_id=outer_sku_id,
product__outer_id=outer_id)
if not (jd_user.sync_stock and product.sync_stock
and product_sku.sync_stock):
continue
order_nums = 0
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(
jd_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['stock_num']):
api.jd_sku_stock_update(outer_id=sku['outer_id'],
quantity=sync_num,
jd_user_id=jd_user.visitor_id)
ItemNumTaskLog.objects.get_or_create(
user_id=jd_user.user.id,
outer_id=outer_id,
sku_outer_id='jd%s' % outer_sku_id,
num=sync_num,
end_at=datetime.datetime.now())
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 rule_match_combose_split(sender, trade_id, *args, **kwargs):
"""
拆分规则:
1,针对实付订单，不能根据有效来计算，由于需拆分的实付订单拆分后会变成无效；
2，赠品是根据最大匹配金额来赠送；
3，该规则执行前，应先将所以满就送的订单删除；
"""
try:
trade = MergeTrade.objects.get(id=trade_id)
except MergeTrade.DoesNotExist:
pass
else:
trade.merge_orders.filter(
gift_type=pcfg.COMBOSE_SPLIT_GIT_TYPE).delete()
try:
orders = trade.merge_orders.filter(
gift_type=pcfg.REAL_ORDER_GIT_TYPE,
status__in=(pcfg.WAIT_SELLER_SEND_GOODS,
pcfg.WAIT_BUYER_CONFIRM_GOODS)).exclude(
refund_status=pcfg.REFUND_SUCCESS)
for order in orders:
outer_id = order.outer_id
outer_sku_id = order.outer_sku_id
order_num = order.num
order_payment = order.payment
prod = Product.objects.getProductByOuterid(outer_id)
prod_sku = Product.objects.getProductSkuByOuterid(outer_sku_id)
if not (prod and prod.is_split) or not (prod_sku
and prod_sku.is_split):
continue
try:
compose_rule = ComposeRule.objects.get(
outer_id=outer_id,
outer_sku_id=outer_sku_id,
type='product')
except Exception, exc:
pass
else:
items = compose_rule.compose_items.all()
total_cost = 0 # 计算总成本
for item in items:
total_cost += item.get_item_cost()
for item in items:
cost = item.get_item_cost()
payment = total_cost and str(
round((cost / total_cost) * float(order_payment),
2)) or '0'
MergeOrder.gen_new_order(
trade.id,
item.outer_id,
item.outer_sku_id,
item.num * order_num,
gift_type=pcfg.COMBOSE_SPLIT_GIT_TYPE,
payment=payment)
order.sys_status = pcfg.INVALID_STATUS
order.save()
msg = u'拆分订单商品(oid:%s)' % str(order.id)
log_action(trade.user.user.id, trade, CHANGE, msg)
except Exception, exc:
logger.error(exc.message or 'combose split error', exc_info=True)
trade.append_reason_code(pcfg.COMPOSE_RULE_ERROR_CODE)
def updateItemNum(user_id, num_iid):
"""
taobao_item_quantity_update response:
{'iid': '21557036378',
'modified': '2012-12-26 12:51:16',
'num': 24,
'num_iid': 21557036378,
'skus': {'sku': ({'modified': <type 'str'>,
'quantity': <type 'int'>,
'sku_id': <type 'int'>},
{'modified': <type 'str'>,
'quantity': <type 'int'>,
'sku_id': <type 'int'>})}}
"""
item = Item.objects.get(num_iid=num_iid)
user = item.user
product = item.product
if not product or not item.sync_stock:
return
user_percent = user.stock_percent
p_outer_id = product.outer_id
skus = json.loads(item.skus) if item.skus else None
if skus:
for sku in skus.get('sku', []):
try:
outer_sku_id = sku.get('outer_id', '')
outer_id, outer_sku_id = Product.objects.trancecode(p_outer_id, outer_sku_id)
if p_outer_id != outer_id or sku['status'] != pcfg.NORMAL or not outer_sku_id:
continue
product_sku = product.prod_skus.filter(outer_id=outer_sku_id).first()
if not product_sku:
continue
order_nums = 0
wait_nums = max(product_sku.wait_post_num, 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(item.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)
elif total_num == 0:
item_count = Item.objects.filter(outer_id=outer_id,
approve_status=pcfg.ONSALE_STATUS).count() or 1
sync_num = int(sync_num / item_count) or sync_num
else:
sync_num = (real_num - wait_nums) > 10 and 2 or 0
elif sync_num > 0:
product_sku.is_assign = False
else:
sync_num = 0
# 当前同步库存值，与线上拍下未付款商品数，哪个大取哪个
sync_num = max(sync_num, sku.get('with_hold_quantity', 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)
# 同步库存数不为0，或者没有库存警告，同步数量不等于线上库存，并且店铺，商品，规格同步状态正确
if (not (sync_num == 0 and product_sku.is_assign)
and sync_num != sku['quantity']
and user.sync_stock
and product.sync_stock
and product_sku.sync_stock):
response = apis.taobao_item_quantity_update(num_iid=item.num_iid,
quantity=sync_num,
sku_id=sku['sku_id'],
tb_user_id=user_id)
item_dict = response['item_quantity_update_response']['item']
Item.objects.filter(num_iid=item_dict['num_iid']).update(modified=item_dict['modified'],
num=sync_num)
product_sku.save()
ItemNumTaskLog.objects.get_or_create(user_id=user_id,
outer_id=product.outer_id,
sku_outer_id=outer_sku_id,
num=sync_num,
start_at=item.last_num_updated,
end_at=datetime.datetime.now())
except Exception, exc:
logger.error('sync sku num error!', exc_info=True)
else:
order_nums = 0
outer_id, outer_sku_id = Product.objects.trancecode(p_outer_id, '')
wait_nums = max(product.wait_post_num, 0)
remain_nums = product.remain_num or 0
real_num = product.collect_num
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.warn_num:
total_num, user_order_num = MergeOrder.get_yesterday_orders_totalnum(
item.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)
elif total_num == 0:
item_count = Item.objects.filter(outer_id=outer_id,
approve_status=pcfg.ONSALE_STATUS).count() or 1
sync_num = int(sync_num / item_count) or sync_num
else:
sync_num = (real_num - wait_nums) > 10 and 2 or 0
elif sync_num > 0:
product.is_assign = False
else:
sync_num = 0
# 当前同步库存值，与线上拍下未付款商品数，哪个大取哪个