def close_timeout_carts_and_orders():
djuser, state = DjangoUser.objects.get_or_create(username='******',
is_active=True)
now = datetime.datetime.now()
all_product_in_cart = ShoppingCart.objects.filter(
status=ShoppingCart.NORMAL, remain_time__lte=now)
for product_in_cart in all_product_in_cart:
product_in_cart.close_cart()
log_action(djuser.id, product_in_cart, CHANGE, u'超出预留时间')
all_trade = SaleTrade.objects.filter(status=SaleTrade.WAIT_BUYER_PAY)
for trade in all_trade:
if trade.is_payable():
continue
try:
charge = xiaolupay.Charge.retrieve(trade.tid)
if charge and charge.paid:
notifyTradePayTask.delay(charge)
else:
trade.close_trade()
log_action(djuser.id, trade, CHANGE, u'超出待支付时间')
except Exception, exc:
logger = logging.getLogger('django.request')
logger.error(exc.message, exc_info=True)
def mama_pay_deposit(customer_id, deposit_type, referrer, trade_id, oid=None):
# type: (int, int, int, int, Optional[text_type]) -> None
"""用户支付押金妈妈记录相关处理
"""
customer = get_customer_by_id(customer_id)
xlmm = customer.get_xiaolumm()
if not xlmm:
return
if deposit_type not in [1, 99, 188]:
return
if deposit_type == 1:
renew_days = XiaoluMama.TRIAL
if not xlmm.is_trialable():
return # 不可以试用
# create_potential_mama(xlmm, referrer) # 创建潜在妈妈记录
elif deposit_type == 99:
renew_days = XiaoluMama.HALF
elif deposit_type == 188:
renew_days = XiaoluMama.FULL
mama_charged = xlmm.chargemama() # 接管妈妈
sys_oa = get_systemoa_user()
if mama_charged:
log_action(sys_oa, xlmm, CHANGE, u'代理接管成功')
xlmm.update_renew_day(renew_days) # 修改下次续费时间
xlmm.deposit_pay() # 支付押金
log_action(sys_oa, xlmm, CHANGE, u'支付押金')
release_coupon_for_deposit(customer_id, deposit_type, trade_id=trade_id) # 发送押金优惠券给用户
update_potential_by_deposit(xlmm.id, renew_days, referrer_mama_id=referrer, oid=oid) # 更新潜在关系记录
signal_xiaolumama_register_success.send_robust(sender=XiaoluMama, xiaolumama=xlmm, renew=True) # 发送信号
def post(self, request):
content = request.POST
product_ids = content.get('product_ids').split(',')
origin_url = content.get('origin_url')
product_qs = Product.objects.filter(outer_id__in=product_ids)
for p in product_qs:
# cnt = 0
# success = False
# invalid_outerid = p.outer_id
# while cnt < 10:
# invalid_outerid += '_del'
# products = Product.objects.filter(outer_id=invalid_outerid)
# if products.count() == 0:
# success = True
# break
# cnt += 1
# if not success:
# continue
# p.outer_id = invalid_outerid
p.status = Product.DELETE
p.save()
log_action(request.user.id, p, CHANGE, u'商品作废')
messages.add_message(request._request, messages.INFO,
u"已成功作废%s个商品!" % (len(product_ids)))
return redirect(origin_url)
def action_receive_money(self, request, queryset):
for order in queryset:
if order.pay_status != u'正常':
order.pay_status = u'正常'
order.save()
log_action(request.user.id, order, CHANGE, u'已收款')
return HttpResponseRedirect(request.get_full_path())
def confirm_get_by_state(out_sid, status):
out_sid = str(out_sid)
status = int(status)
if not out_sid or not status or status != 3:
return
psi = PackageSkuItem.objects.filter(out_sid=out_sid).first()
if psi:
logger.warn({
'action': "kd100",
'info': "confirm_psi_finish_kd100:" + str(out_sid)
})
pid = psi.package_order_pid
PackageOrder.objects.filter(pid=pid).update(
sys_status=PackageOrder.FINISHED_STATUS)
psi.set_status_finish()
packageskuitem = PackageSkuItem.objects.filter(
out_sid=out_sid).values("oid")
if packageskuitem:
packageskuitem = [i['oid'] for i in packageskuitem]
so = SaleOrder.objects.filter(
oid__in=packageskuitem, status=SaleOrder.WAIT_BUYER_CONFIRM_GOODS)
if so:
for i in so:
logger.warn({
'action': "kd100",
'info': "confirm_sign_order_kd100:" + str(out_sid)
})
i.confirm_sign_order()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, i, CHANGE, u'confirm_sign_order_kd100')
def change_pwd_code(self, request):
"""忘记密码时获取验证码"""
mobile = request.data['vmobile']
already_exist = Customer.objects.filter(mobile=mobile).exclude(status=Customer.DELETE)
current_time = datetime.datetime.now()
last_send_time = current_time - datetime.timedelta(seconds=TIME_LIMIT)
if already_exist.count() == 0:
return Response({"result": "1"}) # 尚无用户或者手机未绑定
if mobile == "" or not re.match(PHONE_NUM_RE, mobile): # 进行正则判断
return Response({"result": "false"})
sysoa_user = get_systemoa_user()
reg = Register.objects.filter(vmobile=mobile)
if reg.count() == 0:
new_reg = Register(vmobile=mobile)
new_reg.verify_code = new_reg.genValidCode()
new_reg.verify_count = 0
new_reg.mobile_pass = True
new_reg.code_time = current_time
new_reg.save()
log_action(sysoa_user.id, new_reg, ADDITION, u'新建，忘记密码验证码')
task_register_code.delay(mobile, "2")
return Response({"result": "0"})
else:
reg_temp = reg[0]
if check_day_limit(reg_temp):
return Response({"result": "2"}) # 当日验证次数超过5
if reg_temp.code_time and reg_temp.code_time > last_send_time:
return Response({"result": "3"}) # 180s内已经发送过
reg_temp.verify_code = reg_temp.genValidCode()
reg_temp.code_time = current_time
reg_temp.save()
log_action(sysoa_user.id, reg_temp, CHANGE, u'修改，忘记密码验证码')
task_register_code.delay(mobile, "2")
return Response({"result": "0"})
def check_code(self, request):
"""验证码判断、验证码过时功能"""
current_time = datetime.datetime.now()
last_send_time = current_time - datetime.timedelta(seconds=TIME_LIMIT)
mobile = request.data['username']
verify_code = request.data['valid_code']
if not mobile or not verify_code or len(mobile) == 0 or len(verify_code) == 0:
return Response({"code": 2, "result": "2", "info": "手机验证码不对"})
already_exist = Customer.objects.filter(mobile=mobile).exclude(status=Customer.DELETE)
if already_exist.count() > 0:
return Response({"code": 1, "result": "1", "info": "已经绑定用户"})
django_user = request.user
customer = get_object_or_404(Customer, user=django_user)
reg = Register.objects.filter(vmobile=mobile)
if reg.count() == 0:
return Response({"code": 3, "result": "3", "info": "手机未注册"})
reg_temp = reg[0]
reg_temp.submit_count += 1 # 提交次数加一
reg_temp.cus_uid = customer.id
reg_temp.save()
log_action(request.user.id, reg_temp, CHANGE, u'验证码验证')
if reg_temp.code_time and reg_temp.code_time < last_send_time:
return Response({"code": 4, "result": "4", "info": "验证码过期"})
verify_code_server = reg_temp.verify_code
if verify_code_server != verify_code:
return Response({"code": 5, "result": "5", "info": "验证码不对"})
return Response({"code": 0, "result": "OK", "info": "success"})
def post(self, request):
# type: (HttpRequest) -> Response
"""发送红包
"""
content = request.POST or request.data
customer_id = content.get('customer_id') or None
customer_id = int(customer_id)
amount = content.get('amount') or '0'
memo = content.get('memo') or None
flow_amount = int(decimal.Decimal(amount) * 100) # 以分为单位
if flow_amount == 0:
return Response({
'code': 1,
'info': '红包金额不能为0',
'data': self.get_budget_data(customer_id)
})
# 添加红包钱包记录
budget_log = BudgetLog.create(customer_id=int(customer_id),
budget_type=BudgetLog.BUDGET_IN,
flow_amount=flow_amount,
budget_log_type=BudgetLog.BG_ENVELOPE)
log_action(request.user, budget_log, ADDITION, u'赠送红包 %s' % memo)
data = self.get_budget_data(customer_id)
return Response({'code': 0, 'info': 'success', 'data': data})
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 set_invalid(self, request, pk=None):
from shopback.items.tasks import releaseProductTradesTask
inbound = InBound.objects.get(id=pk)
if inbound.status == InBound.INVALID:
return Response({'error': '已经作废'})
orderlist_ids = set()
outer_ids = set()
for inbounddetail in InBoundDetail.objects.filter(inbound=inbound):
for record in inbounddetail.records.filter(
status=OrderDetailInBoundDetail.NORMAL):
inbounddetail = record.inbounddetail
orderdetail = record.orderdetail
sku = inbounddetail.sku
orderlist_ids.add(orderdetail.orderlist_id)
outer_ids.add(sku.product.outer_id)
if record.arrival_quantity > 0:
sku.quantity -= record.arrival_quantity
sku.save()
log_action(request.user.id, sku, CHANGE, u'作废入仓单%d: 更新库存%+d'
% (inbound.id, 0 - record.arrival_quantity))
record.status = OrderDetailInBoundDetail.INVALID
record.save()
if orderlist_ids:
inbound.update_orderlist(request, list(orderlist_ids))
if outer_ids:
releaseProductTradesTask.delay(list(outer_ids))
inbound.status = InBound.INVALID
inbound.save()
log_action(request.user.id, inbound, CHANGE, u'作废')
return Response({})
def complete_staff_event(request, id):
try:
event = StaffEvent.objects.get(id=id)
except StaffEvent.DoesNotExist:
ret = {'code': 1, 'response_error': '未找到该事件'}
else:
event.is_finished = True
event.save()
ret = {
'code': 0,
'response_content': {
'id': event.id,
'creator': event.creator.username,
'executor': event.executor.username,
'start': format_datetime(event.start),
'end': format_datetime(event.end),
'interval_day': event.interval_day,
'title': event.title,
'type': event.type,
'created': format_datetime(event.created),
'modified': format_datetime(event.modified),
'is_finished': event.is_finished,
}
}
log_action(request.user.id, event, CHANGE, u'完成事件')
return HttpResponse(json.dumps(ret), content_type="application/json")
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 post(self, request, *args, **kwargs):
post = request.POST
supplier_name = post.get("supplier_name")
supplier_code = post.get("supplier_code", "")
main_page = post.get("main_page", "")
platform = post.get("platform")
category = post.get("category")
contact_name = post.get("contact_name")
mobile = post.get("mobile")
address = post.get("contact_address")
memo = post.get("note")
progress = post.get("progress")
speciality = post.get("speciality", '')
supplier_type = post.get("supplier_type", 0)
supplier_zone = post.get("supplier_zone", 0)
ware_by = int(post.get('ware_by') or 0)
new_supplier = SaleSupplier(supplier_name=supplier_name,
supplier_code=supplier_code,
main_page=main_page,
platform=platform,
category_id=category,
contact=contact_name,
mobile=mobile,
address=address,
memo=memo,
progress=progress,
speciality=speciality,
supplier_type=supplier_type,
supplier_zone=supplier_zone,
ware_by=ware_by)
new_supplier.save()
log_action(request.user.id, new_supplier, ADDITION, u'新建'.format(""))
return Response({"supplier_id": new_supplier.id})
def task_update_trial_mama_full_member_by_condition(mama):
"""
检查该妈妈的推荐人是否是 试用用户
如果是 试用用户数
满足邀请三个188 或者
这里用续费天数 判断
"""
if True:
return
trial_mama = XiaoluMama.objects.filter(mobile=mama.referal_from,
status=XiaoluMama.EFFECT, # 自接管后 15天 变为冻结
last_renew_type=XiaoluMama.TRIAL).first() # 推荐人(试用用户并且是有效状态的)
if not trial_mama:
return
join_mamas = XiaoluMama.objects.filter(referal_from=trial_mama.mobile,
status=XiaoluMama.EFFECT,
last_renew_type=XiaoluMama.FULL, # 邀请的是188
agencylevel__gte=XiaoluMama.VIP_LEVEL,
charge_status=XiaoluMama.CHARGED) # 推荐人邀请的正式妈妈
if join_mamas.count() >= 3: # 满足条件
trial_mama.last_renew_type = XiaoluMama.HALF # 转正为半年的类型
trial_mama.renew_time = trial_mama.renew_time + datetime.timedelta(days=XiaoluMama.HALF)
trial_mama.save(update_fields=['last_renew_type', 'renew_time'])
sys_oa = get_systemoa_user()
log_action(sys_oa, trial_mama, CHANGE, u'满足转正条件,转为正式妈妈')
# 修改潜在小鹿妈妈列表中的 转正状态
potential = PotentialMama.objects.filter(potential_mama=trial_mama.id, is_full_member=False).first()
if potential:
potential.is_full_member = True
potential.save(update_fields=['is_full_member'])
log_action(sys_oa, potential, CHANGE, u'满足转正条件,转为正式妈妈')
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 destroy(self, request, pk, format=None):
salecategory = SaleCategory.objects.filter(cid=pk).first()
if salecategory:
salecategory.delete()
cache.delete(SaleCategory.CACHE_KEY)
log_action(request.user, salecategory, DELETION, u'删除分类')
return Response(status=status.HTTP_204_NO_CONTENT)
def batch_taotai_action(self, request, queryset):
""" 批量淘汰 """
supplier_ids = []
for supplier in queryset:
supplier_ids.append(supplier.id)
saleproduct_ids = []
for saleproduct in SaleProduct.objects.filter(
sale_supplier_id__in=supplier_ids).exclude(
status=SaleProduct.REJECTED):
saleproduct_ids.append(saleproduct.id)
today = datetime.datetime.now().date()
product_ids = []
for product in Product.objects.filter(sale_product__in=saleproduct_ids,
status=Product.NORMAL,
sale_time__gte=today):
product_ids.append(product.id)
if product_ids:
self.message_user(request, '以下商品正在上架')
return HttpResponseRedirect('/admin/items/product/?id__in=%s' %
','.join([str(x)
for x in product_ids]))
employee = request.user
for saleproduct in SaleProduct.objects.filter(id__in=saleproduct_ids):
saleproduct.status = SaleProduct.REJECTED
saleproduct.save()
log_action(employee.id, saleproduct, CHANGE, u'淘汰成功')
for supplier in queryset:
supplier.progress = SaleSupplier.REJECTED
supplier.save()
log_action(employee.id, supplier, CHANGE, u'淘汰成功')
self.message_user(request, u"======= 商家批量淘汰成功 =======")
return HttpResponseRedirect("./")
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = serializers.ModifySaleProductSerializer(instance,
data=request.data,
partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
self.set_instance_special_fields(serializer) # 设置价格等信息
model_product = instance.model_product
if model_product: # 有款式
try:
params = {
'name': instance.title.replace('/', ''),
'salecategory_id': instance.sale_category.id,
'product_type': instance.get_product_type(),
'is_boutique': instance.get_boutique_value(),
'source_type': instance.source_type,
}
updated = model_product.update_fields_with_kwargs(**params)
if updated:
log_action(request.user, model_product, CHANGE,
json.dumps(params, indent=2))
Product.create_or_update_skus(
model_product, request.user) # 保存saleproduct 之后才做更新
except Exception, exc:
logger.error(str(exc), exc_info=True)
raise exceptions.APIException(str(exc))
def change_pwd_code(self, request):
"""修改密码时获取验证码"""
current_time = datetime.datetime.now()
last_send_time = current_time - datetime.timedelta(seconds=TIME_LIMIT)
django_user = request.user
customer = get_object_or_404(Customer, user=django_user)
if customer.mobile == "" or not re.match(PHONE_NUM_RE, customer.mobile): # 进行正则判断，待写
return Response({"code": 1, "result": "false", "info": "手机号码不对"})
reg = Register.objects.filter(vmobile=customer.mobile)
if reg.count() == 0:
new_reg = Register(vmobile=customer.mobile)
new_reg.verify_code = new_reg.genValidCode()
new_reg.verify_count = 0
new_reg.mobile_pass = True
new_reg.code_time = current_time
new_reg.save()
log_action(request.user.id, new_reg, ADDITION, u'登录后，新建，修改密码')
task_register_code.delay(customer.mobile, "2")
return Response({"code": 0, "result": "0", "info": "success"})
else:
reg_temp = reg[0]
if check_day_limit(reg_temp):
return Response({"code": 2, "result": "2", "info": "当日验证次数超过5"})
if reg_temp.code_time and reg_temp.code_time > last_send_time:
return Response({"code": 3, "result": "3", "info": "180s内已经发送过"})
reg_temp.verify_code = reg_temp.genValidCode()
reg_temp.code_time = current_time
reg_temp.save()
log_action(request.user.id, reg_temp, ADDITION, u'登录后，修改密码')
task_register_code.delay(customer.mobile, "2")
return Response({"code": 0, "result": "0", "info": "success"})
def post(self, request, *args, **kwargs):
content = request.POST
package_no = content.get('package_no')
package_weight = content.get('package_weight')
if not self.isValidYundaId(package_no):
return u'非法的运单号'
package_id, valid_code, dc_code = self.parseYundaId(package_no)
try:
lo = LogisticOrder.objects.get(out_sid=package_no)
except LogisticOrder.DoesNotExist:
return u'运单号未录入系统'
try:
float(package_weight)
except:
return u'重量异常:%s' % package_weight
lo.weight = package_weight
lo.valid_code = valid_code
lo.dc_code = dc_code
lo.save()
tspw, state = TodaySmallPackageWeight.objects.get_or_create(
package_id=package_no)
tspw.weight = package_weight
tspw.save()
log_action(request.user.id, lo, CHANGE, u'扫描称重')
return Response({'isSuccess': True})
def post(self, request, *args, **kwargs):
content = request.POST
user = request.user
product = content.get("product")
product_bean = Product.objects.filter(id=product,
status=Product.NORMAL)
if product_bean.count() == 0:
return Response({"result": "error"})
product_model = product_bean[0]
all_sku = [key.properties_alias for key in product_model.normal_skus]
all_chi_ma = set()
for k, v in content.items():
if len(k.split("_")) == 3:
all_chi_ma.add(k.split("_")[2].strip())
chi_ma_result = {}
for sku in all_sku:
for chi_ma in all_chi_ma:
chi_ma_content = content.get(
str(product_model.id) + "_" + sku + "_" + chi_ma)
if chi_ma_content and len(
chi_ma_content) > 0 and chi_ma_content != "0":
if sku in chi_ma_result:
chi_ma_result[sku][chi_ma] = chi_ma_content
else:
chi_ma_result[sku] = {chi_ma: chi_ma_content}
try:
product_model.contrast.contrast_detail = chi_ma_result
product_model.contrast.save()
log_action(user.id, product_model, CHANGE, u'修改尺码表内容')
except:
chima_model = ProductSkuContrast(product=product_model,
contrast_detail=chi_ma_result)
chima_model.save()
log_action(user.id, product_model, ADDITION, u'新建尺码表内容')
return Response({"result": "OK"})
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 action_timeout_reforecast(self, request, queryset):
staging_qs = queryset.filter(status__in=(ForecastInbound.ST_APPROVED,
ForecastInbound.ST_DRAFT))
if not staging_qs.exists():
self.message_user(request, u"＊＊＊重新预测到货需在草稿或审核状态下处理＊＊＊!")
return HttpResponseRedirect(request.get_full_path())
new_forecast_obj_list = []
try:
for obj in queryset:
if not obj.is_arrival_timeout():
continue
new_forecast = strip_forecast_inbound(obj.id)
if not new_forecast:
continue
log_action(request.user.id, new_forecast, ADDITION,
u'超时重新预测到货,原单(id:%s)' % (obj.id))
new_forecast_obj_list.append(new_forecast)
new_forecast.memo += u">>> 超时重新预测,上次预测时间:%.19s \n" % obj.forecast_arrive_time
new_forecast.save(update_fields=['memo'])
obj.status = ForecastInbound.ST_TIMEOUT
obj.save(update_fields=['status'])
except Exception, exc:
self.message_user(request, u"创建出错:%s" % exc.message)
def post(request):
post = request.POST
m = ModelProduct()
buy_limit = post.get("buy_limit", 0)
m.name = post["product_name"]
m.sale_time = post["df"]
m.head_imgs = post.get('head_img', '')
m.content_imgs = post.get('content_img', '')
if buy_limit == "on":
m.buy_limit = True
m.per_limit = int(post.get("per_limit", 0))
m.save()
log_action(request.user.id, m, ADDITION, u'新建款式')
product_id_list = post.getlist("product_id")
for product_id in product_id_list:
product = Product.objects.filter(id=product_id).first()
if product:
color_name = product.name.find(
'/') >= 0 and product.name.split('/')[1] or ''
product.name = '%s/%s' % (m.name, color_name)
product.model_id = m.id
product.save(update_fields=['name', 'model_id'])
log_action(request.user.id, product, CHANGE,
u'聚合商品到{0}'.format(m.id))
return redirect("/mm/aggregeta_product/")
def post(request):
post = request.POST
product_id_list = post.getlist("product_id")
model_id = post.get("model_id", 0)
m = ModelProduct.objects.get(id=model_id)
all_model_product = ModelProduct.objects.exclude(
status=u'1').order_by('-created')[0:20]
for product_id in product_id_list:
pro = Product.objects.filter(id=product_id)
if pro.count() > 0:
temp_pro = pro[0]
temp_pro.model_id = m.id
temp_pro.save()
log_action(request.user.id, temp_pro, CHANGE,
u'修改款式ID为{0}'.format(model_id))
all_product = Product.objects.filter(model_id=m.id)
return render(
request,
"pay/aggregate_product2already.html",
{
"target_model": m,
"all_product": all_product,
"all_model_product": all_model_product
},
)
def relate_refund_product(request):
content = request.POST
refund_tid = content.get('refund_tid')
rpid = content.get('rpid')
try:
trade = MergeTrade.objects.get(tid=refund_tid)
except:
return HttpResponse(json.dumps({
'code': 1,
'response_error': u'订单不存在'
}),
content_type="application/json")
try:
refund_prod = RefundProduct.objects.get(id=rpid)
except:
return HttpResponse(json.dumps({
'code': 1,
'response_error': u'退回商品不存在'
}),
content_type="application/json")
refund_prod.trade_id = trade.tid
refund_prod.buyer_nick = trade.buyer_nick
refund_prod.save()
log_action(request.user.id, refund_prod, CHANGE, u'关联订单')
ret_params = {'code': 0, 'response_content': {'success': True}}
return HttpResponse(json.dumps(ret_params),
content_type="application/json")
def update_product_details(self, request, *args, **kwargs):
content = request.data
saleproduct_id = content.get("saleproduct_id") or 0
saleproduct = SaleProduct.objects.filter(id=saleproduct_id).first()
if not saleproduct:
raise exceptions.APIException(u"选品ID错误!")
content_imgs = content.get('content_imgs') or ''
if isinstance(content_imgs, list):
request.data.update({'content_imgs': '\n'.join(content_imgs)})
instance = saleproduct.model_product
partial = kwargs.pop('partial', False)
new_properties = request.data.get('new_properties') or None
request_extras = request.data.get('extras') or None
if request_extras is not None or new_properties:
extras = self.get_request_extras(request, instance)
request.data.update({'extras': extras})
request.data.update(
{'name': instance and instance.name or saleproduct.title})
request.data.update({
'salecategory': instance.salecategory.id,
}) # 类别不予更新（使用原来的类别）
request.data.update(
{'lowest_agent_price':
instance.lowest_agent_price}) # 最低售价（价格由sku决定）
request.data.update(
{'lowest_std_sale_price':
instance.lowest_std_sale_price}) # 最低吊牌价（价格由sku决定）
serializer = serializers.ModelProductUpdateSerializer(
instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
log_action(request.user, instance, CHANGE, u'修改款式信息')
return Response(serializer.data)
def confirm_get_by_content(out_sid, content): #根据物流内容自动确认收货
out_sid = str(out_sid)
confirm_psi_finish(out_sid=out_sid, content=content)
logging.warn("confirm_get_by_content")
logger.warn({'action': "kdn", 'info': "confirm_get_by_content:" + out_sid})
if content.find("\u5df2\u7b7e\u6536") != -1 or content.find(
"\u59a5\u6295") != -1:
packageskuitem = PackageSkuItem.objects.filter(
out_sid=out_sid).values("oid")
if packageskuitem:
packageskuitem = [i['oid'] for i in packageskuitem]
so = SaleOrder.objects.filter(
oid__in=packageskuitem,
status=SaleOrder.WAIT_BUYER_CONFIRM_GOODS)
if so:
for i in so:
logger.warn({
'action': "kdn",
'info': "confirm_sign_order:" + out_sid
})
i.confirm_sign_order()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, i, CHANGE,
u'confirm_sign_order confirm_get_by_content')
def comfirm_get(out_sid, status): #根据物流状态自动确认收货
out_sid = str(out_sid)
confirm_psi_finish(out_sid=out_sid, status=status)
logging.warn("comfirm_get")
logger.warn({'action': "kdn", 'info': "start_comfirm_get:" + out_sid})
tradewuliu = TradeWuliu.objects.filter(out_sid=out_sid).order_by("-id")
confirm_get_by_content(out_sid, tradewuliu.first().content)
packageskuitem = PackageSkuItem.objects.filter(
out_sid=out_sid).values("oid")
logger.warn({
'action': "kdn",
'info': "oid_by_out_sid:" + json.dumps(list(packageskuitem))
})
if packageskuitem and int(status) == 3:
logger.warn({'action': "kdn", 'info': "exp_num:" + out_sid})
packageskuitem = [i['oid'] for i in packageskuitem]
so = SaleOrder.objects.filter(
oid__in=packageskuitem, status=SaleOrder.WAIT_BUYER_CONFIRM_GOODS)
if so:
for i in so:
logger.warn({
'action': "kdn",
'info': "change_get_goods:" + out_sid
})
i.confirm_sign_order()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, i, CHANGE,
u'confirm_sign_order comfirm_get')
def update_Unrelate_Prods_Product(pro, req):
REFUND_REASON = ((0, u'其他'), (1, u'错拍'), (2, u'缺货'), (3,
u'开线/脱色/脱毛/有色差/有虫洞'),
(4, u'发错货/漏发'), (5, u'没有发货'), (6, u'未收到货'), (7, u'与描述不符'),
(8, u'退运费'), (9, u'发票问题'), (10, u'七天无理由退换货'))
refund = get_refund_by_refundproduct(pro)
if refund: # 如果系统已经创建该退款单
# print "其实已经创建了退款单"
refund.has_good_return = True
refund.save()
else: # 没有记录则创建一条记录
# 根据原单 trade_id 找 MergeTrade
# print "好 创建退货"
reason = pro.reason #
reason_str = REFUND_REASON[int(reason)][1]
# 确认 MergeOrder 的存在后 创建 退货款单
package_sku_item = get_package_sku_item(pro)
if not package_sku_item:
# print " 没有package_sku_item记录"
return
try:
# 根据 MergeOrder 的情况创建 退货款单
package_order = PackageOrder.objects.get(
pid=package_sku_item.package_order_pid)
refund = Refund()
refund.tid = package_sku_item.sale_trade_id # 交易ID
refund.title = package_sku_item.title # 标题
refund.num_iid = package_sku_item.outer_id or 0 # 商品ID=商品编码
# refund.user = package_sku_item.user # 店铺在ＰackageSkuItem表中没有这个字段
# refund.seller_id = # 卖家ID
refund.buyer_nick = package_order.buyer_nick # 买家昵称
# refund.seller_nick = PackageOrder.objects.get(pid=package_sku_item.package_order_pid).seller_nick # 卖家昵称在ＰackageSkuItem表中没有这个字段
refund.mobile = package_sku_item.receiver_mobile # 收件人手机 （这里不使用退货物流的手机号码）
refund.phone = package_order.receiver_phone # 电话
refund.total_fee = package_sku_item.total_fee # 订单总费用
# refund.refund_fee # 退款费用
refund.payment = package_sku_item.payment # 实付款
refund.oid = package_sku_item.oid # 订单ID
refund.company_name = package_sku_item.logistics_company_name # 仓库收到退回产品的发货物流公司
refund.sid = package_sku_item.out_sid # 仓库收到退回产品的快递单号
refund.reason = reason_str # 退货原因
# refund.desc = # 描述
refund.has_good_return = True # 是否退货（是）
refund.good_status = GOOD_STATUS_CHOICES[2][0] # 退货商品的状态（买家已经退货）
# refund.order_status = Refund. # 退货商品的订单状态
refund.cs_status = 2 # 需要客服介入
refund.status = pcfg.REFUND_CONFIRM_GOODS # 买家已经退货
refund.save() # 保存数据
# print refund.id
# merge_trade[0].status = pcfg.TRADE_CLOSED # 修改MergeTrade status 为关闭
# merge_trade[0].save() # 保存
action_desc = u"创建交易ID为：{0} 商品标题为：{1}的 Refund ".format(
package_sku_item.sale_order_id, package_sku_item.title)
log_action(req.user.id, refund, ADDITION, action_desc) # 创建操作日志
# print "到这里了"
except Exception, exc:
logger.error(exc.message, exc_info=True)
