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"]