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 __add_app_directory(self):
temp_app_path = join_path(self.app_directory, self.app_name)
if os.path.exists(temp_app_path):
wf_config_extng = os.path.join(temp_app_path, "wf_config.json")
wf_config_new = os.path.join(self.path_to_app, "wf_config.json")
data_extng = read_json_data(wf_config_extng)
data_new = read_json_data(wf_config_new)
existing_version = data_extng["version"]
new_version = data_new["version"]
if existing_version == new_version:
app_status = "Reinstall"
elif existing_version < new_version:
app_status = "Upgrade"
else:
app_status = "Downgrade"
output = "Prompt"
if app_status == "Reinstall":
message = "{0} app with the same version {1} already exists. Do you want to {2}?".format(
self.app_name, new_version, app_status)
else:
message = "{0} app with the version {1} already exists. Do you want to {2} to {3}?".format(
self.app_name, existing_version, app_status, new_version)
print(message)
self.message += message
else:
output = copy_dir(self.path_to_app, temp_app_path)
self.delete_app_dir.append(self.path_to_app)
return output
def check_app_version(existing_app, new_app):
"""This function will compare the versions of the existing app and the new app"""
wf_config_extng = os.path.join(existing_app, "wf_config.json")
wf_config_new = os.path.join(new_app, "wf_config.json")
data_extng = read_json_data(wf_config_extng)
data_new = read_json_data(wf_config_new)
existing_version = data_extng["version"]
new_version = data_new["version"]
if existing_version == new_version:
message = "Reinstall"
elif existing_version < new_version:
message = "Upgrade"
else:
message = "Downgrade"
return existing_version, new_version, message
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 configure_urls_file_custom(app, category):
"""this function configure the url for custom apps"""
app_main_folder = os.path.join(BASE_DIR, category)
app_folder = os.path.join(app_main_folder, app)
wf_config_file = os.path.join(app_folder, "wf_config.json")
data = read_json_data(wf_config_file)
if data["app"]["url"].startswith("/"):
app_url = data["app"]["url"][1:]
else:
app_url = data["app"]["url"]
with open(urls_file, "r") as f:
url_file_content = f.readlines()
with open(urls_file, "w") as f:
if " url(r'^"+app_url+"', include('katana.wapps."+app+".urls')),\n" \
not in url_file_content:
for line in url_file_content:
if line == " url(r'^$', RedirectView.as_view(url='/katana/')),\n":
f.writelines(line)
f.writelines(" url(r'^" + app_url +
"', include('katana.wapps." + app +
".urls')),\n")
else:
f.writelines(line)
else:
for line in url_file_content:
f.writelines(line)
def index(request):
"""
Read an xml file and return the editor page with xml content in it
"""
config = read_json_data(JSON_CONFIG)
wdfdir = config["idfdir"]
# Check to open new/existing file
if request.method == "POST":
data = request.POST
if os.path.isfile(data["path"]):
xml_data = xmltodict.parse(open(data["path"]).read())
# Generate the filepath to use on webpage
filepath = data["path"]
filepath = filepath.replace(wdfdir, "")
filepath = filepath[1:] if filepath.startswith(os.sep) else filepath
# xml should only has 1 root
root = list(xml_data.keys())[0]
data, ref_dict = process_xml(xml_data)
return render(request, 'wdf_edit/index.html',
{"data": xml_data[root], "data_read": ref_dict, "filepath": filepath,
"desc":xml_data[root].get("description", "")})
else:
return render(request, 'wdf_edit/failure.html')
else:
sample_data = {"system": [{"@name": "Example system", "Example key": "Example value"}]}
ref_dict = copy.deepcopy(sample_data)
return render(request, 'wdf_edit/index.html', {"data": sample_data, "data_read": ref_dict, "filepath": ""})
def __edit_urls_py(self):
checker = "RedirectView.as_view(url='/katana/')"
data = read_json_data(self.wf_config_file)
if data["app"]["url"].startswith("/"):
app_url = data["app"]["url"][1:]
else:
app_url = data["app"]["url"]
self.urls_inclusions.append("url(r'^" + app_url + "', include('" +
data["app"]["include"] + "')),")
data = readlines_from_file(self.urls_file)
self.urls_backup = data
index = -1
for i in range(0, len(data)):
if checker in data[i]:
index = i + 1
break
white_space = data[index].split("url")
for i in range(0, len(self.urls_inclusions)):
self.urls_inclusions[
i] = white_space[0] + self.urls_inclusions[i] + "\n"
u_data = data[:index]
u_data.extend(self.urls_inclusions)
u_data.extend(data[index:])
urls_data = ""
for line in u_data:
urls_data += line
output = write_to_file(self.urls_file, urls_data)
return output
def get_list_of_suites(request):
"""
Returns a list of suites
"""
config = read_json_data(CONFIG_FILE)
return JsonResponse(
{"data": navigator.get_dir_tree_json(config["projdir"])})
def get(self, request):
user_data = self.get_user_data()
fname_file = os.path.join(BASE_DIR, "wui/core/static/core/framework_name.json")
data = read_json_data(fname_file)
framename = data["fr_name"]
print(AppInformation.information.apps)
return render(request, self.index_page, {"apps": AppInformation.information.apps, "userData": user_data, "frame_name": framename})
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_file(request):
"""
Reads a file, validates it, computes the HTML and returns it as a JSON response
"""
try:
file_path = request.GET.get('path',)
if file_path == "false":
file_path = TEMPLATE
vcf_obj = VerifySuiteFile(TEMPLATE, file_path)
output, data = vcf_obj.verify_file()
if output["status"]:
mid_req = (len(data["TestSuite"]["Requirements"]["Requirement"]) + 1) / 2
if file_path == TEMPLATE:
output["filepath"] = read_json_data(CONFIG_FILE)["testsuitedir"]
else:
output["filepath"] = get_parent_dir_path(file_path)
output["filename"] = os.path.splitext(get_dir_from_path(file_path))[0]
output["html_data"] = render_to_string('suites/display_suite.html',
{"data": data, "mid_req": mid_req,
"defaults": DROPDOWN_DEFAULTS})
return JsonResponse(output)
else:
JsonResponse({"status": output["status"], "message": output["message"]})
except Exception as e:
return JsonResponse({"status": 0,"message":"Exception opening the file"})
def update_fname(fname):
"""this function update the framework name """
fname_file = os.path.join(BASE_DIR,
"wui/core/static/core/framework_name.json")
data = read_json_data(fname_file)
data["fr_name"] = fname
with open(fname_file, "w") as f:
f.write(json.dumps(data, indent=4))
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 general_setting_handler(self, request):
json_file = self.navigator.get_katana_dir() + os.sep + 'config.json'
if os.path.exists(self.navigator.get_warrior_dir() + os.sep + 'Tools' +
os.sep + 'w_settings.xml'):
w_settings = self.navigator.get_warrior_dir(
) + os.sep + 'Tools' + os.sep + 'w_settings.xml'
else:
w_settings = self.navigator.get_katana_dir(
) + os.sep + 'native' + os.sep + 'settings' + os.sep + 'Tools' + os.sep + 'w_settings.xml'
elem_file = xml_controler.parse(w_settings)
elem_file = elem_file.getroot()
elem = self.search_by_name('def_dir', elem_file)
def_dir_string = xml_controler.tostring(elem)
def_dir_xml_obj = elem
if request.method == 'POST':
w_settings_data = {
'Setting': {
'Logsdir': '',
'Resultsdir': '',
'@name': ''
}
}
returned_json = json.loads(request.POST.get('data'))
for k, v in list(w_settings_data['Setting'].items()):
w_settings_data['Setting'][k] = returned_json[0][k]
del returned_json[0][k]
elem_file.remove(def_dir_xml_obj)
val = xmltodict.unparse(w_settings_data, pretty=True)
elem_file.insert(0, xml_controler.fromstring(val))
with open(w_settings, 'wb') as f:
f.write(xml_controler.tostring(elem_file))
with open(json_file, 'w') as f:
f.write(
json.dumps(returned_json[0],
indent=4,
separators=(',', ': ')))
else:
with open(json_file, 'r') as f:
json_data = json.load(f)
if os.environ["pipmode"] == 'True':
pythonsrcdir = read_json_data(json_file)['pythonsrcdir']
else:
pythonsrcdir = self.navigator.get_warrior_dir()
data = {
'fromXml':
xmltodict.parse(def_dir_string).get('Setting'),
'fromJson':
validate_config_json(json_data,
self.navigator.get_warrior_dir())
}
return data
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 get_engineer_name(self):
"""
This function returns the full name (if given in the user_profile.json) of the user.
:return:
"""
user_profile = join_path(self.get_katana_dir(), "user_profile.json")
profile_data = read_json_data(user_profile)
name = ""
if profile_data is not None:
name = (profile_data["firstName"] + " " +
profile_data["lastName"]).strip()
return name
def get_file(request):
"""
Reads a case file and returns it's contents in JSOn format
"""
try:
file_path = request.GET.get('path')
if file_path == "false":
file_path = TEMPLATE
vcf_obj = VerifyCaseFile(TEMPLATE, file_path)
output, data = vcf_obj.verify_file()
if output["status"]:
mid_req = (len(data["Testcase"]["Requirements"]["Requirement"]) +
1) / 2
repo_dirs = navigator.get_user_repos_dir()
repo_dict = {}
for repo in repo_dirs:
repo_dict[repo] = {}
repo_path = repo_dirs[str(repo)]
da_obj = GetDriversActions(repo_path)
if file_path == TEMPLATE:
output["filepath"] = read_json_data(CONFIG_FILE)["xmldir"]
else:
output["filepath"] = get_parent_dir_path(file_path)
output["filename"] = os.path.splitext(
get_dir_from_path(file_path))[0]
output["user_repos"] = repo_dirs
repo_dict[repo] = da_obj.get_all_actions()
output["drivers"] = repo_dict
output["html_data"] = render_to_string(
'cases/display_case.html', {
"data": data,
"mid_req": mid_req,
"defaults": DROPDOWN_DEFAULTS,
"user_repos": repo_dirs
})
return JsonResponse(output)
else:
JsonResponse({
"status": output["status"],
"message": output["message"]
})
except Exception as e:
return JsonResponse({
"status": 0,
"message": "Exception opening the file"
})
def set_apps(self, data):
""" call this to build Apps array and make app objects """
self.get_config_paths(data)
for url in self.paths:
json_data = read_json_data(url)
if json_data is not None:
app_path = get_parent_directory(url)
app = App(json_data, app_path, data["base_directory"])
js_urls = get_paths_of_subfiles(
join_path(app_path, app.static_file_dir, "js"),
extension=compile_regex("^\.js$"))
for i in range(0, len(js_urls)):
js_urls[i] = get_relative_path(js_urls[i], app_path)
app.data["js_urls"] = js_urls
self.apps.append(app)
return self.apps
def __init__(self, base_directory, app_path, app_type):
self.app_name = get_dir_from_path(app_path)
self.base_directory = base_directory
self.plugin_dir = join_path(self.base_directory, "warrior", "plugins")
self.app_dir = join_path(self.base_directory, "katana", app_type)
self.settings_file = join_path(self.base_directory, "katana", "wui",
"settings.py")
self.urls_file = join_path(self.base_directory, "katana", "wui",
"urls.py")
self.app_path = get_abs_path(self.app_name, self.app_dir)
self.app_type = app_type
self.config_file = join_path(self.app_path, "wf_config.json")
self.config_file_data = read_json_data(self.config_file)
self.related_plugins = self.__extract_plugin_names()
self.pkg_in_settings = self.__get_setting_file_info()
self.include_urls = self.__get_urls_info()
self.valid_app_types = {"katana.wapps"}
self.cache_dir = create_dir(
join_path(self.base_directory, "katana", ".data", self.app_name))
self.settings_backup = []
self.urls_backup = []
def on_post(request):
"""
Main function that handles a post request with edited xml data
"""
data = json.loads(request.body.decode("utf-8"))
filepath = data.get("filepath", None)
desc = data.get("description", "")
systems = build_xml_dict(data["systems"])
result = {"credentials":OrderedDict()}
if desc:
result["credentials"]["description"] = desc
result["credentials"]["system"] = systems
from xml.dom.minidom import parseString as miniparse
config = read_json_data(JSON_CONFIG)
wdfdir = config["idfdir"]
filepath = os.path.join(wdfdir, filepath)
f = open(filepath, "w")
f.write(miniparse(xmltodict.unparse(result)).toprettyxml())
return render(request, 'wdf_edit/file_list.html')
def remove_appurl_from_urls_custom(app, category):
"""this function reverts urls for custom app"""
app_main_folder = os.path.join(BASE_DIR, category)
app_folder = os.path.join(app_main_folder, app)
wf_config_file = os.path.join(app_folder, "wf_config.json")
data = read_json_data(wf_config_file)
if data["app"]["url"].startswith("/"):
app_url = data["app"]["url"][1:]
else:
app_url = data["app"]["url"]
with open(urls_file, "r") as f:
url_file_content = f.readlines()
if category == "wapps":
with open(urls_file, "r") as f:
url_file_content = f.readlines()
with open(urls_file, "w") as f:
if " url(r'^"+app_url+"', include('katana.wapps."+app+".urls')),\n" \
in url_file_content:
for line in url_file_content:
if line != " url(r'^" + app_url + "', include('katana.wapps." + app + ".urls')),\n":
f.writelines(line)
else:
for line in url_file_content:
f.writelines(line)
elif category == "native":
with open(urls_file, "r") as f:
url_file_content = f.readlines()
with open(urls_file, "w") as f:
if " url(r'^katana/"+app+"/', include('katana.native."+app+".urls')),\n" \
in url_file_content:
for line in url_file_content:
if line != " url(r'^katana/" + app + "/', include('katana.native." + app + ".urls')),\n":
f.writelines(line)
else:
for line in url_file_content:
f.writelines(line)
def general_setting_handler(self, request):
json_file = self.navigator.get_katana_dir() + os.sep + 'config.json'
w_settings = self.navigator.get_warrior_dir(
) + 'Tools' + os.sep + 'w_settings.xml'
elem_file = xml_controler.parse(w_settings)
elem_file = elem_file.getroot()
elem = self.search_by_name('def_dir', elem_file)
def_dir_string = xml_controler.tostring(elem)
def_dir_xml_obj = elem
if request.method == 'POST':
w_settings_data = {
'Setting': {
'Logsdir': '',
'Resultsdir': '',
'@name': ''
}
}
returned_json = json.loads(request.POST.get('data'))
if os.environ["pipmode"] == 'True':
if os.path.isdir(returned_json[0]['pythonsrcdir']):
if os.path.split(returned_json[0]['pythonsrcdir']
)[-1] == 'Warriorspace' or os.path.split(
returned_json[0]['pythonsrcdir']
)[-2] == 'Warriorspace':
returned_json[0]['pythonsrcdir'] = returned_json[0][
'pythonsrcdir']
else:
try:
os.mkdir(returned_json[0]['pythonsrcdir'] +
'/Warriorspace')
returned_json[0]['pythonsrcdir'] = returned_json[
0]['pythonsrcdir'] + '/Warriorspace'
except FileExistsError:
returned_json[0]['pythonsrcdir'] = returned_json[
0]['pythonsrcdir'] + '/Warriorspace'
else:
return
ref = {
'xmldir': "Testcases",
'testsuitedir': 'Suites',
'projdir': 'Projects',
'idfdir': 'Data',
'testdata': 'Config_files',
'testwrapper': 'wrapper_files'
}
for k, v in list(w_settings_data['Setting'].items()):
w_settings_data['Setting'][k] = returned_json[0][k]
del returned_json[0][k]
if os.environ["pipmode"] == 'True':
for key, value in returned_json[0].items():
if key in ref.keys() and returned_json[0][
'pythonsrcdir'] != "" and returned_json[0][
key] == "":
returned_json[0][key] = returned_json[0][
'pythonsrcdir'] + '/' + ref[key]
if not os.path.isdir(returned_json[0][key]):
os.mkdir(returned_json[0][key])
elem_file.remove(def_dir_xml_obj)
val = xmltodict.unparse(w_settings_data, pretty=True)
elem_file.insert(0, xml_controler.fromstring(val))
with open(w_settings, 'wb') as f:
f.write(xml_controler.tostring(elem_file))
with open(json_file, 'w') as f:
f.write(
json.dumps(returned_json[0],
indent=4,
separators=(',', ': ')))
else:
with open(json_file, 'r') as f:
json_data = json.load(f)
if os.environ["pipmode"] == 'True':
pythonsrcdir = read_json_data(json_file)['pythonsrcdir']
else:
pythonsrcdir = self.navigator.get_warrior_dir()
data = {
'fromXml':
xmltodict.parse(def_dir_string).get('Setting'),
'fromJson':
validate_config_json(json_data,
self.navigator.get_warrior_dir())
}
return data
def read_config_file_data():
nav_obj = Navigator()
data = read_json_data(app_config_json_path)
return data
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')
def get_list_of_suites(request):
"""
Returns a list of suites
"""
config = read_json_data(CONFIG_FILE)
def populate_paths(request):
test_case_folder = "Testcases"
suites_folder = "Suites"
project_folder = "Projects"
data_folder = "Data"
config_folder = "Config_files"
wrapper_folder = "wrapper_files"
returned_json = read_json_data(config_json_path)
list_of_files = os.listdir(returned_json["pythonsrcdir"])
if list_of_files:
if ("warriorspace" not in list_of_files
and "Warriorspace" not in list_of_files
and "Projects" not in list_of_files
and "projects" not in list_of_files
and "Suites" not in list_of_files
and "suites" not in list_of_files
and "Testcases" not in list_of_files
and "testcases" not in list_of_files
and "Data" not in list_of_files and "data" not in list_of_files
and "Wrapper_files" not in list_of_files
and "wrapper_files" not in list_of_files
and "Config_files" not in list_of_files
and "config_files" not in list_of_files):
os.mkdir(returned_json["pythonsrcdir"] + "/Warriorspace")
sub_folders = {
"Testcases": "xmldir",
"Suites": "testsuitedir",
"Projects": "projdir",
"Data": "idfdir",
"Config_files": "testdata",
"wrapper_files": "testwrapper",
}
for folder in [
"Testcases",
"Suites",
"Data",
"wrapper_files",
"Config_files",
"Projects",
]:
os.mkdir(returned_json["pythonsrcdir"] + "/Warriorspace/" +
folder)
returned_json[sub_folders[folder]] = (
returned_json["pythonsrcdir"] + "/Warriorspace/" + folder)
with open(config_json_path, "w") as f:
f.write(json.dumps(returned_json, indent=4))
return HttpResponse(request)
if os.path.isdir(returned_json["pythonsrcdir"]):
if (returned_json["pythonsrcdir"].split("/")[-1].lower()
== "warriorspace"
or returned_json["pythonsrcdir"].split("/")[-2].lower()
== "warriorspace"):
child_dirs = os.listdir(returned_json["pythonsrcdir"])
if "Testcases" in child_dirs:
test_case_folder = "Testcases"
returned_json[
"xmldir"] = returned_json["pythonsrcdir"] + "/Testcases"
elif "testcases" in child_dirs:
test_case_folder = "testcases"
returned_json[
"xmldir"] = returned_json["pythonsrcdir"] + "/testcases"
else:
test_case_folder = "Testcases"
os.mkdir(returned_json["pythonsrcdir"] + "/Testcases")
returned_json[
"xmldir"] = returned_json["pythonsrcdir"] + "/Testcases"
if "Suites" in child_dirs:
suites_folder = "Suites"
returned_json["testsuitedir"] = (
returned_json["pythonsrcdir"] + "/Suites")
elif "suites" in child_dirs:
suites_folder = "suites"
returned_json["testsuitedir"] = (
returned_json["pythonsrcdir"] + "/suites")
else:
suites_folder = "Suites"
os.mkdir(returned_json["pythonsrcdir"] + "/Suites")
returned_json["testsuitedir"] = (
returned_json["pythonsrcdir"] + "/Suites")
if "Projects" in child_dirs:
project_folder = "Projects"
returned_json[
"projdir"] = returned_json["pythonsrcdir"] + "/Projects"
elif "projects" in child_dirs:
project_folder = "projects"
returned_json[
"projdir"] = returned_json["pythonsrcdir"] + "/projects"
else:
project_folder = "Projects"
os.mkdir(returned_json["pythonsrcdir"] + "/Projects")
returned_json[
"projdir"] = returned_json["pythonsrcdir"] + "/Projects"
if "Data" in child_dirs:
data_folder = "Data"
returned_json[
"idfdir"] = returned_json["pythonsrcdir"] + "/Data"
elif "data" in child_dirs:
data_folder = "data"
returned_json[
"idfdir"] = returned_json["pythonsrcdir"] + "/data"
else:
data_folder = "Data"
os.mkdir(returned_json["pythonsrcdir"] + "/Data")
returned_json[
"idfdir"] = returned_json["pythonsrcdir"] + "/Data"
if "Config_files" in child_dirs:
config_folder = "Config_files"
returned_json["testdata"] = (returned_json["pythonsrcdir"] +
"/Config_files")
elif "config_files" in child_dirs:
config_folder = "config_files"
returned_json["testdata"] = (returned_json["pythonsrcdir"] +
"/config_files")
else:
config_folder = "Config_files"
os.mkdir(returned_json["pythonsrcdir"] + "/Config_files")
returned_json["testdata"] = (returned_json["pythonsrcdir"] +
"/Config_files")
if "wrapper_files" in child_dirs:
wrapper_folder = "wrapper_files"
returned_json["testwrapper"] = (returned_json["pythonsrcdir"] +
"/wrapper_files")
elif "Wrapper_files" in child_dirs:
wrapper_folder = "Wrapper_files"
returned_json["testwrapper"] = (returned_json["pythonsrcdir"] +
"/Wrapper_files")
else:
wrapper_folder = "wrapper_files"
os.mkdir(returned_json["pythonsrcdir"] + "/wrapper_files")
returned_json["testwrapper"] = (returned_json["pythonsrcdir"] +
"/wrapper_files")
elif os.listdir(returned_json["pythonsrcdir"]):
base_tree = os.listdir(returned_json["pythonsrcdir"])
for element in base_tree:
if element == "warriorspace":
warrior_path = "/warriorspace"
elif element == "Warriorspace":
warrior_path = "/Warriorspace"
if "warriorspace" in [x.lower() for x in base_tree]:
child_dirs = os.listdir(returned_json["pythonsrcdir"] + "/" +
warrior_path)
if "Testcases" in child_dirs:
test_case_folder = "Testcases"
returned_json["xmldir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/Testcases")
elif "testcases" in child_dirs:
test_case_folder = "testcases"
returned_json["xmldir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/testcases")
else:
test_case_folder = "Testcases"
if not os.path.exists(returned_json["pythonsrcdir"] +
warrior_path + "/Testcases"):
os.mkdir(returned_json["pythonsrcdir"] + warrior_path +
"/Testcases")
returned_json["xmldir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/Testcases")
if "Suites" in child_dirs:
suites_folder = "Suites"
returned_json["testsuitedir"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/Suites")
elif "suites" in child_dirs:
suites_folder = "suites"
returned_json["testsuitedir"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/suites")
else:
suites_folder = "Suites"
if not os.path.exists(returned_json["pythonsrcdir"] +
warrior_path + "/Suites"):
os.mkdir(returned_json["pythonsrcdir"] + warrior_path +
"/Suites")
returned_json["testsuitedir"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/Suites")
if "Projects" in child_dirs:
project_folder = "Projects"
returned_json["projdir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/Projects")
elif "projects" in child_dirs:
project_folder = "projects"
returned_json["projdir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/projects")
else:
project_folder = "Projects"
if not os.path.exists(returned_json["pythonsrcdir"] +
warrior_path + "/Projects"):
os.mkdir(returned_json["pythonsrcdir"] + warrior_path +
"/Projects")
returned_json["projdir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/Projects")
if "Data" in child_dirs:
data_folder = "Data"
returned_json["idfdir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/Data")
elif "data" in child_dirs:
data_folder = "data"
returned_json["idfdir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/data")
else:
data_folder = "Data"
if not os.path.exists(returned_json["pythonsrcdir"] +
warrior_path + "/Data"):
os.mkdir(returned_json["pythonsrcdir"] + warrior_path +
"/Data")
returned_json["idfdir"] = (returned_json["pythonsrcdir"] +
warrior_path + "/Data")
if "Config_files" in child_dirs:
config_folder = "Config_files"
returned_json["testdata"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/Config_files")
elif "config_files" in child_dirs:
config_folder = "config_files"
returned_json["testdata"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/config_files")
else:
config_folder = "Config_files"
if not os.path.exists(returned_json["pythonsrcdir"] +
warrior_path + "/Config_files"):
os.mkdir(returned_json["pythonsrcdir"] + warrior_path +
"/Config_files")
returned_json["testdata"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/Config_files")
if "wrapper_files" in child_dirs:
wrapper_folder = "wrapper_files"
returned_json["testwrapper"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/wrapper_files")
elif "Wrapper_files" in child_dirs:
wrapper_folder = "Wrapper_files"
returned_json["testwrapper"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/Wrapper_files")
else:
wrapper_folder = "wrapper_files"
if not os.path.exists(returned_json["pythonsrcdir"] +
warrior_path + "/wrapper_files"):
os.mkdir(returned_json["pythonsrcdir"] + warrior_path +
"/wrapper_files")
returned_json["testwrapper"] = (
returned_json["pythonsrcdir"] + warrior_path +
"/wrapper_files")
else:
if "Testcases" in base_tree:
test_case_folder = "Testcases"
elif "testcases" in base_tree:
test_case_folder = "testcases"
if "Suites" in base_tree:
suites_folder = "Suites"
elif "suites" in base_tree:
suites_folder = "suites"
if "Projects" in base_tree:
project_folder = "Projects"
elif "projects" in base_tree:
project_folder = "projects"
if "Data" in base_tree:
data_folder = "Data"
elif "data" in base_tree:
data_folder = "data"
if "Config_files" in base_tree:
config_folder = "Config_files"
elif "config_files" in base_tree:
config_folder = "config_files"
if "wrapper_files" in base_tree:
wrapper_folder = "wrapper_files"
elif "Wrapper_files" in base_tree:
wrapper_folder = "Wrapper_files"
sub_folders = {
test_case_folder: "xmldir",
suites_folder: "testsuitedir",
project_folder: "projdir",
data_folder: "idfdir",
config_folder: "testdata",
wrapper_folder: "testwrapper",
}
list_of_keys = list(sub_folders.keys())
for folder in list_of_keys:
try:
os.mkdir(returned_json["pythonsrcdir"] + "/" + folder)
returned_json[sub_folders[folder]] = (
returned_json["pythonsrcdir"] + "/" + folder)
except FileExistsError:
returned_json[sub_folders[folder]] = (
returned_json["pythonsrcdir"] + "/" + folder)
else:
os.mkdir(returned_json["pythonsrcdir"] + "/Warriorspace")
sub_folders = {
"Testcases": "xmldir",
"Suites": "testsuitedir",
"Projects": "projdir",
"Data": "idfdir",
"Config_files": "testdata",
"wrapper_files": "testwrapper",
}
for folder in [
"Testcases",
"Suites",
"Data",
"wrapper_files",
"Config_files",
"Projects",
]:
os.mkdir(returned_json["pythonsrcdir"] + "/Warriorspace/" +
folder)
returned_json[sub_folders[folder]] = (
returned_json["pythonsrcdir"] + "/Warriorspace/" + folder)
with open(config_json_path, "w") as f:
f.write(json.dumps(returned_json, indent=4))
return HttpResponse(request)
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
def read_config_file_data():
"""this function reads the data from appconfig.json file"""
data = read_json_data(app_config_file)
return data
