def save_model(self, request, obj, form, change):
if obj.pk:
obj.modified_at = get_now()
else:
obj.created_at = obj.modified_at = get_now()
obj.created_by = request.user
return super(BaseContentAdmin, self).save_model(request, obj, form, change)
def get_tracking_no_ahead():
"""真正执行的脚本"""
print "***START assign shipping***", get_now()
ahead_assign_shipping()
print "***END assign shipping***", get_now()
print "***START shipping order***", get_now()
ahead_shipping_order()
print "***END shipping order***", get_now()
def manage_script(fun):
# 通过在shell命令行增加参数, 来确定脚本是立刻执行还是定时执行
# upervisor中默认没有参数, 所以supervisor始终为定时执行
start_now = False
if len(sys.argv) == 2 and sys.argv[1] == 'now':
start_now = True
# 脚本的执行时间, 保存在our_config中, key为方法名称
timings = ScriptTimings.script_dict[fun.__name__]['timings']
while True:
# 如果不是立刻开始, 说明是需要进行循环跑的
if not start_now:
timing_start(timings)
# 在方法执行之前, 进行脚本创建
script_log = ScriptLog.objects.create(process=fun.__name__,
date_from=get_now(),
running_status=2)
connection.close()
# 执行方法, 如果发生异常, 则捕获异常, 并结束循环
try:
fun()
except Exception, e:
script_log.date_to = get_now()
script_log.running_status = 0
script_log.content = e
script_log.save()
break
# 方法执行结束, 进行善后处理
script_log.date_to = get_now()
script_log.running_status = 1
script_log.run_time = round(
(script_log.date_to - script_log.date_from).total_seconds() / 60.0,
2)
script_log.save()
connection.close()
sys.stdout.flush()
gc.collect()
# 如果是要立刻开始的, 说明是手动跑的, 这次跑完, 则中断循环
if start_now:
break
time.sleep(60)
def nxb_get_data(packages):
result = {
'datas': [],
'template': 'nxb.html',
'msg': '',
}
for package in packages:
packageitem = package.set_to_logistics()
data = {
'package_id': package.id,
'address': package.name + '<br>'\
+ package.address + '<br>'\
+ package.shipping_city + ','\
+ package.shipping_state + ','\
+ package.shipping_country.name,
'zip': package.shipping_zipcode,
'phone': package.shipping_phone,
'tracking_code': package.tracking_no,
'country_code': package.shipping_country.code,
'country_cn': package.shipping_country.cn_name,
'set': packageitem.name,
'date': get_now(),
'customs_amount': package.custom_amount,
}
result['datas'].append(data)
return result
def get_wish_order():
print "**START**", get_now()
channel_accounts = get_accounts('wish')
for account in channel_accounts:
print "\n *Account: %s Start" % account.name
try:
wish = Wish(client_id=account.client_id,
client_secret=account.client_secret,
refresh_token=account.refresh_token
)
except Exception, e:
print "Failure, account: ", account.name, get_now(), e
continue
#取最近2天
next_page = "First"
since = (get_now() - datetime.timedelta(days=2)).isoformat()[:-6]
while next_page:
try:
if next_page == "First":
datas = wish.list_order(since, limit=5)
else:
datas = wish.list_order_by_next_page(next_page)
next_page = datas.get('paging', {}).get('next', '')
except Exception, e:
print ee(e), get_now()
break
order_list = datas.get('data', [])
#如果最后一页只有一个订单,数据类型会变成字典,需转换成列表
if type(order_list) == dict:
order_list = [order_list]
# pp(order_list)
order_dicts = data_to_order_dicts(order_list, account)
for ordernum, order_dict in order_dicts.iteritems():
r = import_order(order_dict)
#每导入一个订单, 打印出订单信息
print "Success" if r['success'] else 'Failure',\
ordernum, get_now(), account.name, r['msg'].strip()
def data_to_order_dicts(order_list, account):
order_dicts = {}
for order_info in order_list:
order = order_info['Order']
ordernum = order['transaction_id']
import_note = ''
try:
sku = order['sku']
qty = int(order['quantity'])
price = float(order['price'])
order_item = {
'sku': sku,
'qty': qty,
'price': price,
'channel_oi_id': order['order_id'],
}
except Exception, e:
import_note += u'| orderitem 有误 %s \n' % ee(e)
if ordernum not in order_dicts:
order_dict = {}
order_dict['ordernum'] = ordernum
order_dict['channel'] = account
order_dict['order_items'] = [order_item]
# 金额的计算, 使用扣除平台费之前的金额
try:
order_dict['currency'] = "USD"
order_dict['rate'] = 1.0
order_dict['amount_shipping'] = float(order['shipping']) * qty
order_dict['amount'] = qty * price + order_dict['amount_shipping']
except Exception, e:
import_note += u'| 订单金额有误 %s \n' % ee(e)
order_dict['shipping_type'] = 0
order_dict['create_time'] = eparse(order['order_time'] + '+00:00')
order_dict['latest_ship_date'] = get_now() + datetime.timedelta(hours=int(order['hours_to_fulfill']))
# 地址信息
try:
address_info = order['ShippingDetail']
order_dict['shipping_firstname'] = address_info['name']
order_dict['shipping_address'] = address_info.get('street_address1', '') + u" " + \
address_info.get('street_address2', '')
order_dict['shipping_city'] = address_info['city']
order_dict['shipping_state'] = address_info.get('state', '')
order_dict['shipping_country_code'] = address_info['country']
order_dict['shipping_zipcode'] = address_info.get('zipcode', '')
order_dict['shipping_phone'] = address_info['phone_number']
except Exception, e:
import_note += u'| 订单地址信息有误 %s \n' % ee(e)
def save(self, *args, **kwargs):
kwargs['using'] = settings.BILLING_DB
assigned_at = kwargs.pop("assigned_at", None)
if not kwargs.pop("no_assigned_at_save", False):
if assigned_at:
self.assigned_at = assigned_at
else:
self.assigned_at = get_now()
# self.update_free_reserved(save=False)
return super(ExternalNumber, self).save(*args, **kwargs)
def ahead_assign_shipping():
# 给速卖通的package提前跑运单号
packages = Package.objects.filter(shipping__isnull=True)\
.filter(order__channel__type=2)\
.exclude(status=4)
print packages
for package in packages:
carrier = package.get_carrier()
if carrier:
shipping = Shipping.objects.filter(label=carrier).first()
if not shipping:
print "Failure", package.id, get_now(), carrier, "not exist"
continue
package.shipping = shipping
package.option_log += u'\n IT 在%s 通过 提前跑运单号 分配了物流方式%s' % (
get_now(), shipping.label)
package.save()
print "Success", package.id, get_now(), shipping
else:
print "Failure", package.id, get_now(), "not assign carrier"
def timing_start(times):
while True:
now_minute = get_now().minute
now_hour = get_now().hour
if now_minute == 0:
print 'Time is %s:00' % now_hour
if type(times) == list:
if time.strftime('%H:%M') in times:
print '%s START' % time.strftime('%H:%M')
break
elif type(times) == dict:
if (not (now_hour + times['start_hour']) % times['interval_hour']
) and now_minute == times['start_minute']:
print '%s START' % time.strftime('%H:%M')
break
sys.stdout.flush()
time.sleep(45)
return True
def get_smt_order():
print "**START**", get_now()
# 获取所有速卖有效通账号
channel_accounts = get_accounts('Smt')
for account in channel_accounts:
print "\n *Account: %s Start" % account.name
# 如果帐号尝试失败, 则继续下一个帐号
success_num = 0
for i in range(10):
try:
aliexpress = Aliexpress(
app_key=account.app_key,
app_pwd=account.app_pwd,
refresh_token=account.refresh_token,
)
data = aliexpress.list_order(page=1, page_size=1)
totalItem = data.get('totalItem') or '0'
break
except Exception, e:
print ee(e)
print "Failure %s , try numbers: %s" % (account.name, i + 1)
else:
print "**Failure %s" % account.name
continue
print "Total: ", totalItem
# 如果没有订单, 则换帐号
if int(totalItem) == 0:
print account.name, "has no order."
time.sleep(2)
continue
# 因为目的只是获取订单号, 所以page_size设置的较大
page_size = 30
order_info = []
# pages向上取整, 使用(A+B-1)/B, range最右再加一页
pages = int((int(totalItem) + page_size - 1) / page_size) + 1
for i in range(1, pages):
for k in range(3):
try:
data = aliexpress.list_order(page=i, page_size=page_size)
break
except Exception, e:
print 'Get page timeout.Numbers:%s Page:%s ' % (k, i)
# 订单的备注信息只在这里有, 在订单的详细信息中没有, 但是有的订单会没有memo字段, 因此使用字典的get方法
order_info += [(str(j['orderId']), j.get('memo', ''))
for j in data['orderList']]
time.sleep(1)
def ahead_shipping_order():
# 给速卖通的package提前获取运单号
packages = Package.objects.filter(shipping__isnull=False)\
.filter(order__channel__type=2)\
.filter(tracking_no='')\
.exclude(status=4)\
.filter(shipping__label__in=ShippingList.have_api_shipping)
for package in packages:
# todo 测试的时候不走sfru
# if package.shipping.label == 'SFRU':
# print 'SFRU continue'
# continue
result = logistics_tracking_no(package)
if result['success']:
# todo 记录谁在什么时候分配的运单号
package.tracking_no = result['tracking_no']
package.option_log += u'\n IT 在%s 通过 提前跑运单号 获取了运单号%s' % (
get_now(), result['tracking_no'])
package.save()
print "Success", package.id, package.shipping.label, get_now(
), package.tracking_no
else:
print "Failure", package.id, package.shipping.label, get_now(
), result['msg']
def eub_distribute(package):
result = {
'success': False,
'tracking_no': '',
'msg': '',
}
# eub的api可能会卡主, 因此设置timeout=5执行时间, 最大尝试次数为3
for i in range(3):
try:
eub = Eub(package.shipping.label)
tracking_data = eub.order(package)
break
except Exception, e:
print "EUB try numbers:%s timeout. %s %s %s" % (i + 1, package.id,
get_now(), str(e))
tracking_data = ''
def handle(request):
data = {}
if request.POST.get('type') == 'orderitem_detail':
try:
from_time = eparse(request.POST.get('from'), offset=" 00:00:00+08:00")
to_time = eparse(request.POST.get('to'), offset=" 00:00:00+08:00") or get_now()
except Exception, e:
messages.error(request, u'请输入正确的时间格式')
return redirect('order_handle')
shop = request.POST.get('shop')
channel_id = request.POST.get('channel')
response, writer = write_csv("order_cost")
orderitem_detail(writer, from_time, to_time, shop, channel_id)
return response
def check_and_add_needed_docs(user):
"Проверяет на наличие необходимых подписанных документов. При их отсутствии - создает на них заявки"
profile = user.get_profile()
if not profile.is_card:
for doc_slug in NEEDED_DOCS:
sd = get_signed(user, doc_slug)
if not sd:
# если нету заявок на этот документ - создаем заявку.
app = get_application(user, doc_slug)
if not app:
doc = FinDoc.objects.get(slug=doc_slug)
sd = FinDocSignApplication(
assigned_to=user,
assigned_at=get_now(),
findoc=doc,
)
sd.save()
def sfhome_get_data(packages):
result = {
'datas': [],
'template': 'sfhome.html',
'msg': '',
}
sf = Sfhome()
for package in packages:
packageitem = package.set_to_logistics()
# todo 这个destcode需要使用api查询
destcode = sf.search(package.id)["destcode"]
# todo 展示的tracking_no是3位字母之间一个空格
sub_tracking_no = " ".join([package.tracking_no[i:i+3] for i in range(0, len(package.tracking_no), 3)])
data = {
"server_type": "标准快递",
"destcode": destcode,
"des_country": package.shipping_country.code,
"des_city": package.shipping_city,
"des_state": package.shipping_state,
"des_address": package.address,
"des_ship_name": package.name,
"des_phone": package.shipping_phone,
"tracking_no": package.tracking_no,
"sub_tracking_no": sub_tracking_no,
"actual_weight": 0.3,
"billing_weight": "",
"source_state": "广州省",
"source_city": "广州市",
"source_district": "白云区",
"source_address": "石槎路穗新创意园 A402",
"source_name": "韦胜彬",
"source_phone": 13218887792,
"source_code": "020",
# todo 在html上使用过滤器
"ship_data": get_now(),
"ship_ordernum": str(package.id),
"ship_good_name": packageitem.cn_name,
"total_value": total_value,
}
result['datas'].append(data)
return result
def eub_get_data(packages):
result = {
'datas': [],
'template': 'eub.html',
'msg': '',
}
for package in packages:
packageitem = package.set_to_logistics()
if package.shipping_country.code == 'US':
country_name = 'UNITED STATES OF AMERICA'
else:
result['msg'] += u' | package: ' + str(package_id) + u'不发美国之外的国家'
result['datas'].append({})
continue
if package.shipping_country.code == "US":
pick_code = Eub.get_pick_code(package.shipping_zipcode)
else:
pick_code = 4
data = {
'package_id': package.id,
'ship_name': package.name,
'ship_address': package.address,
'ship_city': package.shipping_city,
'ship_state': package.shipping_state,
'ship_country': country_name,
'zip': package.shipping_zipcode,
'phone': package.shipping_phone,
'tracking_code': package.tracking_no,
'country_code': package.shipping_country.code,
'set_name': packageitem.name,
'set_cn_name': packageitem.cn_name,
'date': get_now(),
'qty': package.qty,
'customs_amount': package.custom_amount,
'pick_code': pick_code,
}
result['datas'].append(data)
return result
def nxb_distribute(package):
result = {
'success': False,
'tracking_no': '',
'msg': '',
}
nxb_code = NxbCode.objects.filter(is_used=0).first()
if not nxb_code:
result['msg'] += u'nxb的运单号已经用完'
else:
nxb_code.is_used = 1
nxb_code.used_time = get_now()
nxb_code.package_id = package.id
nxb_code.save()
result['success'] = True
result['tracking_no'] = nxb_code.code
return result
def sfru_get_data(packages):
result = {
'datas': [],
'template': 'sfru.html',
'msg': '',
}
for package in packages:
packageitem = package.set_to_logistics()
pick_code = Sfru.get_pick_code(package.shipping_country.code)
if not pick_code:
result['msg'] += u' | package %s 没有拣货码' % package.id
result['datas'].append({})
continue
datas = {
'package_id': package.id,
'ship_name': package.name,
'ship_address': package.address,
'ship_city': package.shipping_city,
'ship_state': package.shipping_state,
'zip': package.shipping_zipcode,
'ship_country': package.shipping_country.code,
'phone': package.shipping_phone,
'tracking_no': package.tracking_no,
'sf_numbers': package.sf_numbers,
'country_code': package.shipping_country,
'set_name': packageitem.name,
'set_cn_name': packageitem.cn_name,
'date': get_now(),
'qty': package.qty,
'customs_amount': package.custom_amount,
'product_amount': package.price,
'actual_weight': 0.3,
'product_weight': round(0.3 / package.qty, 2),
'pick_code': pick_code,
}
result['datas'].append(datas)
return result
def create_and_delete_application(request, slug, redirect_after_sign):
"Удаляет старые заявки и создает новые"
user = request.user
app_list = get_real_application(user)
for app in app_list: # удаляем все существующие заявки для данного пользователя
app.delete()
doc = FinDoc.objects.get(slug=slug)
if not request.POST:
request.POST = request.GET
user_can_cancel = True
if slug in ('dop_soglashenie_izmenenie_requisites',):
user_can_cancel = False
sd = FinDocSignApplication(
assigned_to=user,
assigned_at=get_now(),
findoc=doc,
user_can_cancel=user_can_cancel,
service_for_billing="application_from_a_package"
)
sd.pickle_params({"redirect_after_sign": redirect_after_sign})
sd.save()
def post_shopify_no():
print "**START**", get_now()
channel_accounts = get_accounts('shopify')
for account in channel_accounts:
print "\n *Account: %s Start" % account.name
# 选出合适的package
packages = Package.objects.filter(order__channel_id=account.id)\
.filter(shipping_id__isnull=False)\
.filter(possback_status=0)\
.exclude(status__in=[0, 4])\
.exclude(tracking_no='')
for package in packages:
data = get_package_data(package)
shopify = Shopify(account.name, account.api_key, account.password)
try:
r = shopify.upload_tracking(**data).json()
except Exception, e:
print 'Failure', package.order.ordernum, get_now(
), account.name, e
error_info = r.get('errors', {}).get('order', '')
if r.get('fulfillment', {}).get('status', '') == 'success':
print 'Success', package.order.ordernum, get_now(
), account.name
elif 'is already fulfilled' in error_info:
print 'Already', package.order.ordernum, get_now(
), account.name
elif error_info:
print 'Failure', package.order.ordernum, get_now(
), account.name, error_info
else:
print 'Failure', package.order.ordernum, get_now(
), account.name, 'need IT'
time.sleep(5)
return context
bill_acc = zakaz.bill_account
try:
user = User.objects.get(username=bill_acc.username)
except Exception, exc:
context["errors"].append("No such user")
return context
app_list = FinDocSignApplication.objects.filter(assigned_to=user) # получаем все заявки
for app in app_list: # удаляем все существующие заявки для данного пользователя
app.delete()
slug = "akt_priemki_peredachi_vypoln_rabot"
doc = FinDoc.objects.get(slug=slug)
user_can_cancel = True
sd = FinDocSignApplication(
assigned_to=user,
assigned_at=get_now(),
findoc=doc,
user_can_cancel=user_can_cancel,
service_for_billing="application_from_a_package"
)
sd.pickle_params({"redirect_after_sign": url_after_sign})
sd.save()
try:
package_obj = Package_on_connection_of_service.objects.get(url_after_sign=url_after_sign, user=user)
except:
slugs = ['akt_priemki_peredachi_vypoln_rabot']
successfully_create = create_package(user,
'/account/internet/demands/activation/%s/' % zayavka_id,
reverse('my_inet'),
'',
def save_model(self, request, obj, form, change):
if not obj.pk:
obj.assigned_by = request.user
obj.assigned_at = get_now()
return super(FinDocSignApplicationAdmin, self).save_model(request, obj, form, change)
def get_order_data(self, package):
packageitem = package.set_to_logistics()
receiver = u'''
<name>{package.name}</name>
<postcode>{package.shipping_zipcode}</postcode>
<phone>{package.shipping_phone}</phone>
<mobile></mobile>
<country>{package.shipping_country.code}</country>
<province>{package.shipping_state}</province>
<city>{package.shipping_city}</city>
<county></county>
<street>{package.address}</street>
'''.format(package=package)
item_list = u'''
<item>
<count>{package.qty}</count>
<origin>CN</origin>
<cnname>{packageitem.cn_name}</cnname>
<unit>11</unit>
<weight>{package.weight}</weight>
<delcarevalue>{package.custom_amount}</delcarevalue>
<enname>{packageitem.name}</enname>
<description></description>
</item>
'''.format(package=package, packageitem=packageitem)
package_data = {
"account":
self,
"package":
package,
"receiver":
receiver,
"items":
item_list,
"startdate":
get_now(utc=True).isoformat()[:-6],
"enddate":
(get_now(utc=True) + datetime.timedelta(days=10)).isoformat()[:-6],
}
data = u'''<?xml version="1.0" encoding="UTF-8"?>
<orders xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<order>
<orderid>{package.id:1>4}</orderid>
<operationtype>0</operationtype>
<producttype>0</producttype>
<customercode>njky2015</customercode>
<vipcode></vipcode>
<clcttype>1</clcttype>
<pod>false</pod>
<untread>Abandoned</untread>
<volweight>0</volweight>
<startdate>{startdate}</startdate>
<enddate>{enddate}</enddate>
<printcode>01</printcode>
<sender>{account.sender}</sender>
<receiver>{receiver}</receiver>
<collect>{account.collect}</collect>
<items>{items}</items>
<remark></remark>
</order>
</orders>'''.format(**package_data)
# 去掉xml文件中的-'&, 并用utf8格式进行编码
data = data.replace("'", " ").replace("&", " ").encode('utf-8')
return data
def do_package():
# 创建package
print 'START create package', get_now()
create_package()
print 'END create package', get_now()
# 更新package的状态
print 'START update_package_status_to1', get_now()
update_package_status_to1()
print 'END update_package_status_to1', get_now()
# 创建itemlocked & itemwanted
print 'START itemlocked', get_now()
lock_packageitem()
print 'END itemlocked', get_now()
# 链接itemwanted & itemlocked
print 'START mapping_item_wanted', get_now()
mapping_item_wanted()
print 'END mapping_item_wanted', get_now()
# charge_package_can_pick
print 'START charge_package_can_pick', get_now()
charge_package_can_pick()
print 'END charge_package_can_pick', get_now()
# 更新order为发货完成
print 'START orders_delivery', get_now()
orders_delivery()
print 'END orders_delivery', get_now()
def get_choies_order():
print '*START work get order %s' % get_now()
sys.stdout.flush()
#从choies或者wholssale导入的订单, 有5小时的时差
add_5hour = datetime.timedelta(hours=5)
shops = [
'choies.com',
]
urls = {
'choies.com': 'http://www.choies.com/api/order_date_list',
# 'wholesale': 'http://www.choieswholesale.com/api/order_date_list',
# 'persunmall': 'http://www.persunmall.com/api/order_date_list',
# 'choies': 'http://local.clothes.com/api/order_date_list',
}
posturls = {
'choies.com': 'http://www.choies.com/api/from_ws_update_order_erp',
# 'wholesale': 'http://www.choieswholesale.com/api/from_ws_update_order_erp',
# 'persunmall': 'http://www.persunmall.com/api/from_ws_update_order_erp',
# 'choies': 'http://local.clothes.com/api/from_ws_update_order_erp',
}
for shop_name in shops:
today = datetime.date.today()
start_date = today - datetime.timedelta(days=30)
start_date = today - datetime.timedelta(days=3) # 测试用
while today >= start_date:
# 根据日期获取订单信息
start_date = start_date + datetime.timedelta(days=1)
url = urls[shop_name] + "?date=%s" % start_date.isoformat()
print url, shop_name
shop = Channel.objects.get(name=shop_name)
r = requests.get(url)
if r.status_code == 200:
pass
else:
print 'Url return %s' % str(r.status_code)
continue
try:
orders_data = r.json()
except Exception, e:
print str(e)
continue
# 处理订单
for order_data in orders_data:
if order_data['payment_status'] != 'verify_pass':
continue
order_dict = {}
#print order_data
try:
order = Order.objects.get(ordernum=order_data['ordernum'])
except:
# 必填字段
order_dict['ordernum'] = order_data['ordernum']
order_dict['channel'] = shop
order_items = []
for item_data in order_data['orderitems']:
model = item_data['sku']
sku_items = []
size = ''
color = ''
for attribute in item_data['attributes'].strip().split(
';'):
if not attribute:
continue
key = attribute.split(':')[0]
try:
value = attribute.split(':')[1]
except:
break
if key == 'Size':
size = value.replace(' ', "")
if size.startswith('EUR'):
size = size.split('/')[1]
elif key == 'Color':
color = value.replace(' ', "")
try:
other = attribute.split(':')[2]
color = ""
except:
pass
size = size.split('(')[0]
try:
color_other = color.split('[-]')[1]
color = ""
except:
pass
sku_items.append(model)
sku_items.append(size)
sku_items.append(color)
sku = '-'.join([i for i in sku_items if i])
sku = sku.upper()
if 'is_gift' in item_data and int(
item_data['is_gift']) == 0:
is_gift = False
else:
is_gift = True
order_item = {
'sku': sku,
'qty': item_data['quantity'],
'note': item_data['attributes'],
'price': item_data['price'],
# 如果是礼品, 当成正常的商品用, 只是price为0
}
order_items.append(order_item)
order_dict['order_items'] = order_items
# 订单信息
order_dict['email'] = order_data['email']
order_dict['note'] = order_data['remark']
order_dict['currency'] = order_data['currency']
order_dict['amount'] = float(order_data['amount'] or 0)
order_dict['amount_shipping'] = float(
order_data['amount_shipping']) # to add 运费
if 'order_insurance' in order_data and order_data[
'order_insurance']:
order_dict['amount_shipping'] += float(
order_data['order_insurance'])
if order_data['rate'] == 0:
rate = 1
else:
rate = order_data['rate']
order_dict['rate'] = rate # to delete order是否需要rate
if float(order_data['amount_shipping']) / rate < 10:
order_dict['shipping_type'] = 0
else:
order_dict['shipping_type'] = 1
if shop_name == "wholesale":
if 0 <= float(
order_data['amount_shipping']) / rate < 1:
order_dict['shipping_type'] = 0
else:
order_dict['shipping_type'] = 1
order_dict['create_time'] = eparse(
order_data['date_purchased'],
offset="+00:00") + add_5hour
# naive = parse_datetime(order_data['date_purchased']) + add_14hour
# order_dict['create_time'] = pytz.timezone("Asia/Shanghai").localize(naive, is_dst=None)
# 地址信息
order_dict['shipping_firstname'] = order_data[
'shipping_firstname']
order_dict['shipping_lastname'] = order_data[
'shipping_lastname']
order_dict['shipping_address'] = order_data[
'shipping_address']
order_dict['shipping_city'] = order_data['shipping_city']
order_dict['shipping_state'] = order_data['shipping_state']
order_dict['shipping_country_code'] = order_data[
'shipping_country']
order_dict['shipping_zipcode'] = order_data['shipping_zip']
order_dict['shipping_phone'] = order_data.get(
'shipping_phone', '')
# START 下面都是待定 是否需要一个other_msg的字段专门用来保存这些不是很重要且无规律, 但是可能需要看的信息
order_dict['comment1'] = order_data[
'cele_admin'] # to delete 红人单
if order_data['ip_address'] == '0.0.0.0':
order_dict['is_hand'] = True
else:
order_dict['is_hand'] = False
# todo payment_date是否需要, 和create是否二选一,
# 可以使用导单备注进行保存需要保存的信息
order_dict['payment_date'] = eparse(
order_data['payment_date'],
offset="+00:00") + add_5hour
order_dict['order_from'] = order_data[
'order_from'] # to delete 只有choies用, 记录after_sale和celebrate的
order_dict['payment'] = order_data[
'payment'] # to delete 付款方式, 不确定是否要保留
order_dict['amount_product'] = order_data[
'amount_products'] # to add 商品价格
order_dict['amount_coupon'] = order_data[
'amount_coupon'] # to add 优惠金额
order_dict['address_confirm'] = 1 # to delete 地址是否验证
# END 上面都是待定
print order_dict['ordernum'], order_dict[
'shipping_country_code'], order_dict['amount'], [
i['sku'] for i in order_dict['order_items']
]
# todo
# order_dict['add_user'] = User.objects.get(username='******')
# order_dict['order_manager'] = User.objects.get(username='******')
r = import_order(order_dict)
print r['msg']
for package in packages:
packageitem = package.set_to_logistics()
attice_number = Chukouyi.get_attice_number(package.shipping_country.code)
if not attice_number:
result['msg'] += u' | package: %s 找不到对应的格口号' % package.id
result['datas'].append({})
continue
data = {
'package_id': package.id,
'weight': 0.3,
'amount_shipping': package.custom_amount,
"sender": u'韦胜彬',
# todo 在html上使用过滤器
"sendetime": get_now(),
"recivename": package.name,
"reciveaddress": package.address,
"city": package.shipping_city,
"state": package.shipping_state,
"country_code": package.shipping_country.code,
"country_name": package.shipping_country.name,
"country_cnname": package.shipping_country.cn_name,
"zipcode": package.shipping_zipcode,
"recivephone": package.shipping_phone,
"tracking_code": package.tracking_no,
"attice_number": attice_number,
"chukouyi_flag": 'AAU',
"ship_label": ship_type,
"set_name": packageitem.name,
"itemSign": package.tracking_no
def import_ws_product(request):
data_notice = {}
if request.POST:
if request.POST.get("type") == 'import_product_cost':
msg = ''
reader = csv.reader(
StringIO.StringIO(request.FILES['csvFile'].read()))
header = next(reader)
for row in reader:
for j in range(0, 3):
# row[j] = row[j].decode('gbk').encode('utf-8')#不要相信业务提供的表格
row[j] = row[j].strip()
if j == 3:
try:
row[j] = float(row[j])
except Exception, e:
row[j] = 0
alias = Alias.objects.filter(sku=row[0]).first()
if alias:
msg += "SUCCESS,%s |" % row[0]
if row[3] > 0:
DepotInLog.objects.filter(depot_id=2,
item=alias.item,
type=4).update(cost=row[3])
try:
depotitem = DepotItem.objects.get(depot_id=2,
item=alias.item)
depotin_cost = DepotInLog.objects.filter(
depot_id=2, item=alias.item, type=4).first()
if depotin_cost:
depotitem.total = depotitem.qty * float(row[3])
depotitem.save()
except depotitem.DoesNotExist:
pass
else:
msg += "ERROR,%s,alias not exist |" % row[0]
if msg:
#下载表格
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename="import_product_cost_errors.csv"'
writer = csv.writer(response)
writer.writerow(['product_sku'])
datas = msg.split('|')
for pd in datas:
writer.writerow([pd])
return response
if request.POST.get("type") == 'import_product_material':
msg = ''
reader = csv.reader(
StringIO.StringIO(request.FILES['csvFile'].read()))
header = next(reader)
for row in reader:
for j in range(0, 1):
# row[j] = row[j].decode('gbk').encode('utf-8')#不要相信业务提供的表格
row[j] = row[j].strip()
p = Product.objects.filter(choies_sku=row[0]).update(
material=row[1])
if p:
msg += "SUCCESS,%s |" % row[0]
else:
msg += "ERROR,%s |" % row[0]
if msg:
#下载表格
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename="import_product_material_errors.csv"'
writer = csv.writer(response)
writer.writerow(['product_sku'])
datas = msg.split('|')
for pd in datas:
writer.writerow([pd])
return response
if request.POST.get("type") == "import_used_ky_tracking_no":
from lib.utils import get_now
from lib.models import Shipping
msg = ''
reader = csv.reader(
StringIO.StringIO(request.FILES['csvFile'].read()))
header = next(reader)
for ordernum, label, tracking_no in reader:
order = Order.objects.filter(ordernum=ordernum).first()
if not order:
msg += u'order:%s没找到 |' % ordernum
continue
package = Package.objects.filter(order_id=order.id).first()
if not package:
msg += u'order:%s没有创建packge |' % ordernum
continue
shipping = Shipping.objects.filter(label=label).first()
if not shipping:
msg += u'%s没有对应的shipping |' % label
continue
package.shipping = shipping
package.tracking_no = tracking_no
package.option_log += u'\n%s在%s 导入了旧的物流信息:%s %s' % (
request.user.username, get_now(), label, tracking_no)
package.save()
if not msg:
messages.success(request, u"导入成功")
else:
messages.error(request, msg)
order_dict['amount_coupon'] = order_data[
'amount_coupon'] # to add 优惠金额
order_dict['address_confirm'] = 1 # to delete 地址是否验证
# END 上面都是待定
print order_dict['ordernum'], order_dict[
'shipping_country_code'], order_dict['amount'], [
i['sku'] for i in order_dict['order_items']
]
# todo
# order_dict['add_user'] = User.objects.get(username='******')
# order_dict['order_manager'] = User.objects.get(username='******')
r = import_order(order_dict)
print r['msg']
#update choies order erp_header_id = 2
# posturl = posturls[shop_name]
# postdata = {
# 'order_id': order_data['id'],
# }
# try:
# pass # 测试的时候不能回传
# # r = requests.post(posturl, data=postdata)
# except Exception, e:
# print str(order_data['ordernum']) + ' update ' + str(shop_name) + ' order erp_header_id Failed!'
print '*END work get order %s' % get_now()
get_choies_order()
from_time = eparse(request.POST.get('from'), offset=" 00:00:00+08:00")
to_time = eparse(request.POST.get('to'), offset=" 00:00:00+08:00") or get_now()
except Exception, e:
messages.error(request, u'请输入正确的时间格式')
return redirect('order_handle')
shop = request.POST.get('shop')
channel_id = request.POST.get('channel')
response, writer = write_csv("order_cost")
orderitem_detail(writer, from_time, to_time, shop, channel_id)
return response
elif request.POST.get("type") == 'order_cost':
try:
from_time = eparse(request.POST.get('from'), offset=" 00:00:00+08:00")
to_time = eparse(request.POST.get('to'), offset=" 00:00:00+08:00") or get_now()
except Exception, e:
messages.error(request, u'请输入正确的时间格式%s' % str(e))
return redirect('order_handle')
shop = request.POST.get('shop')
channel_id = request.POST.get('channel')
response, writer = write_csv("order_cost")
order_cost(writer, from_time, to_time, shop, channel_id)
return response
elif request.POST.get('type') == 'manual_import_order':
msg = ''
reader = csv.reader(StringIO.StringIO(request.FILES['csvFile'].read()))
try:
writer.writerow([
'Package_id',
'Ordernum',
'Shipping',
'tracking_no',
'print_time',
'is_tonanjing',
'is_over',
'remark',
])
try:
from_time = eparse(request.POST.get('from'),
offset=" 00:00:00+08:00")
to_time = eparse(request.POST.get('to'),
offset=" 00:00:00+08:00") or get_now()
except Exception, e:
messages.error(request, u"请输入正确的时间格式")
return redirect('tongguan_index')
package3baos = Package3bao.objects.filter(package__print_time__gte=from_time)\
.filter(package__print_time__lte=to_time)\
.filter(is_tonanjing=1)
for p in package3baos:
row = [
p.package_id,
p.package.order.ordernum,
p.package.shipping.label,
add8(p.package.print_time),
p.is_tonanjing,
p.is_over,
def forecast(request):
if request.method == 'POST':
data = {}
data['msg'] = ''
order_status = [1,3,4,5,6]
if 'channel' in request.POST and request.POST['channel']:
channels = request.POST.getlist('channel')
now = get_now()
last_order = Order.objects.filter(deleted=False)\
.filter(channel_id__in=channels).filter(status__in=order_status)\
.filter(is_fba=True).order_by('-create_time')[:1].values('create_time')
for l_o in last_order:
now = l_o['create_time']
date7 = 7
sale_date7 = now - datetime.timedelta(days=date7)
# 根据传递的渠道进行分别的生成
for channel in channels:
#先删除该channel下旧的数据
channel = int(channel)
FbaForecast.objects.filter(deleted=False).filter(channel_id=channel).filter(is_purchase=False).delete()
# 选出某个商店最近7天的所有orderitem
orderitems = OrderItem.objects.filter(deleted=False)\
.filter(order__status__in=order_status)\
.filter(order__channel_id=channel)\
.filter(order__create_time__gte=sale_date7)\
.filter(order__is_fba=True)\
.values('qty', 'sku', 'item_id')
fore_dic = {}
# 这个循环计算出这个channel不同时间段的销售量: 7天
for orderitem in orderitems:
sku = orderitem['sku']
try:
if orderitem['item_id'] not in fore_dic:
fore_dic[orderitem['item_id']] = {'sales7': 0}
fore_dic[orderitem['item_id']]['sales7'] += orderitem['qty']
except:
data['msg'] += 'Item:%s Not Found | ' % sku
# 这个循环生成新的预测囤货信息
itemids = fore_dic.keys()
itemobjs = Item.objects.filter(id__in=itemids).values('id', 'sku', 'product_id')
for itemobj in itemobjs:
foredata = fore_dic[itemobj['id']]
# try:
# 可用库存,当前库存
try:
fba_stock = FbaSku.objects.get(item_id=itemobj['id'])
can_stock = fba_stock.fulfillable #可用库存
now_stock = fba_stock.total - fba_stock.unsellable #当前库存
except FbaSku.DoesNotExist:
can_stock = 0
now_stock = 0
# 区分“做货产品”和“采购产品”
supplier_product = SupplierProduct.objects.filter(product_id=itemobj['product_id']).order_by('order')[:1].values('id', 'supplier__type')
supplier_type = 0
for s_product in supplier_product:
supplier_type = s_product['supplier__type']
if supplier_type == 2:
forecast_type = '做货产品'
is_made = True
else:
forecast_type = '采购产品'
is_made = False
# 囤货产品类型
if can_stock == 0:
has_stock = False
forecast_type = '断货' + forecast_type
else:
has_stock = True
forecast_type = '有货' + forecast_type
# 7天销量
sales_7 = foredata['sales7']
# 安全库存
if is_made:
safe_stock = sales_7 * 6
else:
safe_stock = sales_7 * 4
# 采购中的数量
purchase_item_qty = 0
qty = PurchaseOrderItem.objects.filter(status__in=[0, 3]).filter(item_id=itemobj['id']).filter(purchaseorder__status__in=[0,1]).aggregate(Sum('qty'))
real_qty = PurchaseOrderItem.objects.filter(status=3).filter(item_id=itemobj['id']).filter(purchaseorder__status__in=[0,1]).aggregate(Sum('real_qty'))
if real_qty['real_qty__sum']:
partial_real_qty = real_qty['real_qty__sum']
else:
partial_real_qty = 0
if qty['qty__sum']:
purchase_item_qty = qty['qty__sum'] - partial_real_qty
else:
purchase_item_qty = 0 - partial_real_qty
#预测囤货数量(建议采购数量)
if not has_stock and not is_made: # 断货采购产品
fore_qty = sales_7 * 4 - purchase_item_qty
elif not has_stock and is_made: # 断货做货产品
fore_qty = sales_7 * 6 - purchase_item_qty
elif has_stock and not is_made: # 有货采购产品
fore_qty = sales_7 * 4 - purchase_item_qty
elif has_stock and not is_made: # 有货做货产品
fore_qty = sales_7 * 6 - purchase_item_qty
# 创建预测囤货数据
forecast = FbaForecast()
forecast.channel_id = channel
forecast.item_id = itemobj['id']
forecast.forecast_type = forecast_type
forecast.sales_7 = sales_7
forecast.can_stock = can_stock
forecast.now_stock = now_stock
forecast.safe_stock = safe_stock
forecast.purchase_item_qty = purchase_item_qty
forecast.fore_qty = fore_qty
forecast.assigner_id = request.user.id
forecast.save()
# except Exception, e:
# data['msg'] += str(e) + ' | '
# 新增产品
if 'skus' in request.POST and request.POST['skus']:
skus = request.POST['skus'].strip().split('\r\n')
do_skus = []
for sku in skus:
try:
fba_sku = FbaSku.objects.get(sku=sku)
data['msg'] += '%s在对照表中已存在' % sku
except FbaSku.DoesNotExist:
do_skus.append(sku)
if len(do_skus) > 0:
last_order = OrderItem.objects.filter(sku__in=do_skus).filter(order__channel_id__in=channels).filter(order__is_fba=False).order_by('-create_time')[:1].get()
now = last_order.order.create_time
date7 = 7
sale_date7 = now - datetime.timedelta(days=date7)
# 根据传递的渠道进行分别的生成
for channel in channels:
channel = int(channel)
# 选出某个商店最近7天的所有orderitem
orderitems = OrderItem.objects.filter(status=True)\
.exclude(order__status=6)\
.filter(sku__in=do_skus)\
.filter(order__channel_id=channel)\
.filter(order__created__gte=sale_date7)\
.filter(order__is_fba=False)\
.values('order__created', 'qty', 'sku')
fore_dic = {}
# 这个循环计算出这个channel不同时间段的销售量: 7天
sku_lists = tuple(orderitems.values_list('sku', flat=True))
sku_id_dict = dict(Item.objects.filter(sku__in=sku_lists).values_list('sku', 'id'))
for orderitem in orderitems:
sku = orderitem['sku']
try:
item_id = sku_id_dict[sku]
if item_id not in fore_dic:
fore_dic[item_id] = {'sales7': 0}
fore_dic[item_id]['sales7'] += orderitem['qty']
except:
data['msg'] += 'Item:%s Not Found | ' % sku
# 这个循环生成新的预测囤货信息
itemids = fore_dic.keys()
itemobjs = Item.objects.filter(id__in=itemids).values('id', 'sku', 'product_id')
for itemobj in itemobjs:
foredata = fore_dic[itemobj['id']]
try:
# 可用库存,当前库存
try:
fba_stock = FbaSku.objects.get(item_id=itemobj['id'])
can_stock = fba_stock.fulfillable #可用库存
now_stock = fba_stock.total - fba_stock.unsellable #当前库存
except FbaSku.DoesNotExist:
can_stock = 0
now_stock = 0
# 区分“做货产品”和“采购产品”
supplier_product = SupplierProduct.objects.filter(product_id=itemobj['product_id']).order_by('order').values['supplier__type'][:1].get()
if supplier_product['supplier__type'] == 2:
forecast_title = '新增做货产品'
is_made = True
else:
forecast_title = '新增采购产品'
is_made = False
# 7天销量
sales_7 = foredata['sales7']
# 安全库存
if is_made:
safe_stock = sales_7 * 7
else:
safe_stock = sales_7 * 5
# 采购中的数量
purchase_item_qty = Item.objects.get(id=itemobj['id']).get_purchasing_qty()
#预测囤货数量(建议采购数量)
if not is_made: # 断货采购产品
fore_qty = sales_7 * 5
else: # 断货做货产品
fore_qty = sales_7 * 7
# 创建预测囤货数据
forecast = FbaForecast()
forecast.channel_id = channel
forecast.item_id = itemobj['id']
forecast.forecast_type = forecast_type
forecast.sales_7 = sales_7
forecast.can_stock = can_stock
forecast.now_stock = now_stock
forecast.safe_stock = safe_stock
forecast.purchase_item_qty = purchase_item_qty
forecast.fore_qty = fore_qty
forecast.assigner_id = request.user.id
forecast.save()
except Exception, e:
data['msg'] += str(e) + ' | '
response = 'SUCCESS! <a href="/fba/forecast">进入预测囤货列表页面</a><br>'
if data['msg'] != '':
response = '报错信息:<br>%s' % (data['msg'])
return HttpResponse(response)
def get_amazon_order():
print '***START work get amazon order %s ***' % get_now()
channel_accounts = get_accounts('amazon')
for account in channel_accounts:
print "\n *Account: %s Start %s" % (account.name, get_now())
#去除这个用户所在大洲的开发人员账号信息
developer = Accounts.developers[account.continent.title()]
amazon = Orders(access_key=developer['access_key'],
secret_key=developer['secret_key'],
account_id=account.account_id,
auth_token=account.auth_token,
)
#尝试, 当无法获取的时候, 进行
for i in range(10):
if amazon.get_service_status().parsed.get('Status') == 'GREEN':
print "GREEN"
break
else:
print "Failure number: %s" % i+1
time.sleep(60)
else:
time.sleep(1)
print "Account:%s Failure" % account.name
continue
# # test start
# #商品数量为0, 两件产品, 单件有运费,对多件有优惠
# ordernums = ['113-6935756-6939409','115-5224300-1466659', '107-8893319-1637852', '111-5685070-5646636']
# order_info = amazon.get_order(ordernums).parsed
# next_token = order_info.get('NextToken', '')
# order_list = order_info.get('Orders').get('Order')
# print 33333
# break
# # test end
# 给next_token赋初值
next_token = 'First'
now_days = (datetime.datetime.now()- datetime.timedelta(days=1)).strftime('%Y-%m-%d')
while next_token:
#每个帐号第一次获取order, 后面使用next_token进行订单信息的获取
if next_token == 'First':
order_info = amazon.list_orders(marketplaceids=account.marketplaceids.split('#'),
lastupdatedafter=now_days,
max_results="50",
orderstatus=('Unshipped','PartiallyShipped'),
fulfillment_channels=('MFN',)
).parsed
else:
order_info = amazon.list_orders_by_next_token(token=next_token).parsed
next_token = order_info.get('NextToken', '')
try:
order_list = order_info.get('Orders').get('Order')
except Exception, e:
print e
break
#获取订单的时候, 如果最后一页只剩下一个订单, 那么那个订单的数据结构会是dict而不是list, 转化一下
if type(order_list) == dict:
order_list = [order_list]
for order_info in order_list:
ordernum = order_info.get('AmazonOrderId', '')
try:
order = Order.objects.get(ordernum=ordernum)
continue
except Exception, e:
pass
order_dict = get_amazon_order_dict(order_info, account, amazon)
r = import_order(order_dict)
#每导入一个订单, 打印出订单信息
print "Success" if r['success'] else 'Failure',\
ordernum, get_now(), account.name, r['msg'].strip()
connection.close()
time.sleep(60)
try:
order = Order.objects.get(ordernum=ordernum)
continue
except Exception, e:
pass
order_dict = get_amazon_order_dict(order_info, account, amazon)
r = import_order(order_dict)
#每导入一个订单, 打印出订单信息
print "Success" if r['success'] else 'Failure',\
ordernum, get_now(), account.name, r['msg'].strip()
connection.close()
time.sleep(60)
print "\n *Account: %s End %s" % (account.name, get_now())
#一个帐号结束
time.sleep(2)
print '***END work get order %s' % get_now()
def get_amazon_fba_order():
print '***START work get amazon fba order %s ***' % get_now()
channel_accounts = get_accounts('amazon')
for account in channel_accounts:
print "\n *Account: %s Start %s" % (account.name, get_now())
#去除这个用户所在大洲的开发人员账号信息
developer = Accounts.developers[account.continent.title()]
amazon = Orders(access_key=developer['access_key'],
order_dict['shipping_phone'] = phone_number + "|" + mobile_no
except Exception, e:
order_dict['shipping_phone'] = '|'
pass
# 没有电话信息
if order_dict['shipping_phone'] == '|':
import_note += u'| 该订单没有电话信息 \n'
# 订单的创建时间, 取付款成功时间
# 原格式是gmtCreate: 20160512102509000-0700, 需要去除时区前的三个0, 否则无法解析
try:
gmtPaySuccess = order_data.get('gmtPaySuccess')
useful = gmtPaySuccess[:14] + gmtPaySuccess[17:]
create_time = eparse(useful)
except Exception, e:
create_time = get_now()
import_note += u'| 该订单时间有误, 请联系IT \n'
order_dict['create_time'] = create_time
# 其他订单规则
# 如果订单的金额大于100美金, 则该订单为大额订单, 增加文字说明
if order_dict['amount'] > 100:
import_note += u'| 该订单金额超过100美金的大单 \n'
# 如果订单支付了运费, 增加文字说明
if order_dict['amount_shipping'] > 0:
import_note += u'| 该订单支付了运费 %s 美金 \n' % order_dict[
'amount_shipping']
except Exception, e:
import_note += u'| 单身信息出错, 请联系IT %s \n' % ee(e)
packages = Package.objects.filter(order__channel_id=account.id)\
.filter(shipping_id__isnull=False)\
.filter(possback_status=0)\
.exclude(status__in=[0, 4])\
.exclude(tracking_no='')
for package in packages:
data = get_package_data(package)
shopify = Shopify(account.name, account.api_key, account.password)
try:
r = shopify.upload_tracking(**data).json()
except Exception, e:
print 'Failure', package.order.ordernum, get_now(
), account.name, e
error_info = r.get('errors', {}).get('order', '')
if r.get('fulfillment', {}).get('status', '') == 'success':
print 'Success', package.order.ordernum, get_now(
), account.name
elif 'is already fulfilled' in error_info:
print 'Already', package.order.ordernum, get_now(
), account.name
elif error_info:
print 'Failure', package.order.ordernum, get_now(
), account.name, error_info
else:
print 'Failure', package.order.ordernum, get_now(
), account.name, 'need IT'
time.sleep(5)
print "**END**", get_now()
