430 lines
17 KiB
Python
430 lines
17 KiB
Python
import json5
|
|
#import pandas as pd
|
|
import sys
|
|
import argparse
|
|
from chameleon import PageTemplateFile,PageTemplate
|
|
import pkg_resources
|
|
import xml.etree.ElementTree as ET
|
|
import re
|
|
import os
|
|
|
|
|
|
version = 0.6
|
|
|
|
json5_dict: dict = {}
|
|
json5_html_list: list = []
|
|
|
|
print(f"Generate SM2 code from JSON5 - Version {version}")
|
|
# Get the version of Chameleon using pkg_resources
|
|
try:
|
|
version = pkg_resources.get_distribution("Chameleon").version
|
|
print("Using Chameleon version:", version)
|
|
except pkg_resources.DistributionNotFound:
|
|
print("Chameleon is not installed or found.")
|
|
|
|
def parse_json(json_obj, prefix=''):
|
|
structured_list = []
|
|
if isinstance(json_obj, dict):
|
|
for k, v in json_obj.items():
|
|
new_key = f"{prefix}.{k}" if prefix else k
|
|
structured_list.extend(parse_json(v, new_key))
|
|
elif isinstance(json_obj, list):
|
|
for i, v in enumerate(json_obj):
|
|
new_key = f"{prefix}[{i}]"
|
|
structured_list.extend(parse_json(v, new_key))
|
|
else:
|
|
structured_list.append(f"{prefix}: {json_obj}")
|
|
return structured_list
|
|
|
|
def json5_to_list(filename):
|
|
with open(filename, 'r') as file:
|
|
data = json5.load(file)
|
|
return parse_json(data)
|
|
|
|
def json5_to_pandas(filename):
|
|
with open(filename, 'r') as file:
|
|
data = json5.load(file)
|
|
print (data)
|
|
return data.json_normalize(data)
|
|
|
|
def json5_to_dict(filename):
|
|
with open(filename, 'r') as file:
|
|
data = json5.load(file)
|
|
return data
|
|
|
|
def rec_print(data, prefix=''):
|
|
# Check if this item is a dictionary.
|
|
if isinstance(data, dict):
|
|
for key, val in data.items():
|
|
rec_print(val, f"{prefix}.{key}")
|
|
# Check if this item is a list.
|
|
elif isinstance(data, list):
|
|
for idx, val in enumerate(data):
|
|
rec_print(val, f"{prefix}[{idx}]")
|
|
# If neither, it's a basic type.
|
|
else:
|
|
print(f"{prefix}: {data}")
|
|
|
|
def find_item(nested_dict, target_key):
|
|
for key, val in nested_dict.items():
|
|
if key == target_key:
|
|
return val
|
|
elif isinstance(val, dict):
|
|
result = find_item(val, target_key)
|
|
if result is not None:
|
|
return result
|
|
|
|
def find_dicts_with_key(data, target_key):
|
|
results = []
|
|
if isinstance(data, dict):
|
|
if target_key in data:
|
|
results.append(data)
|
|
for val in data.values():
|
|
if isinstance(val, (dict, list)):
|
|
results.extend(find_dicts_with_key(val, target_key))
|
|
elif isinstance(data, list):
|
|
for item in data:
|
|
if isinstance(item, (dict, list)):
|
|
results.extend(find_dicts_with_key(item, target_key))
|
|
return results
|
|
|
|
def find_values_with_key(data, target_key):
|
|
results = []
|
|
if isinstance(data, dict):
|
|
if target_key in data:
|
|
results.append(data[target_key])
|
|
for val in data.values():
|
|
if isinstance(val, (dict, list)):
|
|
results.extend(find_values_with_key(val, target_key))
|
|
elif isinstance(data, list):
|
|
for item in data:
|
|
if isinstance(item, (dict, list)):
|
|
results.extend(find_values_with_key(item, target_key))
|
|
return results
|
|
|
|
def lint_json5(filename):
|
|
try:
|
|
with open(filename, 'r') as file:
|
|
data = file.read()
|
|
json5.loads(data)
|
|
print(f"{filename} as JSON5 data is valid")
|
|
except Exception as e:
|
|
print(f"{filename} as JSON5 data is invalid")
|
|
print("Error:", str(e))
|
|
sys.exit()
|
|
|
|
|
|
def flatten_hash_of_lists(hash_of_lists):
|
|
flattened = {}
|
|
for key, value in hash_of_lists.items():
|
|
if isinstance(value, list):
|
|
for i, item in enumerate(value):
|
|
new_key = f"{key}_{i}" # Appending index to the key to maintain uniqueness
|
|
flattened[new_key] = item
|
|
else:
|
|
flattened[key] = value
|
|
return flattened
|
|
|
|
def hl(keyname):
|
|
# Return highest level value for the keyname
|
|
if keyname in json5_dict:
|
|
return json5_dict[keyname]
|
|
else:
|
|
print(f"{keyname} not found in JSON5 - top level")
|
|
return 'None'
|
|
|
|
def get_all_routes():
|
|
route_list = [html_block.get('route') for html_block in json5_dict.get('html', [])]
|
|
return route_list
|
|
|
|
def lc_get_all_routes():
|
|
# All routes in lower case
|
|
route_list = [html_block.get('route').lower() for html_block in json5_dict.get('html', [])]
|
|
return route_list
|
|
|
|
def has_file_been_modified(file_path):
|
|
# Get the file's creation time and last modification time in Unix timestamp
|
|
creation_time = os.path.getctime(file_path)
|
|
last_modification_time = os.path.getmtime(file_path)
|
|
|
|
# Compare the creation time and last modification time
|
|
if creation_time < last_modification_time:
|
|
return True # File has been modified after creation
|
|
else:
|
|
return False # File has not been modified after creation
|
|
|
|
|
|
import xml.etree.ElementTree as ET
|
|
|
|
def parse_xml_to_dict(xml_file):
|
|
# Parse the XML file
|
|
tree = ET.parse(xml_file)
|
|
root = tree.getroot()
|
|
|
|
xml_dict = {} # Initialize an empty dictionary to store the data
|
|
|
|
# Iterate through the XML tree and extract data
|
|
for elem in root:
|
|
tag = elem.tag
|
|
if elem.text:
|
|
xml_dict[tag] = elem.text
|
|
else:
|
|
cdata_content = elem.find('.//').text # Extract CDATA text
|
|
xml_dict[tag] = cdata_content
|
|
|
|
return xml_dict
|
|
|
|
def deduplicate_array(arr):
|
|
# Convert the array to a set to remove duplicates
|
|
unique_set = set(arr)
|
|
|
|
# Convert the set back to a list to maintain the order
|
|
deduplicated_list = list(unique_set)
|
|
|
|
return deduplicated_list
|
|
|
|
def get_db_fields():
|
|
return []
|
|
|
|
def get_table_control_data():
|
|
return find_values_with_key(json5_html_list,'TableControl')
|
|
|
|
if __name__ == "__main__":
|
|
filename = '/home/brianr/clients/SM2/SM2Gen/nfsshare.json5'
|
|
|
|
# Command line parameters
|
|
parser = argparse.ArgumentParser(description="SM2Gen")
|
|
parser.add_argument('-f', '--filename', help='Specify a filename for the JSON5 file', default=filename)
|
|
parser.add_argument('-nc', '--noController', help='Stop it creating a controller file', default="no")
|
|
parser.add_argument('-nh', '--noHtml', help='Stop it creating html files(s)', default="no")
|
|
parser.add_argument('-nl', '--noLang', help='Stop it creating language localise files(s)', default="no")
|
|
args = parser.parse_args()
|
|
filename = args.filename
|
|
print(f"JSON5 from {filename} with noController={args.noController}, noHtml={args.noHtml} and noLang={args.noLang}") #Not yet activated
|
|
#print("Chameleon version:", chameleon.__version__)
|
|
|
|
# check syntax of JSON5
|
|
lint_json5(filename);
|
|
|
|
# Get dict of it all
|
|
json5_dict = json5_to_dict(filename)
|
|
#print(json5_dict)
|
|
|
|
# Get dict of just the html bit
|
|
json5_html_list = json5_dict['html']
|
|
#print(json5_html_list)
|
|
|
|
#Identify message
|
|
print(f"\nGenerating mojo panels for {hl('PackageName')}")
|
|
print( "-----------------------------------")
|
|
|
|
# Routes for each panel
|
|
routes = get_all_routes();
|
|
lc_routes =lc_get_all_routes();
|
|
|
|
#File names
|
|
controller_file = 'Targets/'+hl('PackageName')+'.pm'
|
|
custom_controller_file = 'Targets/'+hl('PackageName')+'-Custom.pm'
|
|
# see if it has been modified by developer
|
|
if has_file_been_modified(custom_controller_file):
|
|
custom_controller_file = custom_controller_file+'.new'
|
|
layout_file = 'Targets/'+hl('PackageName')+'.html.ep'
|
|
partial_files = list()
|
|
for panel in routes:
|
|
partial_files.append('Targets/_'+hl('prefix')+"_"+panel+'.html.ep')
|
|
print(partial_files)
|
|
lex_file = 'Targets/'+hl('PackageName').lower()+'_en.lex'
|
|
tablecontrols = get_table_control_data() #arrays of hashes used to drive rows in tables
|
|
#print(tablecontrols)
|
|
#quit()
|
|
|
|
#Generate controller file
|
|
try:
|
|
controller_template = PageTemplateFile("Templates/controller.pm.tem")
|
|
dbentries = get_db_fields() #Params which correspond to Db fields
|
|
try:
|
|
controller_perl = controller_template.render(tablecontrols=tablecontrols, dbentries=dbentries,**json5_dict,panels=routes,lcPackageName=json5_dict['PackageName'].lower())
|
|
#print()
|
|
#print(controller_perl)
|
|
# Map '$ 'to '$' to overcome problem with escaping $ signs
|
|
#controller_perl = controller_perl.replace("$ ", "$")
|
|
with open(controller_file, 'w') as file:
|
|
file.write(controller_perl)
|
|
print(f"{controller_file} controller generated ok")
|
|
except Exception as e:
|
|
print(f"An chameleon controller render error occurred: {e}")
|
|
except Exception as e:
|
|
print(f"An chameleon controller template error occurred: {e}")
|
|
|
|
#Generate Custom controller file
|
|
try:
|
|
custom_controller_template = PageTemplateFile("Templates/custom.pm.tem")
|
|
try:
|
|
custom_controller_perl = custom_controller_template.render(panels=routes,tablecontrols=tablecontrols)
|
|
# We must be careful to not overwrite the custom file if the developer has already written to it - TBD
|
|
with open(custom_controller_file, 'w') as file:
|
|
file.write(custom_controller_perl)
|
|
print(f"{custom_controller_file} custom controller generated ok")
|
|
except Exception as e:
|
|
print(f"An chameleon custom controller render error occurred: {e}")
|
|
except Exception as e:
|
|
print(f"An chameleon custom controller template error occurred: {e}")
|
|
|
|
#generate Layout file
|
|
layout_template = PageTemplateFile("Templates/layout.html.ep.tem")
|
|
try:
|
|
try:
|
|
layout_mojo = layout_template.render(**json5_dict,conditions=routes)
|
|
# Map '$ 'to '$' to overcome problem with escaping $ signs
|
|
#layout_mojo = layout_mojo.replace("$ ", "$")
|
|
with open(layout_file, 'w') as file:
|
|
file.write(layout_mojo)
|
|
print(f"{layout_file} mojo template layout file generated ok")
|
|
except Exception as e:
|
|
print(f"An chameleon render on layout file error occurred: {e}")
|
|
#print()
|
|
#print(layout_mojo_template)
|
|
except Exception as e:
|
|
print(f"An chameleon template layout file error occurred: {e}")
|
|
|
|
#Generate a partial file for each of the entries in the html list
|
|
#Pull in the template code for each of the input types
|
|
#html_controls = json5_to_dict('Templates/html_controls.html.ep.tem')
|
|
html_controls = parse_xml_to_dict('Templates/html_controls.html.ep.xml')
|
|
#print(html_controls)
|
|
i = 0
|
|
for html in json5_html_list:
|
|
# Generate a mojo template file, and then add in the controls
|
|
# main file first
|
|
try:
|
|
partial_template = PageTemplateFile("Templates/partial.html.ep.tem")
|
|
partial_mojo_context = {**json5_dict,**html}
|
|
try:
|
|
partial_mojo_template = partial_template.render(**partial_mojo_context)
|
|
# Map '$ 'to '$' to overcome problem with escaping $ signs
|
|
#partial_mojo_template = partial_mojo_template.replace("$ ", "$")
|
|
with open( partial_files[i], 'w') as file:
|
|
file.write(partial_mojo_template)
|
|
print(f"{partial_files[i]} mojo template generated ok - phase 1")
|
|
except Exception as e:
|
|
print(f"An chameleon render error on partial file {html['route']} occurred: {e}")
|
|
except Exception as e:
|
|
print(f"An chameleon html {html['route']} error occurred: {e}")
|
|
|
|
#Now generate the controls from the rest of the entries in the dict.
|
|
#print()
|
|
#print(html['route']);
|
|
all_controls_html = "";
|
|
prefix_is = hl('prefix')
|
|
for html_control in html:
|
|
#print(html_control)
|
|
inner_html = html[html_control]
|
|
if isinstance(inner_html, dict):
|
|
#print("\t\t"+inner_html['route']+":"+inner_html['Type'])
|
|
try:
|
|
control_template = PageTemplate(html_controls[inner_html['Type']])
|
|
try:
|
|
control_html = control_template.render(**inner_html,prefix=prefix_is) #Contents=Contents,Headings=Headings)
|
|
# Map '$ 'to '$' to overcome problem with escaping $ signs
|
|
#control_html = control_html.replace("$ ", "$")
|
|
# Add in two tabs before each newline
|
|
#control_html = control_html.replace("\n", "\n\t\t")
|
|
# and an extra tab before each "%"
|
|
#control_html = control_html.replace("%", "\t%")
|
|
#print(control_html)
|
|
# And re-run it if the type is "table"
|
|
#if inner_html['Type'] == 'Table'
|
|
#Another scan
|
|
# print("Another scan for the table")
|
|
#Else just move on.
|
|
all_controls_html = all_controls_html + control_html
|
|
except Exception as e:
|
|
print(f"An chameleon render on partial file control {inner_html['Name']} error occurred: {e}")
|
|
except Exception as e:
|
|
print(f"An chameleon render on partial file control {inner_html['Name']} error occurred: {e}")
|
|
else:
|
|
#just a simple entry - name less numerics is type
|
|
html_Type = ''.join(char for char in html_control if not char.isdigit())
|
|
#print(html_Type);
|
|
try:
|
|
simple_control_template = PageTemplate(html_controls[html_Type])
|
|
try:
|
|
simple_control_html = simple_control_template.render(value=inner_html,prefix=prefix_is)
|
|
# Map '$ 'to '$' to overcome problem with escaping $ signs
|
|
#simple_control_html = simple_control_html.replace("$ ", "$")
|
|
# Add in two tabs before each newline
|
|
#simple_control_html = simple_control_html.replace("\n", "\n\t\t")
|
|
all_controls_html = all_controls_html + simple_control_html
|
|
except Exception as e:
|
|
print(f"An chameleon render on partial file control {html_control} error occurred: {e}")
|
|
except Exception as e:
|
|
print(f"An chameleon template partial file control {html_control} error occurred: {e}")
|
|
|
|
# Now insert it into the partial file in the correct place.
|
|
# Read in the text file and split at "%# Inputs etc in here."
|
|
with open(partial_files[i], 'r') as file:
|
|
lines = file.readlines()
|
|
index = next((i for i, line in enumerate(lines) if "%# Inputs etc in here." in line), len(lines))
|
|
|
|
# Insert the string at the specified index
|
|
lines.insert(index+1, all_controls_html + '\n')
|
|
|
|
# Write the modified content back to the file
|
|
with open(partial_files[i], 'w') as file:
|
|
file.writelines(lines)
|
|
print(f"Content modified and saved to {partial_files[i]}")
|
|
i += 1
|
|
|
|
# Now generate the <name>.en file
|
|
# Look through the generated files for the /l[\s|(]['|"](.*)['|"]\)/ strings.
|
|
|
|
# create a combined list of all the files
|
|
all_files = [controller_file,layout_file]+partial_files
|
|
#print(all_files)
|
|
all_strings = []
|
|
for filename in all_files:
|
|
with open(filename, 'r') as file:
|
|
file_content = file.read()
|
|
# Define the regular expression pattern to match the strings you want to extract
|
|
pattern = r"l[\s|(][\'|\"](.*)[\'|\"]\)"
|
|
# Use re.findall to extract all occurrences of the pattern from the file content
|
|
extracted_strings = re.findall(pattern, file_content)
|
|
#print(len(extracted_strings))
|
|
all_strings = all_strings + extracted_strings
|
|
#print(len(all_strings))
|
|
#Take out any duplicates
|
|
all_strings = deduplicate_array(all_strings)
|
|
#print(len(all_strings))
|
|
# Now process them one by one into the lexical file
|
|
lex_all = "";
|
|
# '<prefix>_english-message' => 'English Message',
|
|
for lex_message in all_strings:
|
|
# If has a prefix - leave it for left hand side but delete it for the right
|
|
# If has no prefix - add one for left hand side but and lkeave it for the right
|
|
if lex_message.startswith(hl('prefix')):
|
|
left_str = lex_message
|
|
right_str = lex_message[len(hl('prefix'))+1:]
|
|
else:
|
|
left_str = hl('prefix')+"_"+lex_message
|
|
right_str = lex_message
|
|
lex_all += f"'{left_str}' => '{right_str}'\n"
|
|
#And write it to lex file
|
|
with open( lex_file, 'w') as file:
|
|
file.write(lex_all)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|