def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG REGULARSALE:%s' % merge_trade)
if merge_trade.sys_status == pcfg.ON_THE_FLY_STATUS:
return
has_unstockout_product = False
for order in merge_trade.normal_orders.filter(
gift_type=MergeOrder.REAL_ORDER_GIT_TYPE):
has_unstockout_product |= not order.out_stock
try:
product = Product.objects.get(outer_id=order.outer_id)
if product.category.cid <= MAX_YOUNI_CAT:
return
except Product.DoesNotExist:
continue
# 如果订单包含不缺货的订单，则不放入定时提醒
if has_unstockout_product:
return
remind_time = datetime.datetime.now() + datetime.timedelta(
days=settings.REGULAR_DAYS)
merge_trade.sys_status = pcfg.REGULAR_REMAIN_STATUS
merge_trade.remind_time = remind_time
merge_trade.sys_memo += u'特卖订单，到货再发'
update_model_fields(
merge_trade,
update_fields=['sys_memo', 'remind_time', 'sys_status'])
log_action(merge_trade.user.user.id, merge_trade, CHANGE,
u'定时(%s)提醒' % remind_time)
def write_dinghuo_return_pro(refund):
try:
record = DailySupplyChainStatsOrder.objects.get(product_id=refund.outer_id)
record.return_pro += refund.refund_num
update_model_fields(record, update_fields=['return_pro'])
except:
return
def post(self, request):
content = request.POST
supplier_id = content.get("supplier_id", None)
zone_id = content.get("zone_id", None)
supplier_type = content.get("supplier_type", None)
sup = SaleSupplier.objects.get(id=supplier_id)
if supplier_id and zone_id: # 修改地区字段
try:
zone = SupplierZone.objects.get(id=zone_id)
sup.supplier_zone = zone.id
update_model_fields(sup, update_fields=['supplier_zone'])
status = {"code": 0}
log_action(request.user.id, sup, CHANGE,
u'修改供应商片区为{0}'.format(zone.name))
except SupplierZone.DoesNotExist:
status = {"code": 3}
return HttpResponse(json.dumps(status),
content_type='application/json')
elif supplier_id and supplier_type: # 修改类型字段
supplier_type = int(supplier_type)
sup.supplier_type = supplier_type
update_model_fields(sup, update_fields=['supplier_type'])
log_action(
request.user.id, sup, CHANGE, u'修改供应商类型为{0}'.format(
SaleSupplier.SUPPLIER_TYPE[supplier_type][1]))
status = {"code": 0}
else:
status = {"code": 1}
return HttpResponse(json.dumps(status),
content_type='application/json')
def atWAIT_BUYER_CONFIRM_GOODS(self, merge_trade):
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
MergeTrade.objects.get(id=main_tid).append_reason_code(
pcfg.NEW_REFUND_CODE)
main_trade = MergeTrade.objects.get(id=main_tid)
main_order = None
for order in merge_trade.merge_orders.all():
main_order = main_trade.merge_orders.get(oid=order.oid)
main_order.status = order.status
main_order.refund_status = order.refund_status
main_order.sys_status = order.sys_status
update_model_fields(
main_order,
update_fields=['status', 'refund_status', 'sys_status'])
if main_order:
ruleMatchSplit(main_trade)
ruleMatchPayment(main_trade)
if (merge_trade.sys_status in pcfg.WAIT_DELIVERY_STATUS
and not merge_trade.is_locked):
merge_trade.sys_status = pcfg.INVALID_STATUS
def task_category_collect_num(days=15):
"""
days: 更新的天数
定时任务 更新产品分类的库存数量 和 库存金额
"""
sale_time_to = datetime.datetime.today()
sale_time_from = sale_time_to - datetime.timedelta(days=days)
pros = Product.objects.filter(sale_time__gte=sale_time_from,
sale_time__lte=sale_time_to,
status="normal")
cgy_collects = pros.values(
'sale_time', 'category').annotate(total_collect=Sum('collect_num'))
# a = [{'category': 8L, 'sale_time': datetime.date(2015, 11, 30), 'total_collect': 0},...]
for collect in cgy_collects:
cgysta, state = CategorySaleStat.objects.get_or_create(
stat_date=collect['sale_time'], category=collect['category'])
cgysta.collect_num = collect['total_collect']
# 该天该类产品
collect_amount = 0
pskus = ProductSku.objects.filter(
product__sale_time=collect['sale_time'],
product__status="normal",
product__category=collect['category'])
for psku in pskus:
collect_amount += psku.collect_amount
cgysta.collect_amount = collect_amount
update_model_fields(cgysta,
update_fields=['collect_num', "collect_amount"])
def change_hot_val(self, request, pk=0):
""" 增加选品热度值 """
pk = int(pk)
result = {}
sale_pro = get_object_or_404(SaleProduct, id=pk)
customer = get_object_or_404(Customer, user=request.user)
# 查看今天点赞的个数超过10个就不允许点击
today_queryset = self.get_own_today_queryset(customer.id)
today_count = today_queryset.count()
if today_count >= 10:
result['hot_val'] = sale_pro.hot_value
result['today_count'] = today_count
return Response(result)
# 创建点赞记录
sale_praise, state = SalePraise.objects.get_or_create(
sale_id=sale_pro.id, cus_id=customer.id)
if state: # 点赞 state 为True表示创建了
sale_pro.hot_value = F('hot_value') + 1 # 热度加１
update_model_fields(sale_pro, update_fields=['hot_value'])
sale_praise.praise = True
update_model_fields(sale_praise, update_fields=['praise']) # 点赞
sale_pro = get_object_or_404(SaleProduct, id=pk)
result['hot_val'] = sale_pro.hot_value
result['today_count'] = today_count
return Response(result)
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG MEMO:%s' % merge_trade)
origin_trade = kwargs.get('origin_trade', None)
merge_trade.append_reason_code(pcfg.NEW_MEMO_CODE)
merge_trade.seller_memo = self.getOriginMemo(merge_trade, origin_trade)
merge_trade.buyer_message = self.getOriginBuyerMessage(merge_trade, origin_trade)
update_model_fields(merge_trade, update_fields=['seller_memo',
'buyer_message'])
log_action(merge_trade.user.user.id,
merge_trade, ADDITION,
u'订单备注:[%s:%s]' % (merge_trade.buyer_message,
merge_trade.seller_memo))
merge_type = MergeBuyerTrade.getMergeType(merge_trade.id)
if merge_type == pcfg.SUB_MERGE_TYPE:
mbt = MergeBuyerTrade.objects.get(sub_tid=merge_trade.id)
main_trade = MergeTrade.objects.get(id=mbt.main_tid)
main_trade.append_reason_code(pcfg.NEW_MEMO_CODE)
main_trade.update_buyer_message(merge_trade.id,
merge_trade.buyer_message)
main_trade.update_seller_memo(merge_trade.id,
merge_trade.seller_memo)
def update_refundpro_to_product(can_reuse=False):
endtime = datetime.datetime(2015, 10, 8, 17, 20, 0)
actioner = 19 # 操作用户的id systemoa 641
rep_dic = {}
# can_reuse=False 不可以二次销售的 次品 # can_reuse=True 可以二次销售的 正品
re_prods = RefundProduct.objects.filter(is_finish=False,
can_reuse=can_reuse,
created__lte=endtime)
for rp in re_prods:
if rep_dic.has_key(rp.outer_id):
if rep_dic[rp.outer_id].has_key(rp.outer_sku_id):
rep_dic[rp.outer_id][rp.outer_sku_id] += rp.num
else:
rep_dic[rp.outer_id][rp.outer_sku_id] = rp.num
else:
rep_dic[rp.outer_id] = {rp.outer_sku_id: rp.num}
rp.is_finish = True
update_model_fields(rp, update_fields=['is_finish']) # 更新字段方法
log_action(actioner, rp, CHANGE,
u"更新历史退货商品到产品库存时 修改成处理完成") # systemoa 添加log action
for pr in rep_dic.items():
outer_id = pr[0]
for sku in pr[1].items():
sku_out_id = sku[0]
num = sku[1]
# 修改该商品的该sku库存
acrion_product_num(outer_id, sku_out_id, num, can_reuse)
def write_rcd_column_sale_date():
""" ProRefunRcord 添加日期字段后 将对应产品上架日期写入 对应字段 """
pro_rcds = ProRefunRcord.objects.all()
print(u"条数：", pro_rcds.count())
for rcd in pro_rcds:
sale_date = rcd.sale_time()
if sale_date is None:
continue
rcd.sale_date = sale_date
update_model_fields(rcd, update_fields=['sale_date'])
def update_trade_refund_status(self, merge_trade):
merge_trade.has_refund = True
merge_trade.append_reason_code(pcfg.NEW_REFUND_CODE)
if merge_trade.sys_status in pcfg.WAIT_DELIVERY_STATUS:
self.atWAIT_SELLER_SEND_GOODS(merge_trade)
elif merge_trade.sys_status == pcfg.INVALID_STATUS:
self.atTRADE_CLOSED(merge_trade)
elif merge_trade.sys_status in pcfg.WAIT_SCAN_CHECK_WEIGHT:
self.atWAIT_BUYER_CONFIRM_GOODS(merge_trade)
update_model_fields(merge_trade, update_fields=['has_refund'])
def his_dinghuo_return_pro():
""" 写入产品退货历史退货数量数据 """
# 已经收到货 或者 已经退货的
refunds = SaleRefund.objects.filter(
good_status__in=(SaleRefund.BUYER_RECEIVED, SaleRefund.BUYER_RETURNED_GOODS)).exclude(
status=SaleRefund.REFUND_CLOSED)
for refund in refunds:
record = DailySupplyChainStatsOrder.objects.filter(product_id=refund.outer_id())
if record.exists():
record = record[0]
refund_num = refund.refund_num
record.return_pro += refund_num
update_model_fields(record, update_fields=['return_pro'])
def modify_logistic_refund(customer, company, order, sid, refund):
order.refund_status = SaleRefund.REFUND_CONFIRM_GOODS
order.save(update_fields=['refund_status'])
log_action(customer, order, CHANGE,
u'用户退货填写物流信息,修改order refund_status 到买家退货状态！')
refund.company_name = company
refund.sid = sid
refund.status = SaleRefund.REFUND_CONFIRM_GOODS # 修改到买家已经退货状态(退货途中)
refund.good_status = SaleRefund.BUYER_RETURNED_GOODS # 修改商品状态到买家已经退货
update_model_fields(
refund, update_fields=['company_name', 'sid', 'status', 'good_status'])
log_action(customer, refund, CHANGE, u'用户退货填写物流信息！')
def insert_field_hist_pro_rcd():
""" ProRefunRcord 添加字段后 将对应产品ｉd的 款式id以及接洽人 写入 对应字段 """
pro_rcds = ProRefunRcord.objects.all()
for rcd in pro_rcds:
pro = rcd.item_product()
if pro is None:
continue
model_id = 0 if pro.model_id is None else pro.model_id
rcd.pro_model = model_id
if pro.sale_product > 0:
sal_pro = SaleProduct.objects.get(id=pro.sale_product)
contactor = 0 if sal_pro.contactor is None else sal_pro.contactor
rcd.contactor = contactor
update_model_fields(rcd, update_fields=['pro_model', 'contactor'])
def category_refund_stat(sender, obj, **kwargs):
"""
通过信号写对应上架日期的产品分类的退款数量和金额
"""
pro = Product.objects.get(id=obj.item_id)
cgysta, state = CategorySaleStat.objects.get_or_create(
stat_date=pro.sale_time, category=pro.category.cid)
if state: # 如果是新建
cgysta.refund_num = obj.refund_num
cgysta.refund_amount = obj.refund_fee
else: # 在原有基础上面加退款数量和退款金额
cgysta.refund_num = F("refund_num") + obj.refund_num
cgysta.refund_amount = F("refund_amount") + obj.refund_fee
update_model_fields(cgysta, update_fields=["refund_num", "refund_amount"])
def record_pro(ref):
order = ref.saleorder
if order is None:
return
trade = order.sale_trade
# 订单的付款时间 与 退款单的创建时间 比较 判断是否属于24小时内
pay_time = trade.pay_time
if pay_time is None:
return
ref_created = ref.created
after_24_h = pay_time + datetime.timedelta(days=1)
pro_ref_rcd, state = ProRefunRcord.objects.get_or_create(product=ref.item_id)
if ref_created > after_24_h:
# 表示24小时外申请
if ref.good_status in (SaleRefund.BUYER_RECEIVED, SaleRefund.BUYER_RETURNED_GOODS):
if state:
pro_ref_rcd.ref_sed_num = ref.refund_num
else:
pro_ref_rcd.ref_sed_num += ref.refund_num
else:
if state:
pro_ref_rcd.ref_num_out = ref.refund_num
else:
pro_ref_rcd.ref_num_out += ref.refund_num
else:
# 表示24小时内申请
if ref.good_status in (SaleRefund.BUYER_RECEIVED, SaleRefund.BUYER_RETURNED_GOODS):
if state:
pro_ref_rcd.ref_sed_num = ref.refund_num
else:
pro_ref_rcd.ref_sed_num += ref.refund_num
else:
if state:
pro_ref_rcd.ref_num_in = ref.refund_num
else:
pro_ref_rcd.ref_num_in += ref.refund_num
contactor = ref.sale_contactor() if ref.sale_contactor() is not None else 0
pro_model = ref.pro_model() if ref.pro_model() is not None else 0
pro_ref_rcd.contactor = contactor
pro_ref_rcd.pro_model = pro_model
if pro_ref_rcd.sale_time() is not None:
# 这里如果重新上架的产品产生的退款会将以前的上架日期覆盖掉
pro_ref_rcd.sale_date = pro_ref_rcd.sale_time()
update_model_fields(pro_ref_rcd, update_fields=['ref_sed_num', 'ref_num_out', 'ref_num_in', 'contactor',
'pro_model', 'sale_date'])
def record_supplier(obj):
""" 记录某供应商下产品的的退款状况： 总退款件数 总退款额
Args: obj SaleRefund instance
Returns: None
Raises: None
"""
try:
item_id = obj.item_id # 商品id
pro = Product.objects.get(id=item_id) # 找到商品
sal_p, supplier = pro.pro_sale_supplier()
if supplier is not None:
supplier.total_refund_num = F('total_refund_num') + obj.refund_num
supplier.total_refund_amount = F('total_refund_amount') + obj.total_fee
update_model_fields(supplier, update_fields=['total_refund_num', 'total_refund_amount']) # 更新字段
except:
return
def change_product_inventory(rg, actioner, actor_id):
"""
仓库审核通过退货单的时候减少对应商品的库存
"""
rg.consigner = actioner
update_model_fields(rg, update_fields=['consigner'])
rg_details = rg.rg_details.all()
try:
product = Product.objects.get(id=rg.product_id)
except Product.DoesNotExist:
return
for rd in rg_details:
try:
psk = ProductSku.objects.get(id=rd.skuid)
acrion_invenctory_num(product, psk, rd, actor_id)
except ProductSku.DoesNotExist:
return
def category_pit_num_stat():
"""
定时任务 计算保存 分类统计中的产品坑位数量
"""
pros = Product.objects.filter(sale_time=datetime.date.today(),
status="normal").values()
cgymods = pros.values("category", "model_id").distinct()
dic_cgy = {}
for cgy in cgymods:
if dic_cgy.has_key(cgy['category']):
dic_cgy[cgy['category']] += 1
else:
dic_cgy[cgy['category']] = 1
for category, pit_num in dic_cgy.items():
cgysta, state = CategorySaleStat.objects.get_or_create(
stat_date=datetime.date.today(), category=category)
cgysta.pit_num = pit_num
update_model_fields(cgysta, update_fields=['pit_num'])
def pingpp_charge(self, sale_trade, **kwargs):
""" pingpp支付实现 """
payment = int(sale_trade.payment * 100)
buyer_openid = sale_trade.openid
order_no = sale_trade.tid
channel = sale_trade.channel
if channel == SaleTrade.WX_PUB and not buyer_openid:
raise ValueError(u'请先微信授权登陆后再使用微信支付')
success_url = urlparse.urljoin(
settings.M_SITE_URL,
kwargs.get('success_url', constants.MALL_PAY_SUCCESS_URL))
cancel_url = urlparse.urljoin(
settings.M_SITE_URL,
kwargs.get('cancel_url', constants.MALL_PAY_CANCEL_URL))
extra = {}
if channel == SaleTrade.WX_PUB:
extra = {'open_id': buyer_openid, 'trade_type': 'JSAPI'}
elif channel == SaleTrade.ALIPAY_WAP:
extra = {"success_url": success_url, "cancel_url": cancel_url}
elif channel == SaleTrade.UPMP_WAP:
extra = {"result_url": success_url}
params = {
'order_no': '%s' % order_no,
'app': dict(id=settings.PINGPP_APPID),
'channel': channel,
'currency': 'cny',
'amount': '%d' % payment,
'client_ip': settings.PINGPP_CLENTIP,
'subject': u'小鹿美美平台交易',
'body':
u'订单ID(%s),订单金额(%.2f)' % (sale_trade.id, sale_trade.payment),
'metadata': dict(color='red'),
'extra': extra
}
charge = xiaolupay.Charge.create(**params)
sale_trade.charge = charge.id
update_model_fields(sale_trade, update_fields=['charge'])
return charge
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG INTERCEPT:%s' % merge_trade)
itrades = InterceptTrade.objects.getInterceptTradeByBuyerInfo(
merge_trade.buyer_nick.strip(),
merge_trade.receiver_mobile.strip(),
merge_trade.tid)
for itrade in itrades:
itrade.trade_id = merge_trade.id
itrade.status = InterceptTrade.COMPLETE
itrade.save()
merge_trade.append_reason_code(pcfg.NEW_MEMO_CODE)
merge_trade.sys_memo += u'【订单被拦截】'
update_model_fields(merge_trade, update_fields=['sys_memo'])
log_action(merge_trade.user.user.id, merge_trade, CHANGE, u'订单被拦截')
def modify_refund_fee(customer,
order,
refund,
refund_fee,
good_status=None,
reason=None,
desc=None,
num=None):
refund_update_fields = []
refund_params = {
"reason": reason,
"refund_num": num,
"good_status": good_status,
"desc": desc,
"status": SaleRefund.REFUND_WAIT_SELLER_AGREE, # 修改之后重置为申请状态
}
for k, v in refund_params.iteritems():
if v is None:
continue
if hasattr(refund, k) and getattr(order, k) != v:
setattr(refund, k, v)
refund_update_fields.append(k)
if refund_update_fields:
update_model_fields(refund, update_fields=refund_update_fields)
log_action(customer, refund, CHANGE, u'用户售后被拒绝后修改order信息！')
tasks.pushTradeRefundTask.delay(refund.id)
# 修改该订单的
order_params = {
"refund_id": refund.id,
"refund_fee": refund_fee,
"refund_status": SaleRefund.REFUND_WAIT_SELLER_AGREE
}
order_update_fields = []
for k, v in order_params.iteritems():
if hasattr(order, k) and getattr(order, k) != v:
setattr(order, k, v)
order_update_fields.append(k)
if order_update_fields:
order.save(update_fields=order_update_fields)
log_action(customer, order, CHANGE, u'用户售后修改退款单修改order信息！')
def update_Product_Collect_Num_By_Delete(pro, req):
"""
拆包的时候出错要删除退货商品 ， 同时更新库存的数量
"""
try:
product = Product.objects.get(outer_id=pro.outer_id)
psk = ProductSku.objects.get(product_id=product.id,
outer_id=pro.outer_sku_id)
if pro.can_reuse: # 判断是二次销售 则 减去库存数
# 删除库存sku的数量
psk_quantity = psk.quantity
psk.quantity = F("quantity") - pro.num
update_model_fields(psk, update_fields=['quantity']) # 更新字段方法
action_desc = u"拆包退货商品删除->将原来库存{0}更新为{1}".format(
psk_quantity, psk.quantity)
log_action(req.user.id, psk, CHANGE, action_desc)
# 删除库存商品的数量
pro_collect_num = product.collect_num # 原来的库存数量
product.collect_num = F("collect_num") - pro.num
update_model_fields(product,
update_fields=['collect_num']) # 更新字段方法
pro_action_desc = u"拆包退货商品删除->将原来库存{0}更新为{1}".format(
pro_collect_num, product.collect_num)
log_action(req.user.id, product, CHANGE, pro_action_desc)
else: # 如果不能二次销售 则 减去次品数
sku_inferior_num = psk.sku_inferior_num
psk.sku_inferior_num = F("sku_inferior_num") - pro.num
update_model_fields(psk,
update_fields=['sku_inferior_num']) # 更新字段方法
action_desc = u"拆包退货商品删除->将原来次品数量{0}更新为{1}".format(
sku_inferior_num, psk.sku_inferior_num)
log_action(req.user.id, psk, CHANGE, action_desc)
except Product.DoesNotExist or ProductSku.DoesNotExist:
return
def taskRefundRecord(obj):
order = SaleOrder.objects.get(id=obj.order_id)
trade = order.sale_trade
time_from = trade.pay_time
time_to = trade.pay_time + datetime.timedelta(days=1)
date_cal = datetime.date(time_from.year, time_from.month, time_from.day)
# 判断提交申请的时间是否是在付款后24小时内产生的 (只有在付款后才会有退款)
refund_record, state = PayRefNumRcord.objects.get_or_create(date_cal=date_cal)
if obj.created >= time_to: # 24小时外
if order.status in (SaleOrder.WAIT_BUYER_CONFIRM_GOODS, SaleOrder.TRADE_BUYER_SIGNED):
# 如果 已发货 则 算入 发货后退货数量
if state: # 新建记录 填写 付款成功数量
refund_record.ref_sed_num = 1
else: # 有记录则累加
refund_record.ref_sed_num = F('ref_sed_num') + 1
write_dinghuo_return_pro(obj) # 计算到订货表中的退货数量
if order.status in (SaleOrder.WAIT_SELLER_SEND_GOODS,):
# 如果 未发货 则 算入 24小时外未发货退款数量
if state: # 新建记录 填写 付款成功数量
refund_record.ref_num_out = 1
else: # 有记录则累加
refund_record.ref_num_out = F('ref_num_out') + 1
else: # 如果24小时内 已发货 则 算入 发货后退货数量
if order.status in (SaleOrder.WAIT_BUYER_CONFIRM_GOODS, SaleOrder.TRADE_BUYER_SIGNED):
# 如果 已发货 则 算入 发货后退货数量
if state: # 新建记录 填写 付款成功数量
refund_record.ref_sed_num = 1
else: # 有记录则累加
refund_record.ref_sed_num = F('ref_sed_num') + 1
write_dinghuo_return_pro(obj) # 计算到订货表中的退货数量
else: # 否则 算入 24小时内 退款数量
if state: # 新建记录 填写 付款成功数量
refund_record.ref_num_in = 1
else: # 有记录则累加
refund_record.ref_num_in = F('ref_num_in') + 1
update_model_fields(refund_record, update_fields=['ref_sed_num', 'ref_num_out', 'ref_num_in'])
# 添加产品的退货记录
record_pro(obj)
# 记录供应商的一些参数
record_supplier(obj)
def process(self, merge_trade, *args, **kwargs):
logger.debug('DEBUG LOGISTIC:%s' % merge_trade)
try:
if merge_trade.is_force_wlb:
merge_trade.append_reason_code(pcfg.TRADE_BY_WLB_CODE)
# 如果订单属于广州仓，则默认发韵达
if merge_trade.ware_by == WARE_GZ:
merge_trade.logistics_company = self.getGZLogisticCompany(
merge_trade)
else:
merge_trade.logistics_company = self.getSHLogisticCompany(
merge_trade)
update_model_fields(merge_trade,
update_fields=['logistics_company', 'ware_by'])
if merge_trade.ware_by == WARE_NONE:
raise Exception(u'请拆单或选择始发仓')
except Exception, exc:
merge_trade.sys_memo += u'[物流：%s]' % exc.message
update_model_fields(merge_trade, update_fields=['sys_memo'])
merge_trade.append_reason_code(pcfg.DISTINCT_RULE_CODE)
def acrion_product_num(outer_id, sku_out_id, num, can_reuse):
try:
actioner = 19 # 操作用户的id systemoa 641
pro = Product.objects.get(outer_id=outer_id)
psk = ProductSku.objects.get(product=pro.id, outer_id=sku_out_id)
if can_reuse: # 可以二次销售 正品 更新 quantity
before_num = psk.quantity
psk.quantity = F('quantity') + num # 增加历史库存数
update_model_fields(psk, update_fields=['quantity']) # 更新字段方法
log_action(
actioner, psk, CHANGE,
u"更新历史{0}+{1}退货商品到产品库存中".format(before_num, psk.quantity))
before_pro_num = pro.collect_num
pro.collect_num = F('collect_num') + num
update_model_fields(pro, update_fields=['collect_num']) # 更新字段方法
log_action(
actioner, pro, CHANGE,
u"更新历史{0}+{1}退货商品到产品库存中".format(before_pro_num, psk.quantity))
else:
before_num = psk.sku_inferior_num
psk.sku_inferior_num = F('sku_inferior_num') + num # 增加历史库存数
update_model_fields(psk,
update_fields=['sku_inferior_num']) # 更新字段方法
log_action(
actioner, psk, CHANGE,
u"更新历史{0}+{1}退货次品到产品库存次品中".format(before_num,
psk.sku_inferior_num))
print "usual :", outer_id, sku_out_id, num
except ProductSku.DoesNotExist:
print "exption :ProductSku mutil", outer_id, sku_out_id, num
except Product.DoesNotExist:
print "exption :ProductSku mutil", outer_id, sku_out_id, num
except Product.MultipleObjectsReturned:
print "exption :ProductSku mutil", outer_id, sku_out_id, num
except ProductSku.MultipleObjectsReturned:
print "exption :ProductSku mutil", outer_id, sku_out_id, num
except:
print "未知异常", outer_id, sku_out_id, num
def acrion_invenctory_num(product, psk, rd, actor_id):
# 减少库存sku的数量
psk_quantity = psk.quantity
if psk_quantity >= rd.num:
psk.quantity = F("quantity") - rd.num
update_model_fields(psk, update_fields=['quantity']) # 更新字段方法
else:
psk.quantity = 0
update_model_fields(psk, update_fields=['quantity']) # 更新字段方法
action_desc = u"仓库审核退货单通过->将原来库存{0}更新为{1}".format(psk_quantity,
psk.quantity)
log_action(actor_id, psk, CHANGE, action_desc)
# 减少库存商品的数量
product_af = Product.objects.get(id=product.id)
pro_collect_num = product_af.collect_num # 原来的库存数量
if pro_collect_num >= rd.num:
product_af.collect_num = F("collect_num") - rd.num
update_model_fields(product_af,
update_fields=['collect_num']) # 更新字段方法
else:
product_af.collect_num = 0
update_model_fields(product_af,
update_fields=['collect_num']) # 更新字段方法
pro_action_desc = u"仓库审核退货单通过->将原来库存{0}更新为{1}".format(
pro_collect_num, product_af.collect_num)
log_action(actor_id, product_af, CHANGE, pro_action_desc)
# 减少库存 减去次品数
sku_inferior_num = psk.sku_inferior_num
if sku_inferior_num >= rd.inferior_num:
psk.sku_inferior_num = F("sku_inferior_num") - rd.inferior_num
update_model_fields(psk, update_fields=['sku_inferior_num']) # 更新字段方法
else:
psk.sku_inferior_num = 0
update_model_fields(psk, update_fields=['sku_inferior_num']) # 更新字段方法
action_desc = u"仓库审核退货单通过->将原来次品数量{0}更新为{1}".format(
sku_inferior_num, psk.sku_inferior_num)
log_action(actor_id, psk, CHANGE, action_desc)
def get(self, request):
if True:
return redirect('/sale/promotion/appdownload/')
openid, unionid = self.get_openid_and_unionid(request)
if not valid_openid(openid) or not valid_openid(unionid):
redirect_url = self.get_snsuserinfo_redirct_url(request)
return redirect(redirect_url)
# service = WeixinUserService(settings.WEIXIN_APPID, openId=openid, unionId=unionid)
# wx_user = service._wx_user
wx_users = Customer.objects.filter(unionid=unionid,
status=Customer.NORMAL)
if not wx_users.exists():
return HttpResponse(
u'<html><body>你还不是小鹿妈妈,请先<a href="/m/register/">申请</a></body></html>'
)
wx_user = wx_users[0]
target_date = datetime.date.today()
yesterday = target_date - datetime.timedelta(days=1)
time_from = datetime.datetime(target_date.year, target_date.month,
target_date.day)
time_to = datetime.datetime(target_date.year, target_date.month,
target_date.day, 23, 59, 59)
mobile = wx_user.mobile
unionid = unionid or wx_user.unionid
data = {}
try:
referal_num = XiaoluMama.objects.filter(
referal_from=mobile, status=XiaoluMama.EFFECT).count()
xlmm, state = XiaoluMama.objects.get_or_create(openid=unionid)
if xlmm.mobile != mobile:
xlmm.mobile = mobile
xlmm.weikefu = xlmm.weikefu or wx_user.nick
update_model_fields(xlmm, update_fields=['mobile', 'weikefu'])
if xlmm.status == XiaoluMama.FROZEN:
return render(request, "mama_404.html")
mobile_revised = "%s****%s" % (mobile[:3], mobile[-4:])
mm_clogs = CarryLog.objects.filter(
xlmm=xlmm.id) # .exclude(log_type=CarryLog.ORDER_RED_PAC)
pending_value = mm_clogs.filter(status=CarryLog.PENDING).aggregate(
total_value=Sum('value')).get('total_value') or 0
total_income = mm_clogs.filter(
carry_type=CarryLog.CARRY_IN,
status=CarryLog.CONFIRMED).aggregate(
total_value=Sum('value')).get('total_value') or 0
total_pay = mm_clogs.filter(
carry_type=CarryLog.CARRY_OUT,
status=CarryLog.CONFIRMED).aggregate(
total_value=Sum('value')).get('total_value') or 0
yest_income = mm_clogs.filter(
carry_type=CarryLog.CARRY_IN, carry_date=yesterday).aggregate(
total_value=Sum('value')).get('total_value') or 0
yest_pay = mm_clogs.filter(
carry_type=CarryLog.CARRY_OUT, carry_date=yesterday).aggregate(
total_value=Sum('value')).get('total_value') or 0
pending_value = pending_value / 100.0
total_income = total_income / 100.0
total_pay = total_pay / 100.0
yest_income = yest_income / 100.0
yest_pay = yest_pay / 100.0
abnormal_cash = xlmm.cash_money - (total_income - total_pay
) # 异常金额
order_num = 0
order_stat = StatisticsShoppingByDay.objects.filter(
linkid=xlmm.pk, tongjidate=target_date)
if order_stat.count() > 0:
order_num = order_stat[0].buyercount
click_list = Clicks.objects.filter(linkid=xlmm.pk,
click_time__range=(time_from,
time_to),
isvalid=True)
click_num = click_list.values('openid').distinct().count()
# 设置最高有效最高点击上限
max_click_count = xlmm.get_Mama_Max_Valid_Clickcount(
order_num, day_date=target_date)
if time_from.date() >= ctasks.CLICK_MAX_LIMIT_DATE:
click_num = min(max_click_count, click_num)
referal_mm = 0
# if xlmm.progress != XiaoluMama.PASS :
# if xlmm.referal_from:
# referal_mamas = XiaoluMama.objects.filter(mobile=xlmm.referal_from)
# if referal_mamas.count() > 0:
# referal_mm = referal_mamas[0].id
# else:
# referal_mm = 1
try:
adver = XlmmAdvertis.objects.get(show_people=xlmm.agencylevel,
is_valid=True)
now = datetime.datetime.now()
if now >= adver.start_time and now <= adver.end_time:
adv_cntnt = adver
else:
adv_cntnt = None
except XlmmAdvertis.DoesNotExist:
adv_cntnt = None
data = {
"mobile": mobile_revised,
"click_num": click_num,
"xlmm": xlmm,
"advertise": adv_cntnt,
'referal_mmid': referal_mm,
"order_num": order_num,
"pk": xlmm.pk,
'pending_value': pending_value,
"referal_num": referal_num,
'total_income': total_income,
'total_pay': total_pay,
'abnormal_cash': abnormal_cash,
'yest_income': yest_income,
'yest_pay': yest_pay
}
except Exception, exc:
logger.error(exc.message, exc_info=True)
def post(self, request):
content = request.POST
date = content.get("date", None)
categray = content.get("categray", None)
pic_link = content.get("pic_link", None)
if pic_link is None or date is None or categray is None:
data = {"code": 0} # 确少参数
return HttpResponse(json.dumps(data)) # 传图为空
date_desc = date + '_poster'
year, month, day = map(int, date.split('-'))
active_time = datetime.datetime(year, month, day, 9, 30, 0)
active_time_from = datetime.datetime(year, month, day, 0, 0, 0)
active_time_to = datetime.datetime(year, month, day, 23, 59, 59)
try:
goodshelf, state = GoodShelf.objects.get_or_create(
active_time__gte=active_time_from,
active_time__lte=active_time_to)
if categray == "child":
GoodShelf.DEFAULT_CHD_POSTER[0]['pic_link'] = pic_link
chd_posters = GoodShelf.DEFAULT_CHD_POSTER
goodshelf.chd_posters = chd_posters
update_model_fields(goodshelf, update_fields=['chd_posters'])
data = {"code": 1} # 修改童装海报成功
log_action(request.user.id, goodshelf, CHANGE, u'修改童装海报成功')
elif categray == "female":
GoodShelf.DEFAULT_WEN_POSTER[0]['pic_link'] = pic_link
goodshelf.wem_posters = GoodShelf.DEFAULT_WEN_POSTER
update_model_fields(goodshelf, update_fields=['wem_posters'])
log_action(request.user.id, goodshelf, CHANGE, u'修改女装海报成功')
data = {"code": 2} # 修改女装海报成功
else:
data = {"code": 5} # 类别缺失
# 上线日期
goodshelf.title = date_desc
goodshelf.active_time = active_time
update_model_fields(goodshelf,
update_fields=['title', 'active_time'])
log_action(request.user.id, goodshelf, CHANGE, u'修改海报上线日期')
# 创建次日海报
next_day_from = active_time_from + datetime.timedelta(days=1)
next_day_to = active_time_to + datetime.timedelta(days=1)
next_day_gs, state_next = GoodShelf.objects.get_or_create(
active_time__gte=next_day_from, active_time__lte=next_day_to)
next_day_gs.title = goodshelf.title + '_next'
next_day_gs.chd_posters = goodshelf.chd_posters
next_day_gs.wem_posters = goodshelf.wem_posters
next_day_gs.active_time = active_time + datetime.timedelta(days=1)
update_model_fields(next_day_gs,
update_fields=[
'title', 'active_time', 'chd_posters',
'wem_posters'
])
if state_next:
log_action(request.user.id, next_day_gs, ADDITION, u'新建海报成功')
else:
log_action(request.user.id, next_day_gs, CHANGE, u'修改海报成功')
return HttpResponse(json.dumps(data)) # 传图成功
except GoodShelf.MultipleObjectsReturned:
data = {'code': 3} # 多个海报对象
return HttpResponse(json.dumps(data))
except ValueError:
data = {'code': 4} # ValueError
return HttpResponse(json.dumps(data))
def createMergeTrade(cls, trade, *args, **kwargs):
return
from shopback.trades.handlers import trade_handler
from shopback.trades.models import MergeTrade
seller = cls.getOrCreateSeller(trade)
merge_trade, state = MergeTrade.objects.get_or_create(tid=trade.tid,
user=seller)
update_fields = [
'buyer_nick', 'created', 'pay_time', 'modified', 'status',
'buyer_message'
]
merge_trade.buyer_nick = trade.buyer_nick.strip(
) or trade.receiver_mobile
merge_trade.buyer_message = trade.buyer_message
merge_trade.created = trade.created
merge_trade.modified = trade.modified
merge_trade.pay_time = trade.pay_time
merge_trade.status = SaleTrade.mapTradeStatus(trade.status)
update_address = False
if not merge_trade.receiver_name and trade.receiver_name:
update_address = True
address_fields = [
'receiver_name', 'receiver_state', 'receiver_city',
'receiver_address', 'receiver_district', 'receiver_mobile',
'receiver_phone'
]
for k in address_fields:
setattr(merge_trade, k, getattr(trade, k))
update_fields.extend(address_fields)
merge_trade.payment = merge_trade.payment or float(trade.payment)
merge_trade.total_fee = merge_trade.total_fee or float(trade.total_fee)
merge_trade.post_fee = merge_trade.post_fee or float(trade.post_fee)
merge_trade.trade_from = 0
merge_trade.shipping_type = pcfg.EXPRESS_SHIPPING_TYPE
merge_trade.type = pcfg.SALE_TYPE
update_model_fields(merge_trade,
update_fields=update_fields + [
'shipping_type', 'type', 'payment',
'total_fee', 'post_fee', 'trade_from'
])
for order in trade.sale_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
