def __init__(self, filepath): """ :param filepath: Path to the root directory of the app being installed self.navigator: Navigator() onject self.app_name: Name of the actual app directory. self.path_to_app: Path to the actual app directory self.wf_config_file: Path to the app's wf_config file self.urls_inclusions: List of ursl that need o be included in main urls.py self.mandatory_fields: Mandatory fields necessary in wf_config.json self.wapp_data: All data in the wf_config.json file self.django_based: True indicates that this app uses new Katana API. False indicates that app still uses the old Katana API """ self.navigator = Navigator() self.app_name = get_sub_folders( join_path(filepath, "warriorframework_py3", "katana", "katana.wapps"))[0] self.path_to_app = join_path(filepath, "warriorframework_py3", "katana", "katana.wapps", self.app_name) self.wf_config_file = join_path(self.path_to_app, "wf_config.json") self.urls_inclusions = [] self.mandatory_fields = [ "app", "version", "warrior-compatibility", "warrior-incompatibility" ] self.wapp_data = read_json_data(self.wf_config_file) self.django_based = False if "pure_django" not in self.wapp_data or not self.wapp_data[ "pure_django"] else True
def ready(self): """ The ready function is trigger only on events like server start up and server reload """ # print "***************You are in Core Katana App Config Class***************" nav_obj = Navigator() base_directory = nav_obj.get_katana_dir() warrior_dir = nav_obj.get_warrior_dir() config_file_name = "wf_config.json" config_json_file = join_path(base_directory, "config.json") settings_file_path = get_abs_path(join_path("wui", "settings.py"), base_directory) core_index_obj = CoreIndex(base_directory, settings_file_path=settings_file_path) available_apps = core_index_obj.get_available_apps() settings_apps = core_index_obj.get_apps_from_settings_file() AppInformation.information = Apps() AppInformation.information.set_apps({ 'base_directory': base_directory, 'config_file_name': config_file_name, 'available_apps': available_apps, 'settings_apps': settings_apps }) if os.environ["pipmode"] == "True": pythonsrcdir = read_json_data(config_json_file)['pythonsrcdir'] else: pythonsrcdir = warrior_dir ordered_json = validate_config_json(read_json_data(config_json_file), pythonsrcdir) with open(config_json_file, "w") as f: f.write(json.dumps(ordered_json, indent=4))
def read_config_file(request): nav_obj = Navigator() config_file_path = join_path(nav_obj.get_katana_dir(), "config.json") data = read_json_data(config_file_path) if data is None: data = False return JsonResponse(data)
def get(self, request): """ This is a get request for getting the file explorer data. It internally calls the get_dir_tree_json() in navigator_utils.py to get a list of directories. THIS VIEW EXISTS ONLY BECAUSE JSTREE DOES NOT HAVE SUPPORT FOR POST IN LAZY LOADING. params sent via the request: start_dir: Absolute path to the start directory. If not given, defaulted to "Warriorspace". path: Absolute path to the current directory. Send a path via this argument indicates that information for current directory's parent needs to be obtained. If not False, it is prioritized over start_dir lazy_loading: Indicates that jsTree lazy_loading is being used and only direct sub-children's information needs to be obtained. """ nav_obj = Navigator() start_dir = "false" lazy_loading = True if "lazy_loading" in request.GET and request.GET["lazy_loading"].lower() == "true" else False config_data = read_config_file_data() get_children_only = False if "start_dir" in request.GET: get_children_only = True start_dir = request.GET["start_dir"] if os.environ["pipmode"] == 'True': if config_data["pythonsrcdir"] != "" and start_dir == "false": get_children_only = False if config_data["xmldir"].split("/")[-2] == "warriorspace" or config_data["xmldir"].split("/")[-2] == "Warriorspace": start_dir = config_data["pythonsrcdir"] + "/" +config_data["xmldir"].split("/")[-2] elif config_data["xmldir"].split("/")[-3] == "warriorspace" or config_data["xmldir"].split("/")[-3] == "Warriorspace": start_dir = config_data["pythonsrcdir"] + "/" +config_data["xmldir"].split("/")[-3] else: start_dir = config_data["pythonsrcdir"] elif config_data["pythonsrcdir"] == "" and start_dir == "false": get_children_only = False start_dir = nav_obj.get_katana_dir() else: if config_data["pythonsrcdir"] != "" and start_dir == "false": get_children_only = False if config_data["xmldir"].split("/")[-2] == "warriorspace" or config_data["xmldir"].split("/")[-2] == "Warriorspace": start_dir = config_data["pythonsrcdir"] + "/" +config_data["xmldir"].split("/")[-2] elif config_data["xmldir"].split("/")[-3] == "warriorspace" or config_data["xmldir"].split("/")[-3] == "Warriorspace": start_dir = config_data["pythonsrcdir"] + "/" +config_data["xmldir"].split("/")[-3] else: start_dir = config_data["pythonsrcdir"] elif config_data["pythonsrcdir"] == "" and start_dir == "false": get_children_only = False start_dir = nav_obj.get_katana_dir() if "path" in request.GET: get_children_only = False start_dir = request.GET["path"] output = nav_obj.get_dir_tree_json(start_dir_path=start_dir, lazy_loading=lazy_loading) if get_children_only: output = output["children"] return JsonResponse(output, safe=False)
def __init__(self, template, file_path): self.navigator = Navigator() self.template = template self.file_path = file_path self.template_data = read_xml_get_json(template, ordered_dict=True) self.data = read_xml_get_json(file_path, ordered_dict=True) self.output = {"status": True, "message": ""} self.root = "Project"
def __init__(self, template, file_path): """ Constructor of the VerifyCaseFile class """ self.navigator = Navigator() self.template = template self.file_path = file_path self.template_data = read_xml_get_json(template, ordered_dict=True) self.data = read_xml_get_json(file_path, ordered_dict=True) self.output = {"status": True, "message": ""} self.root = "TestWrapper" self.major = ("Details", "Requirements", "Steps")
def __init__(self, data_file, ref_data_file): self.data_file = data_file self.data = read_xml_get_json(data_file) self.ref_data_file = ref_data_file self.nav_obj = Navigator() self.dependency_template = join_path(self.nav_obj.get_katana_dir(), "native", "settings", "static", "settings", "base_templates", "empty.xml") self.ref_data = self._get_ref_data() self.dependency_dict = self.__get_dependency_dict()
def save_warhorn_config_file(request): nav_obj = Navigator() directory = request.POST.get('directory') if directory == "default": directory = os.path.join(nav_obj.get_katana_dir(), "katana.wapps", "assembler", ".data") filepath = os.path.join(directory, request.POST.get('filename') + ".xml") json_data = json.loads(request.POST.get('json_data')) json_data["data"]["warriorframework"] = "Test" data = xmltodict.unparse(json_data) response = _save_file(filepath, data) return JsonResponse(response)
def __init__(self): """ Constructor for execution app """ self.nav = Navigator() self.config_data = "" self.katana_dir = os.path.dirname(katana.native.__path__[0]) self.config_json = os.path.join(self.katana_dir, 'config.json') self.config_json_dict = "" self.warrior_dir = "" self.warrior = "" self.default_ws = "" self.templates_dir = os.path.join(templates_dir, 'execution') self.jira_settings_file = "" self.execution_settings_json = os.path.join(templates_dir, 'execution', 'execution_settings.json')
class CliDataFileClass(View): nav_obj = Navigator() app_directory = join_path(nav_obj.get_katana_dir(), "wapps", "cli_data") app_static_dir = join_path(app_directory, "static") def get(self, request): filepath = request.GET.get('path') # filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "test.xml") base_filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "empty.xml") if filepath == "false": filepath = base_filepath name = "Untitled" else: name, _ = os.path.splitext(get_dir_from_path(filepath)) vcdc_obj = VerifyCliDataClass(filepath, base_filepath) json_data = vcdc_obj.verify_contents() return JsonResponse({"contents": json_data, "name": name}) def post(self, request): json_data = json.loads(request.POST.get('json_data')) data = xmltodict.unparse(json_data) directory = request.POST.get('directory') filepath = os.path.join(directory, request.POST.get('filename') + ".xml") message = "" saved = True try: with open(filepath, 'w') as f: f.write(data) except Exception as e: saved = False message = e return JsonResponse({"saved": saved, "message": message})
def get_jstree_dir(request): """ Prepare the json for jstree to use """ config = read_json_data(JSON_CONFIG) data = Navigator().get_dir_tree_json(config["idfdir"]) data["text"] = config["idfdir"] # print json.dumps(data, indent=4) return JsonResponse(data)
def get_user_data(self): """ function is still used for backward compatibility, can be deprecated once completely handled by client server model """ userdata = {} json_file = Navigator().get_katana_dir() + '/user_profile.json' with open(json_file, 'r') as f: userdata = json.load(f) return userdata
def __init__(self): """ Constructor for execution app """ self.nav = Navigator() self.config_data = read_config_file_data() self.katana_dir = os.path.dirname(native.__path__[0]) self.wf_dir = os.path.dirname(self.katana_dir) self.warrior = os.path.join(self.wf_dir, 'warrior', 'Warrior') if os.environ["pipmode"] == 'True': self.default_ws = self.config_data["pythonsrcdir"] else: self.default_ws = os.path.join(self.wf_dir, 'warrior', 'Warriorspace') self.templates_dir = os.path.join(templates_dir, 'execution') self.jira_settings_file = os.path.join(self.wf_dir, 'warrior', 'Tools', 'jira', 'jira_config.xml') self.execution_settings_json = os.path.join(templates_dir, 'execution', 'execution_settings.json') self.config_json = os.path.join(self.katana_dir, 'config.json')
def get_jstree_dir(request): """ Prepare the json for jstree to use """ config = read_json_data(JSON_CONFIG) if os.path.exists(config["idfdir"]): data = Navigator().get_dir_tree_json(config["idfdir"]) data["text"] = config["idfdir"] else: data="invalid_path" # print json.dumps(data, indent=4) return JsonResponse(data, safe=False)
def post(self, request): """ This is a post request for getting the file explorer data. It internally calls the get_dir_tree_json() in navigator_utils.py to get a list of directories. params sent via the request: start_dir: Absolute path to the start directory. If not given, defaulted to "Warriorspace". path: Absolute path to the current directory. Send a path via this argument indicates that information for current directory's parent needs to be obtained. If not False, it is prioritized over start_dir lazy_loading: Indicates that jsTree lazy_loading is being used and only direct sub-children's information needs to be obtained. """ nav_obj = Navigator() lazy_loading = True if "data[lazy_loading]" in request.POST and request.POST["data[lazy_loading]"].lower() == "true" else False start_dir = "false" config_data = read_config_file_data() if "data[start_dir]" in request.POST: start_dir = request.POST["data[start_dir]"] if os.environ["pipmode"] == 'True': if config_data["pythonsrcdir"] != "" and start_dir == "false": start_dir = config_data["pythonsrcdir"] elif config_data["pythonsrcdir"] == "" and start_dir == "false": start_dir = nav_obj.get_katana_dir() else: if config_data["pythonsrcdir"] != "" and start_dir == "false": get_children_only = False start_dir = config_data["pythonsrcdir"] elif config_data["pythonsrcdir"] == "" and start_dir == "false": get_children_only = False start_dir = nav_obj.get_katana_dir() if "data[path]" in request.POST and request.POST["data[path]"] != "false": start_dir = get_parent_directory(request.POST["data[path]"]) output = nav_obj.get_dir_tree_json(start_dir_path=start_dir, lazy_loading=lazy_loading) return JsonResponse(output)
def save_and_run_warhorn_config_file(request): nav_obj = Navigator() directory = request.POST.get('directory') if directory == "default": directory = os.path.join(nav_obj.get_katana_dir(), "katana.wapps", "assembler", ".data") filepath = os.path.join(directory, request.POST.get('filename') + ".xml") json_data = json.loads(request.POST.get('json_data')) json_data["data"]["warriorframework"] = "Test" data = xmltodict.unparse(json_data) response = _save_file(filepath, data) nav_obj = Navigator() warhorn_dir = nav_obj.get_warhorn_dir() current_dir = os.getcwd() output = "" if response["saved"]: os.chdir(warhorn_dir) output = subprocess.Popen(["python", "warhorn.py", filepath], stdout=subprocess.PIPE).communicate()[0] os.chdir(current_dir) os.remove(filepath) return JsonResponse({"output": output})
def get_data_directory(request): nav_obj = Navigator() directory = os.path.join(nav_obj.get_katana_dir(), "katana.wapps", "assembler", ".data") return JsonResponse({"data_directory": directory})
class VerifyTestWrapperFile: def __init__(self, template, file_path): """ Constructor of the VerifyCaseFile class """ self.navigator = Navigator() self.template = template self.file_path = file_path self.template_data = read_xml_get_json(template, ordered_dict=True) self.data = read_xml_get_json(file_path, ordered_dict=True) self.output = {"status": True, "message": ""} self.root = "TestWrapper" self.major = ("Details", "Requirements", "Steps") def verify_file(self): """ This function verifies the case file """ self.output = self.__verify_root() if self.output["status"]: self.__verify_details() self.__verify_requirements() self.__verify_steps() return self.output, self.data def __verify_root(self): """ Verifies the root of the case file """ output = self.output for key in self.data: if key != self.root: output["status"] = False output["message"] = "{0} is not is the correct format." print("-- An Error Occurred -- {0}".format(output["message"])) break return output def __verify_details(self): """ Verifies the details section of the case file """ if self.major[0] not in self.data[self.root]: self.data[self.root][self.major[0]] = {} for key, value in self.template_data[self.root][self.major[0]].items(): key, value = self.__verified_details_key_value(key, value) self.data[self.root][self.major[0]][key] = self.__verify_values(key, value, self.data[self.root][self.major[0]]) def __verified_details_key_value(self, key, value): """ Verifies specific keys in details """ if value is None: value = "" if value == "": if key == "Engineer": value = self.navigator.get_engineer_name() if key == "Date": now = datetime.now() value = "{0}-{1}-{2}".format(now.year, now.month, now.day) if key == "Time": now = datetime.now() value = "{0}:{1}".format(now.hour, now.minute) return key, value def __verify_requirements(self): """ Verifies the requirements section of the case file """ if self.major[1] not in self.data[self.root] or self.data[self.root][self.major[1]] is None: self.data[self.root][self.major[1]] = {"Requirement": []} elif "Requirement" not in self.data[self.root][self.major[1]] or self.data[self.root][self.major[1]]["Requirement"] is None: self.data[self.root][self.major[1]]["Requirement"] = [] elif not isinstance(self.data[self.root][self.major[1]]["Requirement"], list): self.data[self.root][self.major[1]]["Requirement"] = [self.data[self.root][self.major[1]]["Requirement"]] def __verify_steps(self): """ Verifies the steps section of the case file """ if self.major[2] not in self.data[self.root]: self.data[self.root][self.major[2]] = {"step": []} elif not isinstance(self.data[self.root][self.major[2]]["step"], list): self.data[self.root][self.major[2]]["step"] = [self.data[self.root][self.major[2]]["step"]] @staticmethod def __verified_steps_key_value(key, value, verify_data): """ Verifies specific keys in each step """ if value is None: value = "" if key == "Arguments": if key not in verify_data or verify_data[key] is None: verify_data[key] = {} if "argument" not in verify_data[key] or verify_data[key]["argument"] is None: verify_data[key]["argument"] = [{}] elif not isinstance(verify_data[key]["argument"], list): verify_data[key]["argument"] = [verify_data[key]["argument"]] if key == "Execute": if key not in verify_data or verify_data[key] is None: verify_data[key] = {} if "Rule" not in verify_data[key] or verify_data[key]["Rule"] is None: verify_data[key]["Rule"] = [{}] elif not isinstance(verify_data[key]["Rule"], list): verify_data[key]["Rule"] = [verify_data[key]["Rule"]] return key, value, verify_data def __verify_values(self, tmpl_key, tmpl_value, parent): """ Verifies key value in each step with the case emplate file """ output = "" if tmpl_key not in parent: output = tmpl_value elif parent[tmpl_key] is None: output = tmpl_value else: if isinstance(parent[tmpl_key], list): for i in range(0, len(parent[tmpl_key])): for k, v in tmpl_value.items(): parent[tmpl_key][i][k] = self.__verify_values(k, v, parent[tmpl_key][i]) output = parent[tmpl_key] elif isinstance(tmpl_value, OrderedDict): for k, v in list(tmpl_value.items()): parent[tmpl_key][k] = self.__verify_values(k, v, parent[tmpl_key]) output = parent[tmpl_key] else: output = parent[tmpl_key] if parent[tmpl_key].strip() != "" else tmpl_value return output
def __init__(self): self.navigator = Navigator() self.static_dir = join_path(self.navigator.get_katana_dir(), "native", "settings", "static", "settings")
class Execution(object): """ Execution app class """ def __init__(self): """ Constructor for execution app """ self.nav = Navigator() self.config_data = read_config_file_data() self.katana_dir = os.path.dirname(native.__path__[0]) self.wf_dir = os.path.dirname(self.katana_dir) self.warrior = os.path.join(self.wf_dir, 'warrior', 'Warrior') if os.environ["pipmode"] == 'True': self.default_ws = self.config_data["pythonsrcdir"] else: self.default_ws = os.path.join(self.wf_dir, 'warrior', 'Warriorspace') self.templates_dir = os.path.join(templates_dir, 'execution') self.jira_settings_file = os.path.join(self.wf_dir, 'warrior', 'Tools', 'jira', 'jira_config.xml') self.execution_settings_json = os.path.join(templates_dir, 'execution', 'execution_settings.json') self.config_json = os.path.join(self.katana_dir, 'config.json') def index(self, request): """ Index page for exeution app """ execution_settings_dict = update_jira_proj_list( self.jira_settings_file, self.execution_settings_json) #json.loads(open(self.execution_settings_json).read()) start_dir = self.default_ws if execution_settings_dict['defaults']['start_dir'] == 'default' \ else execution_settings_dict['defaults']['start_dir'] execution_settings_dict['defaults']['start_dir'] = start_dir index_template = os.path.join(self.templates_dir, 'execution.html') return render(request, index_template, execution_settings_dict) def get_results_index(self, request): """ Render the results index html to the client """ fname = 'live_html_results' path = data_live_dir fpath = file_utils.get_new_filepath(fname, path, '.html') html_file = open(fpath, 'w') html_file.write('<div data-currentTable="1"> </div> ') html_file.close() result_setting = {'fpath': fpath} results_template = os.path.join(self.templates_dir, 'execution_results.html') return render(request, results_template, result_setting) def get_html_results(self, request): """ Update the html results by reading the live html results file sent in the request """ data_dict = json.loads(request.GET.get('data')) fpath = data_dict['liveHtmlFpath'] with open(fpath) as htmlfile: data = htmlfile.readlines() return HttpResponse(data) def delete_live_html_file(self, request): """ delete the live html file created """ status = 'success' try: data_dict = json.loads(request.GET.get('data')) fpath = data_dict['liveHtmlFpath'] os.remove(fpath) except Exception as err: status = 'failure' return HttpResponse(status) def get_logfile_contents(self, request): """ Update the html results by reading the live html results file sent in the request """ data_dict = json.loads(request.GET.get('data')) logpath = data_dict['logpath'] logtype = data_dict['logtype'] op_data = {} logfile_name = logpath.split(os.sep)[-1] if str(logtype.lower()) == 'defects': contents = json.loads(open(logpath).read()) if str(logtype.lower()) == 'console_logs': contents = open(logpath).read() contents = contents.replace('\n', '<br>') op_data['logfile_name'] = logfile_name op_data['contents'] = contents return JsonResponse(op_data) def cleanup_data_live_dir(self, request): """ Update the html results by reading the live html results file sent in the request """ status = 'success' try: for item in os.listdir(data_live_dir): path = os.path.join(data_live_dir, item) if os.path.isfile( path) and not path.endswith('donotdeletethisfile.txt'): os.remove(path) elif os.path.isdir(path): shutil.rmtree(path, 'ignore_errors') except Exception as err: print("error ceaning up dir {0}".format(data_live_dir)) print(err) status = 'failure' return HttpResponse(status) def get_ws(self, request): """ return the dir tree json for warriorspace """ data_dict = json.loads(request.GET.get('data')) ws_dir = data_dict['start_dir'] layout = self.nav.get_dir_tree_json(ws_dir) return JsonResponse(layout) def execute_warrior(self, request): """ Execute warrior command and send console logs to the client in a streaming fashion. """ data_dict = json.loads(request.GET.get('data')) execution_file_list = data_dict['execution_file_list'] cmd_string = data_dict['cmd_string'] live_html_res_file = data_dict['liveHtmlFpath'] config_json_dict = json.loads(open(self.config_json).read()) python_path = config_json_dict['pythonpath'] katana_dir = os.path.dirname(katana.native.__path__[0]) config_json = os.path.join(katana_dir, 'config.json') config_json_dict = json.loads(open(config_json).read()) pythonpaths = [] for key in config_json_dict.keys(): if key.startswith('userreposdir'): repo = config_json_dict[key].split('/') repo = "/".join(repo[:-1]) pythonpaths.append(repo) pythonpath = ':'.join(pythonpaths) cmd_string = cmd_string + ' -pythonpath {0}'.format(pythonpath) return StreamingHttpResponse( stream_warrior_output(self.warrior, cmd_string, execution_file_list, live_html_res_file, python_path))
def read_config_file_data(): nav_obj = Navigator() config_file_path = join_path(nav_obj.get_katana_dir(), "config.json") data = read_json_data(config_file_path) return data
WARRIORDIR = dirname(dirname(abspath(__file__))) sys.path.append(WARRIORDIR) try: import katana os.environ["pipmode"] = "False" except: raise from katana.primary_process import __appmanager__, install_custom_app, install_default_apps, \ remove_app_from_settings_custom, remove_appurl_from_urls_custom, remove_cust_app_source, \ update_fname, update_logo, update_panel_color, create_log from katana.utils.navigator_util import Navigator from katana.utils.json_utils import read_json_data from katana.utils.directory_traversal_utils import join_path nav_obj = Navigator() BASE_DIR = nav_obj.get_katana_dir() wapps_dir_path = BASE_DIR + "/wapps/" wapps_dir = BASE_DIR + "/wapps" native_dir = BASE_DIR + "/native" settings_file = BASE_DIR + "/wui/settings.py" if os.environ["pipmode"] == "True": virtual_env = os.getenv('VIRTUAL_ENV') if virtual_env: app_config_file = virtual_env + os.sep + "katana_configs" + os.sep + "app_config.json" elif os.path.exists(site.getuserbase() + os.sep + "katana_configs"): app_config_file = site.getuserbase( ) + os.sep + "katana_configs" + os.sep + "app_config.json" elif os.path.exists("/usr/local/katana_configs"): app_config_file = "/usr/local/katana_configs/app_config.json"
import shutil import zipfile from django.http import JsonResponse from django.shortcuts import render from django.views import View import xml.etree.cElementTree as ET from katana.native.wapp_management.wapp_management_utils.app_validator import AppValidator from katana.native.wapp_management.wapp_management_utils.installer import Installer from katana.native.wapp_management.wapp_management_utils.uninstaller import Uninstaller from katana.utils.directory_traversal_utils import join_path, get_sub_files, get_parent_directory, \ create_dir, get_dir_from_path from katana.utils.file_utils import copy_dir from katana.utils.navigator_util import Navigator from katana.utils.string_utils import get_repository_name from katana.wui.core.core_utils.app_info_class import AppInformation nav_obj = Navigator() class WappManagementView(View): template = 'wapp_management/wapp_management.html' dot_data_directory = join_path(nav_obj.get_katana_dir(), "katana.native", "wapp_management", ".data") def get(self, request): """ Get Request Method """ files = get_sub_files(WappManagementView.dot_data_directory) preferences = [] for subfile in files:
class AppValidator: def __init__(self, filepath): """ :param filepath: Path to the root directory of the app being installed self.navigator: Navigator() onject self.app_name: Name of the actual app directory. self.path_to_app: Path to the actual app directory self.wf_config_file: Path to the app's wf_config file self.urls_inclusions: List of ursl that need o be included in main urls.py self.mandatory_fields: Mandatory fields necessary in wf_config.json self.wapp_data: All data in the wf_config.json file self.django_based: True indicates that this app uses new Katana API. False indicates that app still uses the old Katana API """ self.navigator = Navigator() self.app_name = get_sub_folders( join_path(filepath, "warriorframework_py3", "katana", "katana.wapps"))[0] self.path_to_app = join_path(filepath, "warriorframework_py3", "katana", "katana.wapps", self.app_name) self.wf_config_file = join_path(self.path_to_app, "wf_config.json") self.urls_inclusions = [] self.mandatory_fields = [ "app", "version", "warrior-compatibility", "warrior-incompatibility" ] self.wapp_data = read_json_data(self.wf_config_file) self.django_based = False if "pure_django" not in self.wapp_data or not self.wapp_data[ "pure_django"] else True def is_valid(self): output = {"status": True, "message": ""} if os.path.exists(self.wf_config_file): if self.wapp_data is not None: for field in self.mandatory_fields: if output["status"] and field not in self.wapp_data: output["status"] = False output[ "message"] = "wf_config.json is not in the correct format." print("-- An Error Occurred -- {0}".format( output["message"])) if output["status"]: output = self.__verify_app_details(self.wapp_data["app"]) # validate version compatibility if output["status"]: output = self.__is_compatible(self.wapp_data) # validate databases if any if output["status"] and "database" in self.wapp_data: if isinstance(self.wapp_data["database"], list): for db_details in self.wapp_data["database"]: if output["status"]: output = self.__verify_db_details(db_details) else: output = self.__verify_db_details( self.wapp_data["database"]) else: output["status"] = False output[ "message"] = "wf_config.json is not in the correct format." print("-- An Error Occurred -- {0}".format(output["message"])) if output["status"]: output = self.__validate_static_directory() else: output["status"] = False output["message"] = "wf_config.json does not exist." print("-- An Error Occurred -- {0}".format(output["message"])) return output def __verify_app_details(self, app_details): output = {"status": True, "message": ""} if "name" not in app_details or "url" not in app_details or "include" not in app_details: print( "-- An Error Occurred -- wf_config.json file is not in the correct format." ) output["status"] = False else: self.urls_inclusions.append("url(r'^" + app_details["url"] + "', include('" + app_details["include"] + "')),") path_dir = app_details["include"].split(".") path_urls = "" for d in range(2, len(path_dir)): path_urls += os.sep + path_dir[d] path_urls = path_urls.strip(os.sep) path_urls += ".py" path_to_urls_abs = join_path(self.path_to_app, path_urls) if not os.path.isfile(path_to_urls_abs): output["status"] = False output["message"] = "Package {0} does not exist.".format( app_details["include"]) print("-- An Error Occurred -- {0}".format(output["message"])) return output def __is_compatible(self, data): output = {"status": True, "message": ""} warrior_version = self.navigator.get_wf_version() all_warrior_versions = self.navigator.get_all_wf_versions() allowed, bounds, err_alwd = get_version_list( data[self.mandatory_fields[2]], all_warrior_versions) disallowed, excluded_bounds, err_disalwd = get_version_list( data[self.mandatory_fields[3]], all_warrior_versions) in_allowed = check_against_version_list(warrior_version, allowed, bounds) in_disallowed = check_against_version_list(warrior_version, disallowed, excluded_bounds) if not in_allowed: output["status"] = False if not err_alwd: output["message"] = "-- An Error Occurred -- {0} (Version: {1}) incompatible with " \ "the current WarriorFramework (Version: {2})."\ .format(self.app_name, data["version"], warrior_version) else: output[ "message"] = "-- An Error Occurred -- Compatible versions could not be verified." elif in_disallowed: output["status"] = False output["message"] = "-- An Error Occurred -- {0} (Version: {1}) incompatible with " \ "the current WarriorFramework (Version: {2})." \ .format(self.app_name, data["version"], warrior_version) elif not in_disallowed and err_disalwd: output["status"] = False output[ "message"] = "-- An Error Occurred -- Incompatible versions could not be verified." return output def __verify_db_details(self, db_details): output = {"status": True, "message": ""} for key in db_details: if not key.startswith(self.app_name): output["status"] = False output[ "message"] = "wf_config.json file is not formatted correctly" print("-- An Error Occurred -- {0}".format(output["message"])) return output def __validate_static_directory(self): output = {"status": True, "message": ""} if os.path.isdir(join_path(self.path_to_app, "static")): subs = get_sub_dirs_and_files(join_path(self.path_to_app, "static")) if len(subs["files"]) > 0: output["status"] = False output["message"] = "static directory does not follow the required " \ "directory structure." print("-- An Error Occurred -- {0}".format(output["message"])) else: if not os.path.isdir( join_path(self.path_to_app, "static", self.app_name)): output["status"] = False output["message"] = "static directory does not follow the required " \ "directory structure." print("-- An Error Occurred -- {0}".format( output["message"])) else: subs_files = get_paths_of_subfiles( join_path(self.path_to_app, "static", self.app_name), re.compile("\.js$")) path_to_js = join_path(self.path_to_app, "static", self.app_name, "js") if not self.django_based: # Validates JS structure only if app uses old Katana API list_of_files = ", ".join([ x for x in subs_files if not x.startswith(path_to_js) ]) if list_of_files: output["status"] = False output["message"] = "A .js file cannot be outside the 'js' folder. " \ "List of files in non-compliance: {0}".format(list_of_files) print("-- An Error Occurred -- {0}".format( output["message"])) return output
class VerifyFileContents: def __init__(self, data_file, ref_data_file): self.data_file = data_file self.data = read_xml_get_json(data_file) self.ref_data_file = ref_data_file self.nav_obj = Navigator() self.dependency_template = join_path(self.nav_obj.get_katana_dir(), "native", "settings", "static", "settings", "base_templates", "empty.xml") self.ref_data = self._get_ref_data() self.dependency_dict = self.__get_dependency_dict() def _get_ref_data(self): data = read_xml_get_json(self.ref_data_file) dependency_data = read_xml_get_json(self.dependency_template) data["data"]["warhorn"] = copy.deepcopy( dependency_data["data"]["warhorn"]) return data def __get_dependency_dict(self): output = {} for el in self.ref_data["data"]["warhorn"]["dependency"]: output[el["@name"]] = { "version": el["@version"], "description": el["@description"] } return output def verify_file(self): output = {"status": True, "message": ""} if self.data is None: output["status"] = False output[ "message"] = "An error occurred while trying to read {0}".format( self.data_file) elif "data" not in self.data: output["status"] = False output[ "message"] = "{0} does not seem to be in correct format".format( self.data_file) if output["status"]: self.verify_dependency_json() self.verify_tools_data() self.verify_drivers_json() self.verify_warriorspace_data() return output def verify_dependency_json(self, ): flag = True if "warhorn" not in self.data["data"]: self.data["data"]["warhorn"] = copy.deepcopy( self.ref_data["data"]["warhorn"]) flag = False if "dependency" not in self.data["data"]["warhorn"]: self.data["data"]["warhorn"]["dependency"] = copy.deepcopy( self.ref_data["data"]["warhorn"]["dependency"]) flag = False if not isinstance(self.data["data"]["warhorn"]["dependency"], list): self.data["data"]["warhorn"]["dependency"] = [ self.data["data"]["warhorn"]["dependency"] ] if flag: data = copy.deepcopy(self.data["data"]["warhorn"]["dependency"]) extra_dependencies = set() for i in range(0, len(data)): for key, value in data[i].items(): if key == "@name": if value in self.dependency_dict: data[i]["version"] = self.dependency_dict[value][ "version"] data[i]["description"] = self.dependency_dict[ value]["description"] try: module_name = __import__(value) some_var = module_name.__version__ except ImportError: data[i]["installed"] = False data[i]["matched"] = False except Exception as e: print("-- An Exception Occurred -- while getting details about " \ "{0}: {1}".format(value, e)) data[i]["installed"] = False data[i]["matched"] = False else: data[i]["installed"] = some_var if self.dependency_dict[value] == some_var: data[i]["matched"] = True elif self.dependency_dict[value] > some_var: data[i]["matched"] = "lower" else: data[i]["matched"] = "higher" break else: extra_dependencies.add(i) dependency_list = [] for i in range(0, len(data)): if i not in extra_dependencies: dependency_list.append(copy.deepcopy(data[i])) self.data["data"]["warhorn"]["dependency"] = copy.deepcopy( dependency_list) def verify_tools_data(self): if "tools" not in self.data["data"]: self.data["data"]["tools"] = copy.deepcopy( self.ref_data["data"]["tools"]) else: for key, value in self.ref_data["data"]["tools"].items(): if key not in self.data["data"]["tools"]: self.data["data"]["tools"][key] = self.ref_data["data"][ "tools"][key] url = self.data["data"]["tools"]["@url"] if url != "": self.data["data"]["tools"]["name"] = get_repository_name( url=url) self.data["data"]["tools"][ "available"] = check_url_is_a_valid_repo(url=url) else: self.data["data"]["tools"]["available"] = False def verify_drivers_json(self): flag = True if "drivers" not in self.data["data"]: self.data["data"]["drivers"] = copy.deepcopy( self.ref_data["data"]["drivers"]) flag = False if "repository" not in self.data["data"]["drivers"]: self.data["data"]["drivers"]["repository"] = copy.deepcopy( self.ref_data["data"]["drivers"]["repository"]) flag = False if not isinstance(self.data["data"]["drivers"]["repository"], list): self.data["data"]["drivers"]["repository"] = [ self.data["data"]["drivers"]["repository"] ] if flag: for i in range(0, len(self.data["data"]["drivers"]["repository"])): for key, value in self.ref_data["data"]["drivers"][ "repository"].items(): if key not in self.data["data"]["drivers"]["repository"][ i]: if key != "driver": self.data["data"]["drivers"]["repository"][i][ key] = self.ref_data["data"]["drivers"][ "repository"]["key"] else: self.data["data"]["drivers"]["repository"][i][ key] = copy.deepcopy( self.ref_data["data"]["drivers"] ["repository"][key]) if not isinstance( self.data["data"]["drivers"]["repository"] [i][key], list): self.data["data"]["drivers"]["repository"][i][ key] = [ self.data["data"]["drivers"] ["repository"][i][key] ] url = self.data["data"]["drivers"]["repository"][i]["@url"] if url != "": self.data["data"]["drivers"]["repository"][i][ "name"] = get_repository_name(url=url) available = check_url_is_a_valid_repo(url=url) self.data["data"]["drivers"]["repository"][i][ "available"] = available if available: drivers_data = [] drivers_index = set() temp_directory = os.path.join( self.nav_obj.get_katana_dir(), "katana.wapps", "assembler", ".data") kw_repo_obj = KwRepositoryDetails(url, temp_directory) drivers = set(kw_repo_obj.get_pd_names()) if not isinstance( self.data["data"]["drivers"]["repository"][i] ["driver"], list): self.data["data"]["drivers"]["repository"][i][ "driver"] = [ self.data["data"]["drivers"]["repository"] [i]["driver"] ] for j in range( 0, len(self.data["data"]["drivers"]["repository"] [i]["driver"])): if "@name" not in self.data["data"]["drivers"][ "repository"][i]["driver"][j]: self.data["data"]["drivers"]["repository"][i][ "driver"][j]["@name"] = self.ref_data[ "data"]["drivers"]["repository"][ "driver"]["@name"] else: if self.data["data"]["drivers"]["repository"][ i]["driver"][j]["@name"] in drivers: drivers.remove(self.data["data"]["drivers"] ["repository"][i]["driver"] [j]["@name"]) else: drivers_index.add(j) if "@clone" not in self.data["data"]["drivers"][ "repository"][i]["driver"][j]: self.data["data"]["drivers"]["repository"][i][ "driver"][j]["@clone"] = self.ref_data[ "data"]["drivers"]["repository"][ "driver"]["@clone"] for j in range( 0, len(self.data["data"]["drivers"]["repository"] [i]["driver"])): if j not in drivers_index: drivers_data.append( copy.deepcopy( self.data["data"]["drivers"] ["repository"][i]["driver"][j])) self.data["data"]["drivers"]["repository"][i][ "driver"] = copy.deepcopy(drivers_data) for driver_name in drivers: self.data["data"]["drivers"]["repository"][i][ "driver"].append({ "@name": driver_name, "@clone": "no" }) if os.path.isdir(kw_repo_obj.repo_directory): delete_dir(kw_repo_obj.repo_directory) else: self.data["data"]["drivers"]["repository"][i][ "available"] = False def verify_warriorspace_data(self): flag = True if "warriorspace" not in self.data["data"]: flag = False self.data["data"]["warriorspace"] = copy.deepcopy( self.ref_data["data"]["warriorspace"]) if "repository" not in self.data["data"]["warriorspace"]: flag = False self.data["data"]["warriorspace"]["repository"] = copy.copy( self.ref_data["data"]["warriorspace"]["repository"]) if not isinstance(self.data["data"]["warriorspace"]["repository"], list): self.data["data"]["warriorspace"]["repository"] = [ self.data["data"]["warriorspace"]["repository"] ] if flag: for i in range( 0, len(self.data["data"]["warriorspace"]["repository"])): for key, value in self.ref_data["data"]["warriorspace"][ "repository"].items(): if key not in self.data["data"]["warriorspace"][ "repository"][i]: self.data["data"]["warriorspace"]["repository"][i][ key] = self.ref_data["data"]["warriorspace"][ "repository"][key] url = self.data["data"]["warriorspace"]["repository"][i][ "@url"] if url != "": self.data["data"]["warriorspace"]["repository"][i][ "name"] = get_repository_name(url=url) self.data["data"]["warriorspace"]["repository"][i][ "available"] = check_url_is_a_valid_repo(url=url) else: self.data["data"]["warriorspace"]["repository"][i][ "available"] = False
os.environ["pipmode"] = "True" # except ModuleNotFoundError as error: except: WARRIORDIR = dirname(dirname(abspath(__file__))) sys.path.append(WARRIORDIR) try: import katana os.environ["pipmode"] = "False" except: raise from katana.utils.navigator_util import Navigator nav_obj = Navigator() BASE_DIR = nav_obj.get_katana_dir() appmanage_py = os.path.join(BASE_DIR, "appmanage.py") data = requests.get('https://pypi.python.org/pypi/katanaframework/json') data = data.json() ord_dict = OrderedDict() ord_dict = data['releases'].keys() versn_list = list(ord_dict) if (os.path.exists(os.path.join(BASE_DIR, 'wapps')) or os.path.exists(os.path.join(BASE_DIR, 'native'))): print( colored( "Please manually backup and then delete the following dirs before performing the upgrade operation", "red"))
from django.shortcuts import render from django.views import View import collections import json import os import xmltodict from django.http import JsonResponse from django.template.loader import render_to_string from katana.utils.directory_traversal_utils import join_path, get_parent_dir_path, get_dir_from_path from katana.utils.json_utils import read_json_data, read_xml_get_json from katana.utils.navigator_util import Navigator from katana.wapps.projects.project_utils.defaults import on_errors, impacts, contexts, runmodes, \ executiontypes, runtypes from katana.wapps.projects.project_utils.verify_project_file import VerifyProjectFile navigator = Navigator() CONFIG_FILE = join_path(navigator.get_katana_dir(), "config.json") APP_DIR = join_path(navigator.get_katana_dir(), "wapps", "projects") STATIC_DIR = join_path(APP_DIR, "static", "projects") TEMPLATE = join_path(STATIC_DIR, "base_templates", "Project_Template.xml") DROPDOWN_DEFAULTS = read_json_data( join_path(STATIC_DIR, "base_templates", "dropdowns_data.json")) class projectsView(View): def get(self, request): """ Get Request Method """ return render(request, 'projects/projects.html')
limitations under the License. """ # -*- coding: utf-8 -*- import os from django.shortcuts import render from django.http import JsonResponse, HttpResponse from katana.native.settings.settings import Settings from katana.utils.navigator_util import Navigator from katana.utils.json_utils import read_json_data import ast import json nav_obj = Navigator() REF_FILE = os.path.join( nav_obj.get_katana_dir(), "katana.native", "assembler", "static", "assembler", "base_templates", "empty.xml", ) config_json_path = os.path.join(nav_obj.get_katana_dir(), "config.json") controls = Settings() def index(request):
def validate_config_json(json_data, warrior_dir): """ This function validates the config.json file and returns an ordered dictionary :param json_data: original unordered contents of config.json :param warrior_dir: path to warrior directory :return: Ordered Dictionary containing validated config.json data """ userobj = Navigator() if json_data["userreposdir"] == "": default_userrepo = "" else: default_userrepo = json_data["userreposdir"] ordered_json = OrderedDict() if "engineer" not in json_data: ordered_json["engineer"] = "" else: ordered_json["engineer"] = "" for key in json_data: pattern = r'userreposdir*[0-9a-zA-Z]*' result = re.match(pattern, str(key)) if result: path = json_data[key] reponame = key if reponame: if reponame == "userreposdir": if reponame not in json_data: ordered_json[reponame] = "" else: ordered_json[reponame] = warrior_dir[:-1] else: ordered_json[reponame] = json_data[reponame] ordered_json[reponame] = path else: ordered_json[reponame] = "" if os.environ["pipmode"] == 'True': ordered_json["pythonsrcdir"] = warrior_dir else: ordered_json["pythonsrcdir"] = warrior_dir[:-1] \ if "pythonsrcdir" not in json_data or json_data["pythonsrcdir"] == "" \ else json_data["pythonsrcdir"] warrior_dir = ordered_json["pythonsrcdir"] ref = OrderedDict([ ("xmldir", "Testcases"), ('testsuitedir', 'Suites'), ('projdir', 'Projects'), ('idfdir', 'Data'), ('testdata', 'Config_files'), ('testwrapper', 'wrapper_files'), ]) ref.update(ordered_json) if os.environ["pipmode"] == 'True': if warrior_dir == "": for key, value in list(ref.items()): ordered_json[key] = "" else: for key, value in list(ref.items()): ordered_json[key] = json_data[key] ordered_json['userreposdir'] = default_userrepo else: for key, value in list(ref.items()): if key not in json_data or json_data[key] == "": if key == "engineer" and value == "": pass else: path = get_abs_path(join_path("Warriorspace", value), warrior_dir) if path is not None: ordered_json[key] = path else: ordered_json[key] = "" print( "-- An Error Occurred -- Path to {0} directory could not be located" .format(value)) else: ordered_json[key] = json_data[key] if "pythonpath" not in json_data: ordered_json["pythonpath"] = "" else: ordered_json["pythonpath"] = json_data["pythonpath"] return ordered_json
# -*- coding: utf-8 -*- from __future__ import unicode_literals import json import os import subprocess import xmltodict from django.http import JsonResponse from django.shortcuts import render from django.views import View from katana.wapps.assembler.assembler_utils.repository_details import KwRepositoryDetails from katana.wapps.assembler.assembler_utils.verify_file_contents import VerifyFileContents from katana.utils.directory_traversal_utils import delete_dir from katana.utils.git_utils import get_repository_name, check_url_is_a_valid_repo from katana.utils.navigator_util import Navigator nav_obj = Navigator() REF_FILE = os.path.join(nav_obj.get_katana_dir(), "wapps", "assembler", "static", "assembler", "base_templates", "empty.xml") class AssemblerView(View): def get(self, request): return render(request, 'assembler/assembler.html') class ConfigurationFileOps(View): def post(self, request): template = request.POST.get('filepath') filename = "Untitled" final_data = {} if template == "false":