def ux_get_sales_volume(self):
pcode = self.product_codes_var.get()
response = cafe24_queries.main("get_products",
self.tokens["access_token"],
{"product_code": pcode})
product_nom = response[0]["product_no"]
sales_volume_kwargs = {
"start_date": self.order_start_date_button_var.get(),
"end_date": self.order_end_date_button_var.get(),
"product_no": product_nom
}
response = cafe24_queries.main("get_sales_volume",
self.tokens["access_token"],
sales_volume_kwargs)
handled = self.response_handler(response)
if type(handled) == list:
out_df = pd.DataFrame(handled)
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
"get_sales_volume", self.tokens["access_token"],
sales_volume_kwargs)
handled_again = self.response_handler(response_again)
if type(handled_again) is str:
return
elif type(handled_again) is list:
out_df = pd.DataFrame(handled)
elif handled == "error":
return
self.__gen_df_excel(out_df)
def get_count(self, query_str, count_kwarg_dict):
response = cafe24_queries.main(query_str, self.tokens["access_token"],
count_kwarg_dict)
handled = self.response_handler(response)
if type(handled) is int:
self.log("Count:{}".format(handled))
return handled
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
query_str, self.tokens["access_token"], count_kwarg_dict)
handled_again = self.response_handler(response_again)
if type(handled_again) is int:
self.log("Count:{}".format(handled))
return handled_again
elif type(handled_again) is str:
self.abort_request_popup()
return False
elif handled == "error":
self.abort_request_popup()
return False
def ux_get_products_by_category_nom(self, gen_excel=True):
pathstr = tk.filedialog.askopenfilename()
init_df = pd.read_excel(pathstr, 0)
if "category_no" in init_df.columns:
categories = init_df["category_no"]
else:
categories = init_df.iloc[:, 0]
start_date_timezone = self.order_start_datetime.isoformat()
end_date_timezone = self.order_end_datetime.isoformat()
failed_requests = []
master_df = pd.DataFrame()
cat_set = set(categories)
# print(cat_set)
for index, category_no in enumerate(list(cat_set)):
# print(category_no)
self.log("Getting data for category: {}, #{} of {}".format(
category_no, index, len(cat_set)))
category_df = pd.DataFrame()
product_kwargs = {
"category": category_no,
"created_start_date": start_date_timezone,
"created_end_date": end_date_timezone
}
total_count = self.get_count("get_product_count", product_kwargs)
if total_count is False:
return
req_pages = (total_count // 100) + 1
if req_pages > 50:
self.bug("CANNOT CALL MORE THAN 50 PAGES!")
self.bug("Currently need {} pages for {} orders.".format(
req_pages, total_count))
self.too_many_pages(total_count, req_pages)
return
for page_n in range(0, req_pages):
if len(failed_requests) > 10:
self.bug("Too many failed requests, stopping.")
self.create_popup("Aborting Request",
"Too Many Failed API Requests!")
break
product_kwargs["offset"] = 100 * page_n
response = cafe24_queries.main("get_products_by_category",
self.tokens["access_token"],
product_kwargs)
handled = self.response_handler(response)
# print(handled)
if type(handled) == list:
category_df = pd.concat(
[category_df, pd.DataFrame(handled)],
axis=0,
ignore_index=True,
join="outer")
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
"get_products_by_category",
self.tokens["access_token"], product_kwargs)
handled_again = self.response_handler(response_again)
if type(handled_again) is str:
failed_requests.append(category_no)
elif type(handled_again) is list:
category_df = pd.concat(
[category_df,
pd.DataFrame(handled_again)],
axis=0,
ignore_index=True,
join="outer")
elif handled == "error":
failed_requests.append(category_no)
category_df["category"] = category_no
converted_df = self.convert_category_to_text(category_df)
master_df = pd.concat([master_df, converted_df],
axis=0,
ignore_index=True,
join="outer")
master_df.drop_duplicates(subset="product_code", inplace=True)
self.bug("\n".join(failed_requests))
cols = list(master_df.columns.values
) #Make a list of all of the columns in the df
cols.pop(cols.index("product_code")) #Remove b from list
master_df = master_df[["product_code"] + cols]
if gen_excel:
if master_df.shape[0] > 10:
self.__gen_df_excel(master_df, transpose=False)
else:
self.__gen_df_excel(master_df, transpose=True)
else:
return master_df
def ux_get_products(self, product_ids=None, gen_excel=True):
self.log("Get Products Called")
failed_requests = []
if product_ids is None:
clean_entry = self.product_codes_var.get().strip().replace(
" ", "").replace("\n", "")
ids_set = set(clean_entry.split(","))
else:
ids_set = product_ids
curr_df = pd.DataFrame()
CHUNK_SIZE = 50
for index, product_code_chunk in enumerate(
self.get_chunks(ids_set, CHUNK_SIZE)):
self.log("Getting data for chunk #{}".format(index))
if len(failed_requests) > 10:
self.bug("Too many failed requests, stopping.")
self.create_popup("Aborting Request",
"Too Many Failed API Requests!")
break
stringed = ",".join(product_code_chunk)
response = cafe24_queries.main("get_products",
self.tokens["access_token"],
{"product_code": stringed})
handled = self.response_handler(response)
if type(handled) == list:
curr_df = pd.concat([curr_df, pd.DataFrame(handled)],
axis=0,
ignore_index=True,
join="outer")
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
"get_products", self.tokens["access_token"],
{"product_code": stringed})
handled_again = self.response_handler(response_again)
if type(handled_again) is str:
failed_requests.append(product_code_chunk)
elif type(handled_again) is list:
curr_df = pd.concat(
[curr_df, pd.DataFrame(handled_again)],
axis=0,
ignore_index=True,
join="outer")
elif handled == "error":
failed_requests.append(product_code_chunk)
self.bug("\n".join(failed_requests))
cols = list(curr_df.columns.values
) #Make a list of all of the columns in the df
cols.pop(cols.index("product_code")) #Remove b from list
curr_df = curr_df[["product_code"] + cols]
if gen_excel:
if curr_df.shape[0] > 10:
self.__gen_df_excel(curr_df, transpose=False)
else:
self.__gen_df_excel(curr_df, transpose=True)
else:
return curr_df
def ux_get_order_items(self, order_ids=None, gen_excel=True):
self.log("Get Order Items Called")
failed_requests = []
if order_ids is None:
clean_entry = self.order_id_var.get().strip().replace(" ",
"").replace(
"\n", "")
ids_set = set(clean_entry.split(","))
else:
ids_set = order_ids
curr_df = pd.DataFrame()
for index, order_id in enumerate(ids_set):
self.log("Getting order_items for id: {}, {} out of {}".format(
order_id, index, len(ids_set)))
if len(failed_requests) > 10:
self.bug("Too many failed requests, stopping.")
break
response = cafe24_queries.main("get_order_items",
self.tokens["access_token"],
{"order_id": order_id})
handled = self.response_handler(response)
if type(handled) == list:
curr_df = pd.concat([curr_df, pd.DataFrame(handled)],
axis=0,
ignore_index=True,
join="outer")
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
"get_order_items", self.tokens["access_token"],
{"order_id": order_id})
handled_again = self.response_handler(response_again)
if type(handled_again) is str:
failed_requests.append(order_id)
elif type(handled_again) is list:
curr_df = pd.concat(
[curr_df, pd.DataFrame(handled_again)],
axis=0,
ignore_index=True,
join="outer")
elif handled == "error":
failed_requests.append(order_id)
self.bug("\n".join(failed_requests))
cols = list(curr_df.columns.values
) #Make a list of all of the columns in the df
cols.pop(cols.index("order_item_code")) #Remove b from list
curr_df = curr_df[["order_item_code"] + cols]
if gen_excel:
if curr_df.shape[0] > 10:
self.__gen_df_excel(curr_df, transpose=False)
else:
self.__gen_df_excel(curr_df, transpose=True)
else:
return curr_df
def ux_get_orders(self, gen_excel=True):
self.log("Get Orders Called.")
count_kwargs = {
"start_date": self.order_start_date_button_var.get(),
"end_date": self.order_end_date_button_var.get()
}
total_count = self.get_count("get_order_count", count_kwargs)
if not total_count:
return
req_pages = (total_count // 500) + 1
if req_pages > 16:
self.bug("CANNOT CALL MORE THAN 16 PAGES!")
self.bug("Currently need {} pages for {} orders.".format(
req_pages, total_count))
self.too_many_pages(total_count, req_pages)
return
self.log("Required pages: {}".format(req_pages))
order_kwargs = {
"start_date": self.order_start_date_button_var.get(),
"end_date": self.order_end_date_button_var.get()
}
failed_x_pages = []
curr_df = pd.DataFrame()
for x in range(0, req_pages):
self.log("Getting page: {} of {}...".format(x + 1, req_pages))
order_kwargs["offset"] = 500 * x
response = cafe24_queries.main("get_orders",
self.tokens["access_token"],
order_kwargs)
handled = self.response_handler(response)
if type(handled) == list:
curr_df = pd.concat([curr_df, pd.DataFrame(handled)],
axis=0,
ignore_index=True,
join="outer")
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
"get_orders", self.tokens["access_token"],
order_kwargs)
handled_again = self.response_handler(response_again)
if type(handled_again) is str:
failed_x_pages.append(x)
elif type(handled_again) is list:
curr_df = pd.concat(
[curr_df, pd.DataFrame(handled_again)],
axis=0,
ignore_index=True,
join="outer")
elif handled == "error":
failed_x_pages.append(x)
self.log("Compiling all pages...")
self.bug(failed_x_pages)
cols = list(curr_df.columns.values
) #Make a list of all of the columns in the df
cols.pop(cols.index("order_id")) #Remove b from list
curr_df = curr_df[["order_id"] + cols]
if gen_excel:
self.__gen_df_excel(curr_df)
else:
return curr_df
def ux_get_orders_full(self, gen_excel=True):
self.log("Get Orders Items FULL Called.")
count_kwargs = {
"start_date": self.order_start_date_button_var.get(),
"end_date": self.order_end_date_button_var.get()
}
total_count = self.get_count("get_order_count", count_kwargs)
if not total_count:
return
req_pages = (total_count // 500) + 1
if req_pages > 16:
self.bug("CANNOT CALL MORE THAN 16 PAGES!")
self.bug("Currently need {} pages for {} orders.".format(
req_pages, total_count))
self.too_many_pages(total_count, req_pages)
return
self.log("Required pages: {}".format(req_pages))
failed_x_pages = []
order_kwargs = {
"start_date": self.order_start_date_button_var.get(),
"end_date": self.order_end_date_button_var.get(),
"embed": "items"
}
curr_orders_df = pd.DataFrame()
order_items_dict_list = []
for x in range(0, req_pages):
self.log("Getting page: {} of {}...".format(x + 1, req_pages))
order_kwargs["offset"] = 500 * x
response = cafe24_queries.main("get_orders",
self.tokens["access_token"],
order_kwargs)
handled = self.response_handler(response)
if type(handled) == list:
for order_dict in handled:
order_items_dict_list += order_dict["items"]
order_dict.pop("items")
append_df = pd.DataFrame(handled)
curr_orders_df = pd.concat([curr_orders_df, append_df],
axis=0,
ignore_index=True,
join="outer")
elif type(handled) is str:
if handled == "try_again":
response_again = cafe24_queries.main(
"get_orders", self.tokens["access_token"],
order_kwargs)
handled_again = self.response_handler(response_again)
if type(handled_again) is str:
failed_x_pages.append(x)
elif type(handled_again) is list:
for order_dict in handled_again:
order_items_dict_list += order_dict["items"]
order_dict.pop("items")
append_df = pd.DataFrame(handled_again)
curr_orders_df = pd.concat([curr_orders_df, append_df],
axis=0,
ignore_index=True,
join="outer")
elif handled == "error":
failed_x_pages.append(x)
curr_order_items_df = pd.DataFrame(order_items_dict_list)
curr_order_items_df['order_id'] = curr_order_items_df[
"order_item_code"].apply(self.get_order_id)
merged = pd.merge(curr_order_items_df,
curr_orders_df,
on="order_id",
right_index=False,
how='left',
sort=False)
if self.use_insights_headers.get():
merged = self.get_translated_and_dropped_df(
merged, self.get_cfg_val("header_reference"))
merged = self.convert_all_date_columns(merged)
merged = merged.loc[merged['date_payment'] != ""]
self.__gen_df_excel(merged)