def CreateFulfillmentReturn(execute_command):
params = ['Action=CreateFulfillmentReturn'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
params.append('SellerFulfillmentOrderId=' +
quote(execute_command['seller_order_id']))
params.append('Items.member.1.SellerReturnItemId=' +
quote(execute_command['item_id']))
params.append('Items.member.1.SellerFulfillmentOrderItemId=' +
quote(execute_command['order_item_id']))
params.append('Items.member.1.AmazonShipmentId=' +
quote(execute_command['ship_id']))
params.append('Items.member.1.ReturnReasonCode=' +
quote(execute_command['reason_code']))
params.append('Items.member.1.ReturnComment=' +
quote(execute_command['comment']))
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def GetServiceStatus(execute_command):
params = ['Action=GetServiceStatus'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command)
# 获取包含认证参数的字典
params = params + default_params
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
result = common_unit.xmltojson(r.text)
return result
def ListAllFulfillmentOrders(execute_command):
params = ['Action=ListAllFulfillmentOrders'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
if 'start_time' in execute_command:
st = execute_command['start_time'] + 'T00:00:00'
# st_timeArray = common_unit.time_to_timeArray(st)
params.append('QueryStartDateTime=' +
quote(st)) # 添加请求中包含的start_time
else:
params.append('QueryStartDateTime=')
params = params + default_params
print(params)
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def GetCompetitivePricingForASIN(execute_command):
params = ['Action=GetMatchingProduct']+api_version+['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,execute_command)
# 获取包含认证参数的字典
if 'asin' in execute_command:
asin_list = execute_command['asin'].split(',')
asin_param_list = []
#计算asin列表
try:
for i in asin_list:
asin_param_list.append('ASINList.ASIN.'+str(asin_list.index(i)+1)+'='+i)
except:
asin_param_list = ['ASINList.ASIN.1=']
# 如果不存在asin列表，则直接返回一个空列表扔掉
# 上面计算的asin列表是该接口的特征参数
# 添加请求中包含的asin
params = params + default_params + asin_param_list
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序
# 拼接请求身，需要按首字母排序
# 关于api的分类和版本
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n'+host_name+'\n'+port_point+'\n'+params
# 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string,user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params,signature)
# 拼接请求字符串
r = requests.post(url,headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def UpdateReportAcknowledgements(execute_command):
params = ['Action=UpdateReportAcknowledgements'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
params.append('Acknowledged=' +
quote(execute_command['acknowledged'])) # true or false
if 'request_id' in execute_command:
request_id_list = execute_command['request_id'].split(',')
request_list = []
for i in request_id_list:
request_list.append('ReportRequestIdList.Id.' +
str(request_id_list.index(i) + 1) + '=' + i)
params = params + default_params + request_list
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def DeregisterDestination(execute_command):
params = ['Action=DeregisterDestination'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
if 'destination' in execute_command:
destination_list = execute_command['destination'].split(',')
params.append('Destination.DeliveryChannel=' +
str(destination_list[0]))
params.append('Destination.AttributeList.member.1.Key=' +
str(destination_list[1]))
params.append('Destination.AttributeList.member.1.Value=' +
str(destination_list[2]))
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def upload_product(execute_command):
params = ['Action=SubmitFeed'
] + api_version + ['Timestamp=' + common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
# if execute_command['feed_method'] ==
params += ['FeedType=_POST_PRODUCT_DATA_']
# request_content = make_feed.feed_string
request_content = make_submit_feed.make_feed_string(execute_command)
request_content = bytes(request_content, 'utf-8')
# print(request_content)
# print(type(request_content))
# print(common_unit.get_md5(request_content))
params += [
'ContentMD5Value=' +
quote(common_unit.get_md5(request_content)).replace('/', '%2F')
]
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, request_content, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def ListMatchingProducts(execute_command):
params = ['Action=ListMatchingProducts'] + api_version
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command)
if 'keyword' in execute_command:
params.append('Query=' + quote(execute_command['keyword']))
else:
params.append('Query=')
# 如果不存在搜索关键词，则直接返回一个空的query
# 获取特征参数query即搜索关键词
params = params + default_params
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序
# 拼接请求身，需要按首字母排序
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def GetFeedSubmissionResult(execute_command):
params = ['Action=GetFeedSubmissionResult'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
# params += ['FeedTypeList.Type.1=_POST_PRODUCT_DATA_']
# params += ['FeedTypeList.Type.2=_POST_PRODUCT_PRICING_DATA_']
feed_submission_id = execute_command['submission_id']
params += ['FeedSubmissionId=' + feed_submission_id]
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def ListInventorySupply(execute_command):
params = ['Action=ListInventorySupply'] + api_version + ['Timestamp=' + common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict, execute_command) # 获取包含认证参数的字典
# skuList = []
# sku_list = common_unit.get_skuList(execute_command['store_id'])
# for i in sku_list:
# skuList.append('SellerSkus.member.' + str(sku_list.index(i) + 1) + '=' + i) # 计算skuList列表
params.append('SellerSkus.member.1=' + quote(execute_command['sku']))
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
params = params.replace('+',"%2B")
# print(params)
params = params.replace(' ',"%20")
# print(params)
#把你拉到和我同一水平，再用丰富的经验击败你
#空格不能自动quote，需要手动转换
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key'])))
signature = signature.replace('/', '%2F')
# print(signature)
# signature = signature.replace('=','%3D') # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def CancelShipment(execute_command):
params = ['Action=CancelShipment'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,
execute_command)
params = params + default_params
params += ['ShipmentId=' + execute_command['shipment_id']]
params = sorted(params)
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def CreateInboundShipmentPlan(execute_command):
params = ['Action=CreateInboundShipmentPlan'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,
execute_command)
#params += ['ShipFromAddress='+execute_command['from_address']]
params += ['ShipFromAddress.Name=' + execute_command['address_name']]
params += [
'ShipFromAddress.AddressLine1=' + execute_command['address_line']
]
params += ['ShipFromAddress.City=' + execute_command['address_city']]
params += [
'ShipFromAddress.CountryCode=' + execute_command['address_country']
]
#添加寄出地址
params += [
'ShipToCountryCode=' +
common_unit.country_code[execute_command['to_address_country']]
]
#此处应传入一个用逗号分隔的地区代码
# CA – Canada
# MX – Mexico
# US – United States
params += ['LabelPrepPreference=SELLER_LABEL']
params += [
'InboundShipmentPlanRequestItems.member.1.SellerSKU=' +
execute_command['seller_sku']
]
params += [
'InboundShipmentPlanRequestItems.member.1.Quantity=' +
execute_command['quantity']
]
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序
# 拼接请求身，需要按首字母排序
# 关于api的分类和版本
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def ListMarketplaceParticipations(execute_command):
params = ['Action=ListMarketplaceParticipations'] + api_version
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command)
params = params + default_params
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序
# 拼接请求身，需要按首字母排序
# 关于api的分类和版本
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def GetCompetitivePricingForSKU(execute_command):
params = ['Action=GetCompetitivePricingForSKU']+api_version+['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,execute_command)
# 获取包含认证参数的字典
if 'sku' in execute_command:
sku_list = execute_command['sku'].split(',')
sku_param_list = []
#计算asin列表
try:
for i in sku_list:
sku_param_list.append('SellerSKUList.SellerSKU.'+str(sku_list.index(i)+1)+'='+i)
except:
sku_param_list = ['SellerSKUList.SellerSKU.1=']
# 如果不存在asin列表，则直接返回一个空列表扔掉
# 上面计算的asin列表是该接口的特征参数
# 添加请求中包含的asin
params = params + default_params + sku_param_list
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序 # 拼接请求身，需要按首字母排序 # 关于api的分类和版本
params = '&'.join(params) # 对请求身进行分割
params = params.replace('%2B', "%20")
# print(params)
sig_string = 'POST\n'+host_name+'\n'+port_point+'\n'+params # 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string,user_access_dict['secret_key']))) # 计算字符串的加密签名
signature = signature.replace('/', '%2F')
url = connect_url(params,signature)
r = requests.post(url,headers=headers)
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def ListOrders(execute_command):
params = ['Action=ListOrders'] + api_version
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,
execute_command)
if 'fulfill' in execute_command:
fulfill_list = execute_command['fulfill'].split(',')
fulfill_param_list = []
try:
for i in asin_list:
fulfill_param_list.append('FulfillmentChannel.Channel.' +
str(fulfill_list.index(i) + 1) +
'=' + i)
except:
fulfill_param_list = [
'FulfillmentChannel.Channel.1=AFN',
'FulfillmentChannel.Channel.2=MFN'
]
params += fulfill_param_list
# 添加邮寄方式
if 'last_time' in execute_command:
params += ['CreatedBefore']
def GetMyPriceForASIN(execute_command):
params = ['Action=GetMyPriceForASIN'] + api_version + ['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict, execute_command) # 获取包含认证参数的字典
# if 'asin' in execute_command:
# asin_list = execute_command['asin'].split(',')
# asin_param_list = []
# try:
# for i in asin_list:
# asin_param_list.append('ASINList.ASIN.' + str(asin_list.index(i) + 1) + '=' + i) # 计算asin列表
# except:
# asin_param_list = ['ASINList.ASIN.1='] # 如果不存在asin列表，则直接返回一个空列表扔掉
#
if 'asin' in execute_command:
params.append('ASINList.ASIN.1=' + quote(execute_command['asin']))
else:
params.append('ASINList.ASIN.1=')
params = params + default_params # 上面计算的asin列表是该接口的特征参数 添加请求中包含的asin
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序 ,拼接请求身，需要按首字母排序,关于api的分类和版本
params = '&'.join(params) # 对请求身进行分割
params = params.replace('%2B', "%20")
params = params.replace(' ', "%20")
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
signature = signature.replace('/', '%2F')
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
return common_unit.xmltojson(r.text)
def ListOrderItems(execute_command):
params = ['Action=ListOrderItems']+api_version+['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,execute_command)
params += [str('AmazonOrderId='+execute_command['order_id'])]
# 添加订单编号
# params = params + default_params
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
attribute_content = common_unit.xmltojson(r.text)
print(attribute_content)
result = write_order_item_into_database(execute_command,attribute_content)
return result
def test_access_code(execute_command):
params = ['Action=ListMarketplaceParticipations'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command)
params = params + default_params
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序
# 拼接请求身，需要按首字母排序
# 关于api的分类和版本
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
result = common_unit.xmltojson(r.text)
result = json.loads(result)
if "ErrorResponse" not in result:
result = {'status_code': '0', 'message': '你真厉害，好哥哥！验证成功啦！'}
else:
result = {'status_code': '-1', 'message': '你眼瞎啊？抄access都抄错'}
return json.dumps(result)
def ListReturnReasonCodes(execute_command):
params = ['Action=ListReturnReasonCodes'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
if 'order_id' in execute_command:
order_id = quote(execute_command['order_id']) # 获取参数order_id
params.append('SellerFulfillmentOrderId=' + order_id)
else:
params.append('SellerFulfillmentOrderId=')
params.append('SellerSKU=' +
quote(execute_command['seller_sku'])) # 获取参数seller_sku
if 'language' in execute_command:
language = quote(execute_command['language']) # 获取参数language
params.append('Language=' + language)
else:
params.append('Language=')
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def GetPrepInstructionsForASIN(execute_command):
params = ['Action=GetPrepInstructionsForASIN'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,
execute_command)
if 'asin' in execute_command:
asin_list = execute_command['asin'].split(',')
asin_param_list = []
#计算asin列表
try:
for i in asin_list:
asin_param_list.append('ASINList.ASIN.' +
str(asin_list.index(i) + 1) + '=' + i)
except:
asin_param_list = ['ASINList.ASIN.1=']
# 如果不存在asin列表，则直接返回一个空列表扔掉
# 上面计算的asin列表是该接口的特征参数
# 添加请求中包含的asin
params = params + default_params + asin_param_list
# 链接sku
params += [
'ShipToCountryCode=' +
common_unit.country_code[execute_command['to_address_country']]
]
params = sorted(params)
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def GetPrepInstructionsForSKU(execute_command):
params = ['Action=GetPrepInstructionsForSKU'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,
execute_command)
if 'seller_sku' in execute_command:
seller_sku_list = execute_command['seller_sku'].split(',')
seller_sku_param_list = []
#计算sku列表
try:
for i in seller_sku_list:
seller_sku_param_list.append('SellerSKUList.Id.' +
str(seller_sku_list.index(i) +
1) + '=' + i)
except:
seller_sku_param_list = ['SellerSKUList.Id.1=']
params = params + default_params + seller_sku_param_list
# 链接sku
params += [
'ShipToCountryCode=' +
common_unit.country_code[execute_command['to_address_country']]
]
params = sorted(params)
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def GetServiceStatus(execute_command):
params = ['Action=GetServiceStatus'] + api_version + ['Timestamp=' + common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict, execute_command)
params = params + default_params
params = sorted(params)
params = '&'.join(params)
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key'])))
url = connect_url(params, signature)
r = requests.post(url, headers=headers)
result = common_unit.xmltojson(r.text)
error_result = common_unit.catch_exception(result) # 异常处理
if error_result != '':
result = error_result
return result
def CreateShipment(execute_command):
params = ['Action=CreateShipment'] + api_version + ['Timestamp=' + common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict, execute_command)
params = params + default_params
params += ['HazmatType=' + execute_command['hazmat_type']]
params += ['ShipmentId=' + execute_command['shipment_id']]
params += ['ShippingServiceId=' + execute_command['shipment_id']]
params += ['ShipmentRequestDetails.AmazonOrderId=' + execute_command['order_id']]
params += ['ShipmentRequestDetails.LabelCustomization.CustomTextForLabel=' + execute_command['custom_label']]
params += ['ShipmentRequestDetails.LabelCustomization.StandardIdForLabel=' + execute_command['stand_label']]
params += ['ShipmentRequestDetails.MustArriveByDate=' + execute_command['must_arrive_date']]
params += ['ShipmentRequestDetails.PackageDimensions.Length=' + execute_command['length']]
params += ['ShipmentRequestDetails.PackageDimensions.Width=' + execute_command['width']]
params += ['ShipmentRequestDetails.PackageDimensions.Height=' + execute_command['height']]
params += ['ShipmentRequestDetails.PackageDimensions.Unit=' + execute_command['unit']]
params += ['ShipmentRequestDetails.Weight.Value=' + execute_command['weight_value']]
params += ['ShipmentRequestDetails.Weight.Unit=' + execute_command['weight_unit']]
params += ['ShipmentRequestDetails.ShipDate=' + execute_command['ship_date']]
params += ['ShipmentRequestDetails.ShipFromAddress.Name=' + execute_command['address_name']]
params += ['ShipmentRequestDetails.ShipFromAddress.AddressLine1=' + execute_command['address_line']]
params += ['ShipmentRequestDetails.ShipFromAddress.City=' + execute_command['address_city']]
params += ['ShipmentRequestDetails.ShipFromAddress.StateOrProvinceCode=' + execute_command['state_or_province']]
params += ['ShipmentRequestDetails.ShipFromAddress.PostalCode=' + execute_command['post_code']]
params += ['ShipmentRequestDetails.ShipFromAddress.CountryCode=' + execute_command['country_code']]
params += ['ShipmentRequestDetails.ShipFromAddress.Email=' + execute_command['email']]
params += ['ShipmentRequestDetails.ShipFromAddress.Phone=' + execute_command['phone']]
params += ['ShipmentRequestDetails.ShippingServiceOptions.DeliveryExperience=' + execute_command['experience']]
params += ['ShipmentRequestDetails.ShippingServiceOptions.CarrierWillPickUp=' + execute_command['pick_up']]
params += ['ShipmentRequestDetails.ShippingServiceOptions.DeclaredValue.CurrencyCode=' + execute_command['currency_code']]
params += ['ShipmentRequestDetails.ShippingServiceOptions.DeclaredValue.Amount=' + execute_command['amount']]
params += ['ShipmentRequestDetails.ShippingServiceOptions.LabelFormat=' + execute_command['label_format']]
params += ['ShipmentRequestDetails.ItemList.Item.1.OrderItemId=' + execute_command['order_item_id']]
params += ['ShipmentRequestDetails.ItemList.Item.1.Quantity=' + execute_command['quantity']]
params = sorted(params)
params = '&'.join(params)
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key'])))
url = connect_url(params, signature)
r = requests.post(url, headers=headers)
result = common_unit.xmltojson(r.text)
error_result = common_unit.catch_exception(result) # 异常处理
if error_result != '':
result = error_result
return result
def GetReportRequestList(execute_command):
params = ['Action=GetReportRequestList'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,
execute_command) # 获取包含认证参数的字典
params.append('ReportProcessingStatusList.Status.1=' +
quote(execute_command['process_status']))
params.append('ReportRequestIdList.Id.1=' +
quote(execute_command['request_id']))
if 'start_time' in execute_command:
st = quote(execute_command['start_time'])
st_timeArray = common_unit.time_to_timeArray(st)
params.append('RequestedFromDate=' + st_timeArray) #开始时间
else:
params.append('RequestedFromDate=')
if 'end_time' in execute_command:
et = quote(execute_command['end_time'])
et_timeArray = common_unit.time_to_timeArray(et)
params.append('RequestedToDate=' + et_timeArray) #结束时间
else:
params.append('RequestedToDate=')
if 'report_type' in execute_command:
report_list = execute_command['report_type'].split(',')
report_type_list = []
for i in report_list:
report_type_list.append('ReportTypeList.Type.' +
str(report_list.index(i) + 1) + '=' + i)
params = params + default_params + report_type_list
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def interface_amazon_ListOrders(execute_command):
cursor,conn = common_unit.database_connection()
if execute_command['create_time'] == '':
execute_command['create_time'] == '1970-01-01'
if execute_command['store_id'] != '':
# result = list_order_by_store_id(execute_command)
# return json.dumps(result)
params = ['Action=ListOrders']+api_version+['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,execute_command)
params[-1] = 'MarketplaceId.Id.1='+params[-1].split('=')[1]
if execute_command['create_time'] != '':
params += ['CreatedAfter='+quote(execute_command['create_time']+'T00:00:00')]
else:
params += ['CreatedAfter='+quote('1970-01-01T00:00:00')]
params = params + default_params
# print(params)
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params)
# 对请求身进行分割
# print(params)
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
# print(url)
r = requests.post(url, headers=headers) # 发起请求
content = common_unit.xmltojson(r.text)
# print(content)
status,order_no_list = list_orders(execute_command,content)
if status == 0:
result = {'status_code':0,'message':'同步成功了所有订单，好哥哥你真棒！'}
elif status == -1:
result = {'status_code':-1,'message':'没有订单啊，你会不会查询啊？'}
else:
result = {'status_code':1,'message':'好像有'+str(status)+'条订单数据库里已经有了，要不要试试直接查查数据库？'}
def GetProductCategoriesForASIN(execute_command):
params = ['Action=GetProductCategoriesForASIN'] + api_version+ ['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict, execute_command) # 获取包含认证参数的字典
if 'asin' in execute_command:
params.append('ASIN=' + quote(execute_command['asin']))
else:
params.append('ASIN=') # 添加请求中包含的ASIN
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
signature = signature.replace('/', '%2F')
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
return common_unit.xmltojson(r.text)
def RequestReport(execute_command):
params = ['Action=RequestReport'
] + ['Timestamp=' + common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
access_params = common_unit.make_access_param(user_access_dict,
execute_command)
market_place_id = access_params[-1].split('=')[1]
access_params += ['MarketplaceIdList.Id.1=' + market_place_id]
params = params + access_params # 获取包含认证参数的字典
params.append('ReportType=' + quote(execute_command['report_type']))
if 'start_time' in execute_command:
st = quote(execute_command['start_time'])
st_timeArray = common_unit.time_to_timeArray(st)
params.append('StartDate=' + st_timeArray)
else:
pass # 添加请求中包含的start_time
if 'end_time' in execute_command:
st = quote(execute_command['end_time'])
st_timeArray = common_unit.time_to_timeArray(st)
params.append('EndDate=' + st_timeArray)
else:
pass # 添加请求中包含的end_time
params = params + default_params
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(
sig_string, user_access_dict['secret_key']))) # 计算字符串的加密签名
signature = signature.replace('/', '%2F')
url = connect_url(params, signature) # 拼接请求字符串
print(url)
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
return result
def ListInboundShipmentItems(execute_command):
params = ['Action=ListInboundShipmentItems'] + api_version + [
'Timestamp=' + common_unit.get_time_stamp()
]
user_access_dict = common_unit.get_amazon_keys(
execute_command['store_id'])
params += default_params
# 获取认证参数
# 把认证参数添加进请求头
params += common_unit.make_access_param(user_access_dict,
execute_command)
params = params + default_params
if 'shipment_id' in execute_command:
params += ['ShipmentId=' + execute_command['shipment_id']]
if 'last_updated_before' in execute_command and 'last_created_after' in execute_command:
params += [
'LastUpdatedAfter=' + execute_command['last_updated_after']
]
params += [
'LastUpdatedBefore=' + execute_command['last_updated_before']
]
# 添加时间区间或者运单id，二者只能存在一样
params = sorted(params)
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params
# 连接签名字符串
signature = quote(
str(
common_unit.cal_signature(sig_string,
user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params, signature)
# 拼接请求字符串
r = requests.post(url, headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
return common_unit.xmltojson(r.text)
def GetMatchingProduct(execute_command):
params = ['Action=GetMatchingProduct']+api_version+['Timestamp='+common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict,execute_command)
# 获取包含认证参数的字典
if 'asin' in execute_command:
asin_code = execute_command['asin']
#计算asin列表
asin_param_list = ['ASINList.ASIN.1='+asin_code]
params = params + default_params + asin_param_list
elif 'sku' in execute_command:
sku_code = execute_command['sku']
#计算asin列表
sku_param_list = ['SKUList.SKU.1='+sku_code]
params = params + default_params + sku_param_list
# 如果不存在asin列表，则直接返回一个空列表扔掉
# 上面计算的asin列表是该接口的特征参数
# 添加请求中包含的asin
params = sorted(params)
# 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序
# 拼接请求身，需要按首字母排序
# 关于api的分类和版本
params = '&'.join(params)
# print(params)
# 对请求身进行分割
sig_string = 'POST\n'+host_name+'\n'+port_point+'\n'+params
# 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string,user_access_dict['secret_key'])))
# 计算字符串的加密签名
url = connect_url(params,signature)
# 拼接请求字符串
r = requests.post(url,headers=headers)
# 发起请求
# print(common_unit.xmltojson(r.text))
result = common_unit.xmltojson(r.text)
print(result)
result = save_result_into_db(result,execute_command)
return str(result)
def syn_inventory(execute_command):
params = ['Action=ListInventorySupply'] + api_version + ['Timestamp=' + common_unit.get_time_stamp()]
user_access_dict = common_unit.get_amazon_keys(execute_command['store_id'])
params += common_unit.make_access_param(user_access_dict, execute_command) # 获取包含认证参数的字典
start_time = '1970-12-31T16:00:00' # 设置一个久远的时间开始同步库存(第一次同步店铺商品列表的库存)
start_time = start_time.replace(':', '%3A')
params.append('QueryStartDateTime=' + start_time)
params = params + default_params #
params = sorted(params) # 拼接公有请求参数，认证请求参数，和特征请求参数，并进行排序,拼接请求身，需要按首字母排序
params = '&'.join(params) # 对请求身进行分割
sig_string = 'POST\n' + host_name + '\n' + port_point + '\n' + params # 连接签名字符串
signature = quote(str(common_unit.cal_signature(sig_string, user_access_dict['secret_key'])))
signature = signature.replace('/', '%2F')
# signature = signature.replace('=','%3D') # 计算字符串的加密签名
url = connect_url(params, signature) # 拼接请求字符串
r = requests.post(url, headers=headers) # 发起请求
result = common_unit.xmltojson(r.text)
# result = r
return result
