def _send_request(self, suffix, data=None, content_type=None, category_id=None): if self._base_url.startswith("http://"): url = "{}/{}".format(self._base_url, suffix) else: url = "http://{}/{}".format(self._base_url, suffix) headers = {} if content_type is not None: headers["Content-Type"] = content_type try: if data is not None: result = requests.post(url, headers=headers, data=data) else: result = requests.get(url, headers=headers) if result.status_code == 404: raise CategoryException("No such Category: {}".\ format(category_id)) elif not result.ok: raise CategoryException("Error {}: {}".format( result.status_code, result.reason)) except BaseException as err: print(err) raise CategoryException(err) return result.text
def do_list_category(args, config): """ Lists out all the state associating with the UUIDs in the Transaction Family : Category Args: config (ConfigParser): ConfigParser which contains the default url Returns: type: str String representing JSON object which allows the client to know that the call was either a success or a failure. Raises: CategoryException: * If failed to retrieve the list """ b_url = config.get("DEFAULT", "url") client = CategoryBatch(base_url=b_url) category_list = client.list_category() if category_list is not None: category_list.sort(key=lambda x: x["timestamp"], reverse=True) result = json.dumps(category_list) output = ret_msg("success", "OK", "ListOf:CategoryRecord", result) print(output) else: raise CategoryException("Could not retrieve category listing.")
def main(prog_name=os.path.basename(sys.argv[0]), args=None): if args is None: args = sys.argv[1:] parser = create_parser(prog_name) args = parser.parse_args(args) if args.verbose is None: verbose_level = 0 else: verbose_level = args.verbose setup_loggers(verbose_level=verbose_level) config = load_config() if args.command == 'create': do_create_category(args, config) elif args.command == 'init': do_init(args, config) elif args.command == 'list-category': do_list_category(args, config) elif args.command == 'retrieve': do_retrieve_category(args, config) else: raise CategoryException("invalid command: {}".format(args.command))
def print_msg(response, cmd=None): """ Helps create the return message for the terminal or the web-browser. Args: response (None or list containing None and str): Contains the data for the function to construct return message cmd (None or str): The subcommand which was performed Returns: type: str String representing JSON object which allows the client to know that the call was either a success or a failure. Raises: CategoryException: * If response is None * If response is unknown * If response is a list with None """ try: if type(response) is list and response[0] == None: raise CategoryException("CategoryException : No change.") if response == None: if cmd == "create": raise CategoryException("CategoryException : Duplicate UUID.") elif cmd == "amend": raise CategoryException( "CategoryException : UUID does not exist.") raise CategoryException("Exception raised.") elif "batch_statuses?id" in response: print(ret_msg("success", "OK", "CategoryRecord", "{}")) return ret_msg("success", "OK", "CategoryRecord", "{}") else: raise CategoryException("Exception raised.") except BaseException as err: output = ret_msg("failed", str(err), "CategoryRecord", "{}") print(output) return output
def main_wrapper(): try: main() except CategoryException as err: errmsg = str(err) if '404' in errmsg: exp = ret_msg("failed", "404 Not Found", "EmptyRecord", "{}") print(CategoryException(exp)) else: exp = ret_msg("failed", errmsg, "EmptyRecord", "{}") print(CategoryException()) sys.exit(1) except KeyboardInterrupt: pass except SystemExit as err: raise err except BaseException as err: traceback.print_exc(file=sys.stderr) sys.exit(1)
def do_retrieve_category(args, config): category_id = args.category_id url = config.get('DEFAULT', 'url') client = CategoryBatch(base_url=url) data = client.retreive_category(category_id) if data is not None: result = filter_output(str(data)) output = ret_msg("success", "OK", "CategoryRecord", result) print(output) else: raise CategoryException("Category not found: {}".format(category_id))
def do_list_category(args, config): url = config.get('DEFAULT', 'url') key_file = config.get('DEFAULT', 'key_file') auth_user, auth_password = _get_auth_info(args) client = CategoryBatch(base_url=url, keyfile=key_file) category_list = client.list_category(auth_user=auth_user, auth_password=auth_password) if category_list is not None: output = refine_output(str(category_list)) print(output) else: raise CategoryException("Could not retrieve category listing.")
def do_list_category(args, config): b_url = config.get('DEFAULT', 'url') client = CategoryBatch(base_url=b_url) category_list = client.list_category() if category_list is not None: if str(category_list) != "[]": result = refine_output(str(category_list)) output = ret_msg("success","OK","ListOf:CategoryRecord",result) else: output = ret_msg("success","OK","ListOf:CategoryRecord",str(category_list)) print (output) else: raise CategoryException("Could not retrieve category listing.")
def do_retrieve_category(args, config): category_id = args.category_id url = config.get('DEFAULT', 'url') key_file = config.get('DEFAULT', 'key_file') auth_user, auth_password = _get_auth_info(args) client = CategoryBatch(base_url=url, keyfile=key_file) data = client.retreive_category(category_id, auth_user=auth_user, auth_password=auth_password) if data is not None: output = filter_output(str(data)) print(output) else: raise CategoryException("Category not found: {}".format(category_id))
def do_init(args, config): username = config.get('DEFAULT', 'username') if args.username is not None: username = args.username url = config.get('DEFAULT', 'url') if args.url is not None: url = args.url config.set('DEFAULT', 'username', username) print("set username: {}".format(username)) config.set('DEFAULT', 'url', url) print("set url: {}".format(url)) save_config(config) priv_filename = config.get('DEFAULT', 'key_file') if priv_filename.endswith(".priv"): addr_filename = priv_filename[0:-len(".priv")] + ".addr" else: addr_filename = priv_filename + ".addr" if not os.path.exists(priv_filename): try: if not os.path.exists(os.path.dirname(priv_filename)): os.makedirs(os.path.dirname(priv_filename)) privkey = signing.generate_privkey() pubkey = signing.generate_pubkey(privkey) addr = signing.generate_identifier(pubkey) with open(priv_filename, "w") as priv_fd: print("writing file: {}".format(priv_filename)) priv_fd.write(privkey) priv_fd.write("\n") with open(addr_filename, "w") as addr_fd: print("writing file: {}".format(addr_filename)) addr_fd.write(addr) addr_fd.write("\n") except IOError as ioe: raise CategoryException("IOError: {}".format(str(ioe)))
def do_retrieve_category(args, config): """ Retrieves the state associating with the UUID in the Transaction Family : Category Args: args (ArgumentParser): ArgumentParser object containing required parameters config (ConfigParser): ConfigParser which contains the default url Returns: type: str String representing JSON object which allows the client to know that the call was either a success or a failure. Raises: CategoryException: * If failed to retrieve the uuid """ all_flag = args.all range_flag = args.range category_id = args.category_id if range_flag != None: all_flag = True b_url = config.get("DEFAULT", "url") client = CategoryBatch(base_url=b_url) data = client.retreive_category(category_id, all_flag, range_flag) if data is not None: if all_flag == False: output = ret_msg("success", "OK", "CategoryRecord", data.decode()) else: output = ret_msg("success", "OK", "CategoryRecord", data) print(output) else: raise CategoryException("Category not found: {}".format(category_id))
def do_retrieve_category(args, config): all_flag = args.all range_flag = args.range category_id = args.category_id if range_flag != None: all_flag = True b_url = config.get("DEFAULT", "url") client = CategoryBatch(base_url=b_url) data = client.retreive_category(category_id, all_flag, range_flag) if data is not None: if all_flag == False: output = ret_msg("success", "OK", "CategoryRecord", data.decode()) else: output = ret_msg("success", "OK", "CategoryRecord", json.loads(data)) print(output) else: raise CategoryException("Category not found: {}".format(category_id))
def do_list_category(args, config): b_url = config.get("DEFAULT", "url") client = CategoryBatch(base_url=b_url) category_list = client.list_category() if category_list is not None: if str(category_list) != "[]": result = ("[" + str(category_list)[3:-2] + "]").replace("b'", "")\ .replace("'", "") result = json.loads(result) result.sort(key=lambda x:x["timestamp"], reverse=True) result = json.dumps(result) output = ret_msg("success", "OK", "ListOf:CategoryRecord", result) else: output = ret_msg("success", "OK", "ListOf:CategoryRecord", str(category_list)) print (output) else: raise CategoryException("Could not retrieve category listing.")
def _send_request(self, suffix, data=None, content_type=None, category_id=None, creation=False): """ Performs RESTful API call on the given params. Args: suffix (str): The suffix of the url in query data (str): The data to be sent in POST request (default None) content_type (str): The data type (default None) category_id (str): The uuid of the category (default None) creation (bool): The flag for "create" command (default False) Returns: type: str Data associated with suffix as a string. or type: None None object if any exception occurs or "404" was raised during "create" command. Raises: CategoryException: * If "404" was raised for the request * If status was "sucessful" """ # Building the URL if self._base_url.startswith("http://"): url = "{}/{}".format(self._base_url, suffix) else: url = "http://{}/{}".format(self._base_url, suffix) headers = {} if content_type is not None: headers["Content-Type"] = content_type # Performing appropriate RESTful API try: if data is not None: result = requests.post(url, headers=headers, data=data) else: result = requests.get(url, headers=headers) if result.status_code == 404: if creation: return None raise CategoryException("No such Category: {}".\ format(category_id)) elif not result.ok: raise CategoryException("Error {}: {}".format( result.status_code, result.reason)) except BaseException as err: print(err) return None # Returning the data as string return result.text