class BasicAuth:
def __init__(self):
admin_consumer_key = "ck_4c5db02305903c89717481b801f510a50c769cf0"
admin_consumer_secret = "cs_be0444f22ccc2358bb98193aa39279ce33b78aa8"
self.wcapi = API(url="http://127.0.0.1/sreenu_store",
consumer_key=admin_consumer_key,
consumer_secret=admin_consumer_secret,
version="v3")
def test_api(self):
print(self.wcapi.get("").json())
def post_method(self, endpoint, data):
result = self.wcapi.post(endpoint, data)
rs_response = result.status_code
rs_body = result.json()
rs_url = result.url
return rs_response, rs_body, rs_url
def get_method(self, endpoint):
result = self.wcapi.get(endpoint)
rs_response = result.status_code
rs_body = result.json()
rs_url = result.url
return rs_response, rs_body, rs_url
class REQ():
def __init__(self):
consumer_admin_key = "ck_7e00fe275804399bba0baf6af01832ac7e1adb5f"
consumer_admin_secret = "cs_634013c0b6d035d47629da55faf2adf37cde4329"
self.wcapi = API(url="http://127.0.0.1/akstore",
consumer_key=consumer_admin_key,
consumer_secret=consumer_admin_secret,
version="v3")
def test_api(self):
print(self.wcapi.get("").json())
def post(self, endpoint, data):
result = self.wcapi.post(endpoint, data)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return (rs_code, rs_body, rs_url)
def get(self, endpoint):
result = self.wcapi.get(endpoint)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return (rs_code, rs_body, rs_url)
def wc_cust_delete(self, id):
result = self.wcapi.delete("customers/" + str(id) + "?force=true")
return (result).json()
def wc_product_delete(self, id):
result = self.wcapi.delete("products/" + str(id) + "?force=true")
return (result).json()
def Woocommerce(URL, INVOICE_ID, CONSUMER_KEY, CONSUMER_SECRET, VERSION):
wcapi = API(url=URL,
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
version=VERSION)
for attribute in wcapi.get("orders").json():
if attribute['status'] == 'processing':
for i in wcapi.get("payment_gateways").json():
if i['id'] == 'paypal':
PAYPAL = i['settings']['invoice_prefix']['value']
INVOICE = f"{INVOICE_ID}-{attribute['number']}"
ShippingInfo = attribute['shipping']
NAME = f"{ShippingInfo['first_name']} {ShippingInfo['last_name']}"
if ShippingInfo['address_2'] != None:
ADDRESS = f"{ShippingInfo['address_1']} {ShippingInfo['address_2']}"
else:
ADDRESS = f"{ShippingInfo['address_1']}"
CITY = ShippingInfo['city']
STATE = ShippingInfo['state']
ZIPCODE = ShippingInfo['postcode']
TRANSACTION = attribute['transaction_id']
PHONE = attribute['billing']['phone']
for variant in attribute['line_items']:
SKU = variant['sku']
QUANTITY = variant['quantity']
ORDERS.append([
PAYPAL, TRANSACTION, INVOICE, NAME, PHONE, ADDRESS, CITY,
STATE, ZIPCODE, SKU, QUANTITY, 'Build Stock Later'
])
return ORDERS
def get(self, request, format=None):
try:
# Create a WooCommerce API instance
wcapi = API(url=settings.WOOCOMMERCE_URL,
consumer_key=settings.CONSUMER_KEY,
consumer_secret=settings.CONSUMER_SECRET,
wc_api=True,
version="wc/v2")
# Get list of attributes in WooCommerce
attributes_in_ecommerce = wcapi.get(
"products/attributes?per_page=100").json()
attributes = AttributeSerializer(data=attributes_in_ecommerce,
many=True)
if attributes.is_valid():
attributes.save()
for attribute in attributes.validated_data:
terms_in_ecommerce = wcapi.get(
f"products/attributes/{attribute['uuid']}/terms?per_page=100"
).json()
terms = AttributeTermSerializer(
data=terms_in_ecommerce,
many=True,
context={'attribute_id': attribute['uuid']})
if terms.is_valid():
terms.save()
else:
print(terms.errors)
return Response(status=status.HTTP_200_OK)
except Exception as e:
print(e)
return Response(status=status.HTTP_400_BAD_REQUEST)
class REQ():
def __init__(self):
admin_consumer_key = "ck_82f82456dfe3b95b2b9dc83c56411bb5277807bd"
admin_consumer_secret = "cs_5af4b6bdfef28ce5337d6a189ef342eb8545079e"
self.wcapi = API(url="http://127.0.0.1/hbstore/",
consumer_key=admin_consumer_key,
consumer_secret=admin_consumer_secret,
wp_api=True,
version="wc/v1")
def testAPI(self):
print(self.wcapi.get("").json())
def post(self, endpoint, data):
result = self.wcapi.post(endpoint, data)
res_code = result.status_code
res_body = result.json()
res_url = result.url
return [res_code, res_body, res_url]
def get(self, endpoint):
result = self.wcapi.get(endpoint)
res_code = result.response_code
res_body = result.json()
res_url = result.url
return [res_code, res_body, res_url]
#
# obj = REQ()
# obj.testAPI()
def searchbySKU(sku):
# Obtengo las claves
api_keys = wc_gsbase_api.getApiKeys("secret_keys.json")
# Crea conexion API con WooCommerce
if bool(api_keys):
wcapi = API(
url="https://camanwi.com", # Your store URL
consumer_key=api_keys['WOOCOMMERCE_KEY'], # Your consumer key
consumer_secret=api_keys[
'WOOCOMMERCE_SECRET'], # Your consumer secret
wp_api=True, # Enable the WP REST API integration
version="wc/v3", # WooCommerce WP REST API version,
timeout=15)
else:
print("No Keys Available")
exit()
# Consigue lista de todos los productos (puede que sean solo los 10 ultimos por la pagination)
my_json = (wcapi.get("products?per_page=50").json())
# Busca el producto con el sku requerido
my_products = {}
encontrado = False
for attribute in my_json:
if attribute['sku'] == sku:
print('Producto Padre ID: ', attribute['id'], 'SKU: ', sku)
# Busco las variaciones del producto.
my_variations_id = (attribute['variations'])
print('Productos hijos ID: ', attribute['variations'])
encontrado = True
my_variations_sku = []
try:
# Extraigo los detalles de cada variacion a traves de su ID.
for id in my_variations_id:
my_product = (wcapi.get("products/" + str(id)).json())
my_products.update({id: my_product})
my_variations_sku.append(my_product["sku"])
resultado = ('Productos hijos SKU: ', my_variations_sku)
# Si encuentra el producto lo guarda en un json.
except UnboundLocalError as e:
print(e)
pass
if encontrado:
with open('Retrieved Products Temp.json', 'w') as json_file:
json.dump(my_products, json_file)
return resultado
# Si no lo encuentra
else:
resultado = ("No se han encontrado productos hijos para el producto " +
sku)
return resultado
def get_woocommerce_orders(date_created, date_updated, orders_dict):
"""Date updated still unused, need to include when updated_at is available in WC API"""
key = global_configuration.Woocommerce.consumer_key
secret = global_configuration.Woocommerce.consumer_secret
url = global_configuration.Woocommerce.url
wcapi = API(url=url, consumer_key=key, consumer_secret=secret, timeout=10)
dict_new_orders = {}
dict_update_orders = {}
date_created_string = date_created.strftime('%Y-%m-%dT%H:%M:%S')
pages = 1
for x in range(1, pages + 1):
r_new = wcapi.get("orders?per_page=100&page={0}&after={1}".format(
x, date_created_string)).json()
r_update = wcapi.get("orders?per_page=100&page={0}&before={1}".format(
x, date_created_string)).json()
for new_order in r_new:
new_order_date_created = dt.strptime(new_order['date_created_gmt'],
"%Y-%m-%dT%H:%M:%S")
new_order_date_modified = dt.strptime(
new_order['date_modified_gmt'], "%Y-%m-%dT%H:%M:%S")
new_order_id = str(new_order['id'])
new_date_created = dt.strptime(new_order['date_created_gmt'],
"%Y-%m-%dT%H:%M:%S")
date_created = new_date_created if new_order_date_created >= date_created else date_created
dict_new_orders[new_order_id] = {
"order_id": new_order_id,
"date_created": new_order['date_created_gmt'],
"date_modified": new_order['date_modified_gmt']
}
if len(orders_dict) > 0:
for update_order in r_update:
update_order_id = str(update_order['id'])
if update_order_id in orders_dict:
update_order_date_created = dt.strptime(
update_order['date_created_gmt'], "%Y-%m-%dT%H:%M:%S")
update_order_date_modified = dt.strptime(
update_order['date_modified_gmt'], "%Y-%m-%dT%H:%M:%S")
if orders_dict[update_order_id]['date_modified'] != None:
orders_dict_date_modified = orders_dict[
update_order_id]['date_modified']
else:
# Assign -1 day so next first condition always True
orders_dict_date_modified = update_order_date_modified - timedelta(
days=1)
if update_order_date_modified > orders_dict_date_modified and update_order not in r_new:
# Check if > condition is enough (it was => before)
dict_update_orders[update_order_id] = {
"order_id": update_order_id,
"date_created": update_order['date_created_gmt'],
"date_modified": update_order['date_modified_gmt']
}
orders = dict_new_orders.copy()
orders.update(dict_update_orders)
return orders, date_created
class Store:
def __init__(self, url, key, secret):
self.wcapi = API(url=url,
consumer_key=key,
consumer_secret=secret,
wp_api=True,
version="wc/v3")
def get_order(self, order_id):
return self.wcapi.get('orders/' + order_id).json()
def get_order_notes(self, order_id):
return self.wcapi.get('orders/' + order_id + '/notes').json()
def _call(self, method, arguments):
try:
_logger.debug("Start calling Woocommerce api %s", method)
api = API(url=self.woo.location,
consumer_key=self.woo.consumer_key,
consumer_secret=self.woo.consumer_secret,
version='v2')
if api:
if isinstance(arguments, list):
while arguments and arguments[-1] is None:
arguments.pop()
start = datetime.now()
try:
if 'false' or 'true' or 'null' in api.get(method).content:
result = api.get(method).content.replace(
'false', 'False')
result = result.replace('true', 'True')
result = result.replace('null', 'False')
result = eval(result)
else:
result = eval(api.get(method).content)
except:
_logger.error("api.call(%s, %s) failed", method, arguments)
raise
else:
_logger.debug("api.call(%s, %s) returned %s in %s seconds",
method, arguments, result,
(datetime.now() - start).seconds)
return result
except (socket.gaierror, socket.error, socket.timeout) as err:
raise NetworkRetryableError(
'A network error caused the failure of the job: '
'%s' % err)
except xmlrpclib.ProtocolError as err:
if err.errcode in [
502, # Bad gateway
503, # Service unavailable
504
]: # Gateway timeout
raise RetryableJobError(
'A protocol error caused the failure of the job:\n'
'URL: %s\n'
'HTTP/HTTPS headers: %s\n'
'Error code: %d\n'
'Error message: %s\n' %
(err.url, err.headers, err.errcode, err.errmsg))
else:
raise
def get_woocommerce_connection(self):
_logger.info(
"==================== Now In Woocomerce Connection to check connection ==================="
)
woocommerce = API(
url=self.url,
consumer_key=self.consumer_key,
consumer_secret=self.secret_key,
wp_api=True,
version="wc/v2",
timeout=30,
query_string_auth=True,
# verify_ssl = False,
)
try:
woocommerce_api = woocommerce.get('system_status')
except Exception as e:
raise UserError(_("Error:" + str(e)))
if 'message' in woocommerce_api.json():
message = "Connection Error" + str(
woocommerce_api.status_code) + " : " + str(
woocommerce_api.text)
raise UserError(_(message))
else:
return woocommerce
def test_woocommerce_connection(self):
message = ""
woocommerce = API(
url=self.url,
consumer_key=self.consumer_key,
consumer_secret=self.secret_key,
wp_api=True,
version="wc/v2",
timeout=30,
query_string_auth=True,
# verify_ssl = False,
)
try:
woocommerce_api = woocommerce.get('system_status')
except Exception as e:
raise UserError(_("Error:" + str(e)))
if 'message' in woocommerce_api.json():
message = "Connection Error" + str(
woocommerce_api.status_code) + " : " + str(
woocommerce_api.text)
raise UserError(_(message))
else:
self.state = 'validate'
message = "Connection Successful!!"
return self.display_message(message)
def woocommerce_export_api_config(self):
if self.api_version == 'legacyv3':
woocommerce = API(
url=self.url,
consumer_key=self.consumer_key,
consumer_secret=self.secret_key,
wp_api=False,
version="v3",
timeout=150,
# verify_ssl = False,
)
else:
woocommerce = API(
url=self.url,
consumer_key=self.consumer_key,
consumer_secret=self.secret_key,
wp_api=True,
version="wc/v3",
timeout=50,
query_string_auth=True,
)
try:
# woocommerce_api=woocommerce.get('products?per_page=1')
woocommerce_api = woocommerce.get('system_status')
except Exception as e:
raise osv.except_osv(_('Error'), _("Error:" + str(e)))
# _logger.error('########### Valor de woocomerce export api: %s', woocommerce_api.json())
if woocommerce_api.json().has_key('message'):
message = "Connection Error" + str(
woocommerce_api.status_code) + " : " + str(
woocommerce_api.text)
raise osv.except_osv(_('Error'), _(message))
else:
return woocommerce
def get_request_request(path, settings=None, params=None):
if not settings:
settings = get_woocommerce_settings()
wcapi = API(
url=settings["woocommerce_url"],
consumer_key=settings["api_key"],
consumer_secret=settings["api_secret"],
verify_ssl=settings["verify_ssl"],
wp_api=True,
version="wc/v3",
timeout=1000,
)
r = wcapi.get(path, params=params)
# r.raise_for_status()
# manually raise for status to get more info from error (message details)
if r.status_code != requests.codes.ok:
make_woocommerce_log(
title="WooCommerce get error {0}".format(r.status_code),
status="Error",
method="get_request",
message="{0}: {1}".format(r.url, r.json()),
request_data="not defined",
exception=True,
)
return r
def test_connection(self):
location = self.location
cons_key = self.consumer_key
sec_key = self.consumer_secret
version = self.version or 'v3'
msg = str()
try:
wcapi = API(
url=location, # Your store URL
consumer_key=cons_key, # Your consumer key
consumer_secret=sec_key, # Your consumer secret
version=version, # WooCommerce WP REST API version
query_string_auth=True # Force Basic Authentication as query
# string true and using under HTTPS
)
r = wcapi.get("products")
if r.status_code == 404:
msg = "(Enter Valid url)"
val = r.json()
except:
raise Warning(_("Sorry, Could not reach WooCommerce site! %s")\
% (msg))
msg = ''
if 'errors' in r.json():
msg = val['errors'][0]['message'] + '\n' + \
val['errors'][0]['code']
raise Warning(_(msg))
else:
raise Warning(_('Test Success'))
return True
def get_customer_data():
wcapi = API(url=os.getenv("URL"),
consumer_key=os.getenv("CONSUMER_KEY"),
consumer_secret=os.getenv("CONSUMER_SECRET"),
version="wc/v3")
r = wcapi.get("orders")
print(r.json())
json_array = r.json()
store_list = []
for item in json_array:
if item['status'] == 'completed':
email = item['billing']['email']
surname = item['billing']['first_name']
lastname = item['billing']['last_name']
phone = item['billing']['phone']
address = item['billing']['address_1'] + " " + item['billing'][
'address_2']
city = item['billing']['city']
postcode = item['billing']['postcode']
state = item['billing']['state']
customer = Customer(email, surname, lastname, phone, address, city, state,
postcode)
print(customer.surname, customer.lastname, customer.phone,
customer.address, customer.state, customer.city, customer.postcode)
return customer
def connect_woocommerce(self):
message = ""
woocommerce = API(
url=self.woocommerce_url,
consumer_key=self.woocommerce_consumer_key,
consumer_secret=self.woocommerce_secret_key,
wp_api=True,
version="wc/v2",
timeout=40,
query_string_auth=True,
# verify_ssl = False,
)
try:
woocommerce_api = woocommerce.get('system_status').json()
except Exception as e:
raise UserError(_("Error:"+str(e)))
if 'message' in woocommerce_api:
message = "Connection Error" + \
str(woocommerce_api['data']['status']) + \
" : "+str(woocommerce_api["message"])
raise UserError(_(message))
else:
self.state = 'validate'
message = "Connection Successful!!"
return True, message
def get_woocommerce_connection(self):
if self.api_version == 'legacyv3':
woocommerce = API(
url=self.url,
consumer_key=self.consumer_key,
consumer_secret=self.secret_key,
wp_api=False,
version="v3",
timeout=50,
)
else:
woocommerce = API(
url=self.url,
consumer_key=self.consumer_key,
consumer_secret=self.secret_key,
wp_api=True,
version="wc/v3",
timeout=50,
query_string_auth=True,
)
date = datetime.now().date()
date = date + timedelta(days=5)
date = str(date)
try:
# woocommerce_api=woocommerce.get('products?filter[created_at_min]='+date)
woocommerce_api = woocommerce.get('system_status')
except Exception as e:
raise osv.except_osv(_('Error'), _("Error:" + str(e)))
if woocommerce_api.json().has_key('message'):
message = str(woocommerce_api.text) + ", Status Code:" + str(
woocommerce_api.status_code)
else:
return woocommerce
raise osv.except_osv(_('Error'), _(message))
class REQ:
def __init__(self):
adm_consumer_key = 'ck_f5fcf679cc65d438ba8188e867610e18a6486ee5'
adm_consumer_secret = 'cs_4c312c0392d86938a4469c432ba15aa78977bb3f'
self.wcapi = API(url="http://127.0.0.1/ak_store/",
consumer_key=adm_consumer_key,
consumer_secret=adm_consumer_secret,
wp_api=True,
version="wc/v2")
# def test_api(self):
# print self.wcapi.get("").json()
def post(self, endpoint, data):
result = self.wcapi.post(endpoint, data)
resp_code = result.status_code
resp_body = result.json()
resp_url = result.url
return [resp_code, resp_body, resp_url]
def get(self, endpoint):
result = self.wcapi.get(endpoint)
resp_code = result.response_code
resp_body = result.json()
resp_url = result.url
return [resp_code, resp_body, resp_url]
# test1 = REQ()
# test1.test_api()
class WooCommerce(object):
def __init__(self, url, consumer_key, consumer_secret):
self.wcapi = API(url=url,
consumer_key=consumer_key,
consumer_secret=consumer_secret)
def get_api(self):
return self.wcapi
def open_products(self):
result = self.wcapi.get('products?filter[limit]=1000')
if result.status_code == 200:
return result.json()['products']
def get_products(self, q, limit=1000):
result = self.wcapi.get(
'products?filter[q]={q}&filter[limit]={limit}'.format(q=q,
limit=1000))
if result.status_code == 200:
return result.json()['products']
def post_product(self, data):
if len(self.get_products(q=data['product']['title'])) == 0:
result = self.wcapi.post('products', data=data)
if result.statu_code == 200:
return result.json()
else:
return "The Products is already exists"
def get_tags(self):
result = self.wcapi.get('products/tags')
if result.status_code == 200:
return result.json()['product_tags']
def get_categories(self):
result = self.wcapi.get('products/categories')
if result.status_code == 200:
return result.json()['product_categories']
def save(self, filename, type='csv'):
if type == 'csv':
products = self.get_products()
keys = products[0].keys()
with open(filename, 'wb') as output_file:
dict_writer = csv.DictWriter(output_file, keys)
dict_writer.writeheader()
dict_writer.writerows(products)
class REQ():
def __init__(self):
admin_consumer_key = 'ck_d46283593b62ed3b10e12f646fdc2afccb672575'
admin_consumer_secret = 'cs_cafbc6686cc0f0a6d1a4a34c2d90ddfda8811822'
self.wcapi = API(
url = 'http://127.0.0.1/bkstore',
consumer_key=admin_consumer_key,
consumer_secret=admin_consumer_secret,
version="v3"
)
def test_api(self):
'''
:return:
'''
print self.wcapi.get("").json()
print self.wcapi.get("").status_code
def post(self, endpoint, data):
'''
:param endpoint:
:param data:
:return:
'''
result = self.wcapi.post(endpoint, data)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return [rs_code, rs_body, rs_url]
def get(self, endpoint):
'''
:param endpoint:
:return:
'''
result = self.wcapi.get(endpoint)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return [rs_code, rs_body, rs_url]
def getCategories():
wcapi = API(url=fetched_data['url'],
consumer_key=fetched_data['consumer_key'],
consumer_secret=fetched_data['consumer_secret'],
version=fetched_data['version'])
catResp = wcapi.get("products/categories?per_page=100")
# print("===== catresp headers===")
# for el in catResp.headers:
# print(el)
totalPages = catResp.headers['X-WP-TotalPages']
totalCat = int(catResp.headers['X-WP-Total'])
rootLevelParents = []
secondLevelParents = []
catWoRoot = []
# cat id rom the form submit
# find rootLevelParents
for nextPage in range(2, int(totalPages) + 2):
for cat in catResp.json():
if cat['parent'] == 0:
# print(cat['name'])
rootLevelParents.append((cat['id'], cat['name']))
else:
catWoRoot.append((cat['id'], cat['name'], cat['parent']))
catResp = wcapi.get(
"products/categories?per_page=100&page={}".format(nextPage))
# print("total cat", totalCat)
# print("root cat", len(rootLevelParents))
# print("cat wo root", len(catWoRoot))
# find secondLevelParents
for catRow in catWoRoot:
for rootRow in rootLevelParents:
if catRow[2] == rootRow[0]:
secondLevelParents.append(catRow)
# print("secondLevelParents", len(secondLevelParents))
# print("=======TESTTTTTTTTTT================")
# print(rootLevelParents
# print("=======TESTTTTTTTTTT================")
# print(secondLevelParents))
return (rootLevelParents, secondLevelParents)
def grab_orders_woocommerce():
wcapi = API(url="https://pulselabz.com",
consumer_key="ck_a14883eff094abe7652196f03533c18b9c05eb0b",
consumer_secret="cs_47027dbf997bd9f53155f7251ed5b2cab27ac323",
wp_api=True,
version="wc/v1")
orders = wcapi.get("orders?status=processing&per_page=10")
for order in orders.json():
load_order_wc(order)
def grab_orders_woocommerce():
wcapi = API(url="https://pulselabz.com",
consumer_key=WC_KEY,
consumer_secret=WC_SECRET,
wp_api=True,
version="wc/v1")
orders = wcapi.get("orders?per_page=50")
for order in orders.json():
load_order_wc(order)
class Requests:
def __init__(self):
admin_consumer_key = 'ck_e5bf8b09f7dddc049037c01bb6cd540695363b75'
admin_consumer_secret = 'cs_2543d5b7ed833e6cf83ae4c3e8f2e5f0ccf5538a'
self.wcapi = API(url="http://127.0.0.1/wp",
consumer_key=admin_consumer_key,
consumer_secret=admin_consumer_secret,
version="wc/v3")
def test_api(self):
"""
:return:
"""
print(self.wcapi.get("").json())
def post(self, endpoint, data):
"""
:param endpoint:
:param data:
:return:
"""
result = self.wcapi.post(endpoint, data)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return [rs_code, rs_body, rs_url]
def get(self, endpoint):
"""
:param endpoint:
:return:
"""
result = self.wcapi.get(endpoint)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return [rs_code, rs_body, rs_url]
class WooCommerce(object):
def __init__(self, url, consumer_key, consumer_secret):
self.wcapi = API(url=url, consumer_key=consumer_key, consumer_secret=consumer_secret)
def get_api(self):
return self.wcapi
def open_products(self):
result = self.wcapi.get('products?filter[limit]=1000')
if result.status_code == 200:
return result.json()['products']
def get_products(self, q, limit=1000):
result = self.wcapi.get('products?filter[q]={q}&filter[limit]={limit}'.format(q=q, limit=1000))
if result.status_code == 200:
return result.json()['products']
def post_product(self, data):
if len(self.get_products(q=data['product']['title'])) == 0:
result = self.wcapi.post('products', data=data)
if result.statu_code == 200:
return result.json()
else:
return "The Products is already exists"
def get_tags(self):
result = self.wcapi.get('products/tags')
if result.status_code == 200:
return result.json()['product_tags']
def get_categories(self):
result = self.wcapi.get('products/categories')
if result.status_code == 200:
return result.json()['product_categories']
def save(self, filename, type='csv'):
if type == 'csv':
products = self.get_products()
keys = products[0].keys()
with open(filename, 'wb') as output_file:
dict_writer = csv.DictWriter(output_file, keys)
dict_writer.writeheader()
dict_writer.writerows(products)
class WooAPIUtility(object):
def __init__(self):
wc_creds = CredentialsUtility.get_wc_api_keys()
self.env = os.environ.get('ENV', 'test')
self.base_url = WOO_API_HOSTS[self.env]
self.wcapi = API(url=self.base_url,
consumer_key=wc_creds['wc_key'],
consumer_secret=wc_creds['wc_secret'],
version="wc/v3")
def assert_status_code(self):
assert self.status_code == self.expected_status_code, f"Bad Status code." \
f"Expected {self.expected_status_code}, Actual status code: {self.status_code}," \
f"URL: {self.endpoint}, Response Json: {self.rs_json}"
def post(self, wc_endpoint, params=None, expected_status_code=200):
rs_api = self.wcapi.post(wc_endpoint, data=params)
self.status_code = rs_api.status_code
self.expected_status_code = expected_status_code
self.rs_json = rs_api.json()
self.endpoint = wc_endpoint
self.assert_status_code()
logger.debug(f"POST API response: {self.rs_json}")
return self.rs_json
def get(self, wc_endpoint, params=None, expected_status_code=200):
rs_api = self.wcapi.get(wc_endpoint, params=params)
self.status_code = rs_api.status_code
self.expected_status_code = expected_status_code
self.rs_json = rs_api.json()
self.endpoint = wc_endpoint
self.assert_status_code()
logger.debug(f"GET API response: {self.rs_json}")
return self.rs_json
def put(self, wc_endpoint, params=None, expected_status_code=200):
rs_api = self.wcapi.put(wc_endpoint, data=params)
self.status_code = rs_api.status_code
self.expected_status_code = expected_status_code
self.rs_json = rs_api.json()
self.endpoint = wc_endpoint
self.assert_status_code()
logger.debug(f"PUT API response: {self.rs_json}")
return self.rs_json
class Request():
def __init__(self):
admin_consumer_key = "ck_b8cca2d3ba8e0d7b08c830254b59e1f005df5bd4"
admin_consumer_secret = "cs_b48bd72801b20cf8df76bee3864d21368f0ef444"
self.wcapi = API(url="http://127.0.0.1/testapi",
consumer_key=admin_consumer_key,
consumer_secret=admin_consumer_secret,
version="v3")
def test_api(self):
"""
:return:
"""
print self.wcapi.get("").json()
def post_request(self, endpoint, data):
"""
:param endpoint:
:param data:
:return:
"""
result = self.wcapi.post(endpoint, data)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return [rs_code, rs_body, rs_url]
def get_request(self, endpoint):
"""
:param endpoint:
:return:
"""
result = self.wcapi.get(endpoint)
rs_code = result.status_code
rs_body = result.json()
rs_url = result.url
return [rs_code, rs_body, rs_url]
class Request(object):
#--------------------------------------------------------------------------------
def __init__(self):
self._wcapi = API(
url=(Conf.API_URL),
consumer_key=(Conf.API_KEY),
consumer_secret=(Conf.API_SEC),
wp_api=(Conf.API_WP),
version=(Conf.API_VER),
)
print("\nAPI Connection Established: {0}\n".format(str(self._wcapi)))
return None
#--------------------------------------------------------------------------------
def test_api_connection(self):
return self._wcapi.get("").json()
#--------------------------------------------------------------------------------
def post(self, end_point, payload):
result = (self._wcapi.post(end_point, payload))
response_code = (result.status_code)
body = (result.json())
url = (result.url)
return [response_code, body, url]
#--------------------------------------------------------------------------------
def get(self, end_point):
result = (self._wcapi.get(end_point))
response_code = (result.status_code)
body = (result.json())
url = (result.url)
return [response_code, body, url]
def fetchBySKU(cls, APIClient: API, productSKU: str):
responseObject = APIClient.get("products", params={"sku": productSKU})
if responseObject.status_code == 200:
responseJSON = responseObject.json()
if len(responseJSON) < 1:
return None
else:
productJSON = responseJSON[0]
return cls(productJSON)
else:
return None
def test_printing_response():
wcapi = API(
url="http://localhost:10004",
consumer_key="ck_a29265ef5bc096bd7cec4266a7732ff63463521a",
consumer_secret="cs_4ac296939dcd86e2aef8b541b9f1c2ad8582a93b",
version="wc/v3"
)
r = wcapi.get("users")
pprint.pprint(r.json())
def getter(consumerKey,consumerSecret,site):
try:
wcapi = API(
url=base64.b64decode(site),
consumer_key=consumerKey,
consumer_secret=consumerSecret,
version="wc/v3"
)
return {"products": wcapi.get("products").json()}
except:
return {"Error": " Please verify parameters"}
class WPWoocommerce:
def __init__(self, invoice):
self.url = settings.woocommerce['url']
self.key = settings.woocommerce['key']
self.secret = settings.woocommerce['secret']
self.version = 'v2'
self.api = API(self.url, self.key, self.secret)
self.order = None
self.invoice = invoice
self.items = []
def getorder(self, id):
self.order = self.api.get('orders/' + str(id)).json()['order']
def get_billing_address(self):
data = self.order['billing_address']
name = data['first_name'] + ' ' + data['last_name']
street = data['address_1'] + ' ' + data['address_2']
client = Person(data['company'], name, street, data['postcode'], data['city'])
return client
from woocommerce import API
import pprint
import json
wcapi = API(
url="https://www.ameryn.com/",
consumer_key="ck_bc1ac58b5dc9099c8df1789f811afa2d",
consumer_secret="cs_7199c23290742677aed84294861ed73b",
version='v2',
verify_ssl=True
)
print wcapi
#order = wcapi.get('recording_orders/3050').json()
recording_orders = wcapi.get('orders?status=recording&filter[limit]=100').json()['orders']
#print json.dumps(order, indent=4)
for each_order in recording_orders:
print each_order['id'], '-', each_order['status'], '-', each_order['billing_address']['email'], '-', '$' + each_order['total']
print '{0} recording_orders, ${1}'.format(str(len(recording_orders)), sum([float(each_order['total']) for each_order in recording_orders]))
#print [order['id'] for order in wcapi.get('recording_orders?status=recording&fields=id&filter[limit]=100').json()['recording_orders']]
all_orders = wcapi.get('orders?filter[limit]=2000').json()['orders']
all_order_totals = [float(each_order['total']) for each_order in all_orders]
print all_order_totals
print '{0} orders, ${1}'.format(str(len(all_orders)), sum(all_order_totals))
print 'Creating new text file'
with open('order_totals.txt', 'w') as txt:
txt.writelines([str(each) for each in all_order_totals])
from woocommerce import API
from urlparse import urlparse, parse_qs
from random import randint
import os
wcapi = API(
url=os.environ['URL'],
consumer_key=os.environ['CONSUMER_KEY'],
consumer_secret=os.environ['CONSUMER_SECRET']
)
# request first product page
r = wcapi.get('products')
# figure out how many pages there are total
last_url = r.links['last']['url']
url_object = urlparse(last_url)
queries = parse_qs(url_object.query)
page_count = queries['page'][0] # was a string, need to convert to int
# pick a random page number to pull up and get those 10 products
page = randint(1, int(page_count))
r = wcapi.get('products?page=' + str(page)).json()
# choose one of the 10 products in the list of products and return its url
product_number = randint(0, 9)
url = r['products'][product_number]['permalink']
print url
class Request:
def __init__(self):
"""
http://woocommerce.github.io/woocommerce-rest-api-docs/
"""
consumer_key = config['CONNECTION']['consumer_key']
consumer_secret = config['CONNECTION']['consumer_secret']
self.wcapi = API(
url=config['CONNECTION']['url'],
consumer_key=consumer_key,
consumer_secret=consumer_secret,
wp_api=True,
version="wc/v2"
)
def post(self, endpoint, data):
"""
this method implements POST request to the provided endpoint with provided data in the body.
:param endpoint: endpoinf for request
:param data: json body
:return: lis of elements - response_code, response_body, response_url
"""
response = self.wcapi.post(endpoint, data)
response_code = response.status_code
response_body = response.json()
response_url = response.url
return [response_code, response_body, response_url]
def get(self, endpoint):
"""
this method implements GET request to the provided endpoint.
:param endpoint: endpoint for request
:return: lis of elements - response_code, response_body, response_url
"""
response = self.wcapi.get(endpoint)
response_code = response.status_code
response_body = response.json()
response_url = response.url
return [response_code, response_body, response_url]
def delete(self, endpoint):
"""
this method implements DELETE request to the provided endpoint
:param endpoint: endpoint for request
:return: lis of elements - response_code, response_body, response_url
"""
response = self.wcapi.delete(endpoint)
response_code = response.status_code
response_body = response.json()
response_url = response.url
return [response_code, response_body, response_url]
def put(self, endpoint, data):
"""
this method implements PUT request to the provided endpoint with provided data
:param data: json body
:param endpoint: endpoint for request
:return: lis of elements - response_code, response_body, response_url
"""
response = self.wcapi.put(endpoint, data)
response_code = response.status_code
response_body = response.json()
response_url = response.url
return [response_code, response_body, response_url]
from woocommerce import API as WCAPI
from pprint import pprint
dir_parent = os.path.dirname(os.path.dirname(sys.argv[0]))
if dir_parent:
os.chdir(dir_parent)
dir_conf = 'conf'
path_conf_wc = os.path.join(dir_conf, 'wc_api.yaml')
with open(path_conf_wc) as file_conf_wc:
conf_wc = yaml.load(file_conf_wc)
for key in ['consumer_key', 'consumer_secret', 'url']:
assert key in conf_wc, key
wcapi = WCAPI(
**conf_wc
)
r = wcapi.get("products?filter[meta]=true")
links_str = r.headers.get('link')
print links_str
for link_str in links_str.split(', '):
print repr(link_str)
response_json = r.json()
if 'products' in response_json:
for product in response_json['products']:
print product.get('id'), product.get('managing_stock'), product.get('stock_quantity'), product.get('in_stock'), product.get('product_meta', {}).get('MYOB SKU')
#!/usr/bin/env python
#coding=utf8
import pika
import sys
from woocommerce import API
import json
# use woocommerce lib
# install: pip install woocommerce
wcapi = API(
url = "http://120.55.166.84/Woo",
consumer_key = "ck_74e4287363f65b85f445cb763f24a8f382c401a2",
consumer_secret = "cs_f5700e2af5d238fae1bc784467bb7f8111f191d7",
timeout = 30
)
r = wcapi.get("products")
j = json.loads(r.text)
products = j['products']
for p in products:
print p['title']
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
message = ' '.join(sys.argv[1:]) or p['title']
channel.basic_publish(exchange='',
routing_key='hello',
body=message)
print " [x] Sent %r" % (message,)
connection.close()
# resource_owner_key)
#
#
#print uri
#print headers
#print body
root_url = "http://westmontptsa.org/wp"
from woocommerce import API
wcapi = API (url=root_url,
consumer_key = consumer_key,
consumer_secret = consumer_secret)
#products = wcapi.get("products")
#print products.json()
orders = wcapi.get("orders?filter[meta]=true")
import pprint
all_orders = orders.json()["orders"]
pp = pprint.PrettyPrinter(indent=4)
for order in all_orders:
#print order.keys()
try:
meta = order["order_meta"]
#u'Payer PayPal address'
#u'Payment type'
student_id = meta[u'Student ID']
student_name = meta[u'Student Name']
t_shirt = meta[u'T-Shirt Size']
phone = order["customer"]["billing_address"]["phone"]
parent_email = order["customer"]["billing_address"]["email"]
