def _get_module(self, request):
# look for existing values
try:
# keyrefId = request.GET['keyref'] if 'keyref' in request.GET else None
module_id = request.GET['module_id']
module = SchemaElement.objects().get(pk=module_id)
keyrefId = module.options['params']['keyref']
# register the module id in the structure
if str(module_id) not in request.session['keyrefs'][keyrefId]['module_ids']:
request.session['keyrefs'][keyrefId]['module_ids'].append(str(module_id))
# get the list of values for this key
keyId = request.session['keyrefs'][keyrefId]['refer']
values = []
modules_ids = request.session['keys'][keyId]['module_ids']
for key_module_id in modules_ids:
key_module = SchemaElement.objects().get(pk=key_module_id)
if key_module.options['data'] is not None:
values.append(key_module.options['data'])
# add empty value
self.options.update({'': ''})
for value in values:
self.options.update({str(value): str(value)})
self.selected = ''
if 'data' in request.GET:
self.selected = request.GET['data']
elif 'data' in module.options and module.options['data'] is not None:
self.selected = str(module.options['data'])
except Exception:
self.options = {}
return OptionsModule.get_module(self, request)
def test_xsd_data_is_schema_element(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
renderer = AbstractListRenderer(xsd_data)
self.assertEqual(xsd_data, renderer.data)
def test_xsd_data_is_schema_element(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
renderer = AbstractListRenderer(xsd_data)
self.assertEqual(xsd_data, renderer.data)
def _get_module(self, request):
# get the name of the key
# keyId = request.GET['key']
module_id = request.GET['module_id']
module = SchemaElement.objects().get(pk=module_id)
keyId = module.options['params']['key']
# register the module id in the structure
if str(module_id) not in request.session['keys'][keyId]['module_ids']:
request.session['keys'][keyId]['module_ids'].append(str(module_id))
# get the list of values for this key
values = []
modules_ids = request.session['keys'][keyId]['module_ids']
for key_module_id in modules_ids:
key_module = SchemaElement.objects().get(pk=key_module_id)
if key_module.options['data'] is not None:
values.append(key_module.options['data'])
# if data are present
if 'data' in request.GET:
# set the key coming from data
key = request.GET['data']
else:
# generate a unique key
key = self.generateKey(values)
# set the value of the module with the key
self.default_value = key
return SyncInputModule.get_module(self, request)
def test_template_list_not_set(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
renderer = AbstractListRenderer(xsd_data)
# Loose comparison is enough for this test
self.assertEqual(len(renderer.templates), 7)
def test_template_list_not_set(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
renderer = AbstractListRenderer(xsd_data)
# Loose comparison is enough for this test
self.assertEqual(len(renderer.templates), 7)
def get_parent_element(element):
"""Get the parent element (tag is element not direct parent) of the current element.
Parameters:
element:
"""
try:
parent = SchemaElement.objects().get(children__contains=ObjectId(element.id))
while parent.tag != 'element':
parent = SchemaElement.objects().get(children__contains=ObjectId(parent.id))
return parent
except:
return None
def create_mock_db_input(value='', placeholder='', title=''):
input_element = SchemaElement()
input_element.tag = "input"
input_element.value = value
input_element.options = {
'title': title,
'placeholder': placeholder
}
input_element.pk = 'mock'
return input_element
def test_template_list_not_dict(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
template_list = None
try:
for template_list in self.type_generator.generate_types_excluding(['dict', 'none']):
with self.assertRaises(Exception):
AbstractListRenderer(xsd_data, template_list)
except AssertionError as error:
template_list_type = str(type(template_list))
error.message += ' (template_list type: ' + template_list_type + ')'
raise AssertionError(error.message)
def test_template_list_not_dict(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
template_list = None
try:
for template_list in self.type_generator.generate_types_excluding(['dict', 'none']):
with self.assertRaises(Exception):
AbstractListRenderer(xsd_data, template_list)
except AssertionError as error:
template_list_type = str(type(template_list))
error.message += ' (template_list type: ' + template_list_type + ')'
raise AssertionError(error.message)
def get_parent_element(element):
"""Get the parent element (tag is element not direct parent) of the current element.
Parameters:
element:
"""
try:
parent = SchemaElement.objects().get(
children__contains=ObjectId(element.id))
while parent.tag != 'element':
parent = SchemaElement.objects().get(
children__contains=ObjectId(parent.id))
return parent
except:
return None
def render(self):
"""
Parameters:
partial:
:return:
"""
if self.data.tag == 'element':
return self.render_element(self.data)
elif self.data.tag == 'choice':
content = self.render_choice(self.data)
root = self.data.children[0]
root_elem_id = root.value
root_elem = SchemaElement.objects().get(pk=root_elem_id)
root_name = root_elem.options['name']
if 'xmlns' in root_elem.options and root_elem.options['xmlns'] is not None:
xmlns = ' xmlns="{}"'.format(root_elem.options['xmlns'])
content[0] += xmlns
if content[0] == "": # Multi-root with element (no need for an element wrapper)
return content[1]
else: # Multi-root with complexType
return self._render_xml(root_name, content[0], content[1])
else:
message = 'render: ' + self.data.tag + ' not handled'
self.warnings.append(message)
return ''
def render(self):
"""
Parameters:
partial:
:return:
"""
if self.data.tag == 'element':
return self.render_element(self.data)
elif self.data.tag == 'choice':
content = self.render_choice(self.data)
root = self.data.children[0]
root_elem_id = root.value
root_elem = SchemaElement.objects().get(pk=root_elem_id)
root_name = root_elem.options['name']
if 'xmlns' in root_elem.options and root_elem.options[
'xmlns'] is not None:
xmlns = ' xmlns="{}"'.format(root_elem.options['xmlns'])
content[0] += xmlns
return self._render_xml(root_name, content[0], content[1])
else:
message = 'render: ' + self.data.tag + ' not handled'
self.warnings.append(message)
return ''
def test_template_list_is_incorrect_dict(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
template = None
try:
for template in self.type_generator.generate_types_excluding([]):
template_list = {"wrong": template}
with self.assertRaises(Exception):
AbstractListRenderer(xsd_data, template_list)
except AssertionError as error:
template_type = str(type(template))
error.message += ' (template type: ' + template_type + ')'
raise AssertionError(error.message)
def test_template_list_is_correct_dict(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
template_list = {
"t1": Template('a'),
"t2": Template('b'),
"t3": Template('c')
}
base_renderer = AbstractListRenderer(xsd_data)
base_renderer.templates.update(template_list)
renderer = AbstractListRenderer(xsd_data, template_list)
self.assertEqual(renderer.templates.keys(), base_renderer.templates.keys())
def _get(self, request):
module_id = request.GET['module_id']
url = request.GET[
'url'] if 'url' in request.GET else SchemaElement.objects().get(
pk=module_id).options['url']
template_data = {
'module_id': module_id,
'module': '',
'display': '',
'result': '',
'url': url
}
try:
template_data['module'] = self._get_module(request)
template_data['display'] = self._get_display(request)
result = self._get_result(request)
template_data['result'] = result
module_element = SchemaElement.objects.get(
pk=request.GET['module_id'])
options = module_element.options
options['data'] = result
module_element.update(set__options=options)
module_element.reload()
except Exception, e:
raise ModuleError(
'Something went wrong during module initialization: ' +
e.message)
def _get(self, request):
module_id = request.GET['module_id']
url = request.GET['url'] if 'url' in request.GET else SchemaElement.objects().get(pk=module_id).options['url']
template_data = {
'module_id': module_id,
'module': '',
'display': '',
'result': '',
'url': url
}
try:
template_data['module'] = self._get_module(request)
template_data['display'] = self._get_display(request)
result = self._get_result(request)
template_data['result'] = result
module_element = SchemaElement.objects.get(pk=request.GET['module_id'])
options = module_element.options
options['data'] = result
module_element.update(set__options=options)
module_element.reload()
except Exception, e:
raise ModuleError('Something went wrong during module initialization: ' + e.message)
def test_template_list_is_correct_dict(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
template_list = {
"t1": Template('a'),
"t2": Template('b'),
"t3": Template('c')
}
base_renderer = AbstractListRenderer(xsd_data)
base_renderer.templates.update(template_list)
renderer = AbstractListRenderer(xsd_data, template_list)
self.assertEqual(renderer.templates.keys(), base_renderer.templates.keys())
def remove_element(request):
element_id = request.POST['id']
# sub_element = SchemaElement.objects.get(pk=element_id)
element_list = SchemaElement.objects(children=element_id)
if len(element_list) == 0:
raise ValueError("No SchemaElement found")
elif len(element_list) > 1:
raise ValueError("More than one SchemaElement found")
# Removing the element from the data structure
schema_element = element_list[0]
schema_element_to_pull = SchemaElement.objects.get(pk=element_id)
schema_element.update(pull__children=schema_element_to_pull)
schema_element.reload()
update_branch_xpath(schema_element)
# Deleting the branch from the database
delete_branch_from_db(element_id)
children_number = len(schema_element.children)
# TODO Move it to parser function
# FIXME Sequence elem it might not work
if len(schema_element.children) == 0:
elem_iter = SchemaElement()
if schema_element.tag == 'element':
elem_iter.tag = 'elem-iter'
elif schema_element.tag == 'choice':
elem_iter.tag = 'choice-iter'
elif schema_element.tag == 'sequence':
elem_iter.tag = 'sequence-iter'
elem_iter.save()
schema_element.update(add_to_set__children=[elem_iter])
schema_element.reload()
response = {
'code': 0,
'html': ""
}
if children_number > schema_element.options['min']:
return HttpResponse(json.dumps(response), status=HTTP_200_OK)
else: # len(schema_element.children) == schema_element.options['min']
if schema_element.options['min'] != 0:
response['code'] = 1
else: # schema_element.options['min'] == 0
renderer = ListRenderer(schema_element, request)
html_form = renderer.render(True)
response['code'] = 2
response['html'] = html_form
return HttpResponse(json.dumps(response))
def generate_xsd_form(request):
""" Renders HTMl form for display.
Parameters:
request:
Returns:
str: HTML form
"""
try:
if 'form_id' in request.session:
root_element_id = request.session['form_id']
form_data = None
request.session['curate_edit'] = False
else: # If this is a new form, generate it and store the root ID
# get the xsd tree when going back and forth with review step
if 'xmlDocTree' in request.session:
xsd_doc_data = request.session['xmlDocTree']
else:
template_id = request.session['currentTemplateID']
template_object = Template.objects.get(pk=template_id)
xsd_doc_data = template_object.content
# get form data from the database (empty one or existing one)
form_data_id = request.session['curateFormData']
form_data = FormData.objects.get(pk=ObjectId(form_data_id))
if form_data.xml_data is not None:
xml_doc_data = form_data.xml_data
else:
xml_doc_data = None
root_element_id = generate_form(request, xsd_doc_data, xml_doc_data, config=load_config())
request.session['form_id'] = str(root_element_id)
root_element = SchemaElement.objects.get(pk=root_element_id)
if form_data is not None:
if form_data.schema_element_root is not None:
delete_branch_from_db(form_data.schema_element_root.pk)
form_data.update(set__schema_element_root=root_element)
form_data.reload()
renderer = ListRenderer(root_element, request)
html_form = renderer.render()
except Exception as e:
renderer = DefaultRenderer(SchemaElement(), {})
if e.message is not None:
err_message = e.message
else:
err_message = "An unknown error raised " + e.__class__.__name__
html_form = renderer._render_form_error(err_message)
return HttpResponse(json.dumps({'xsdForm': html_form}), content_type='application/javascript')
def test_template_list_is_incorrect_dict(self):
xsd_data = SchemaElement()
xsd_data.tag = "test"
template = None
try:
for template in self.type_generator.generate_types_excluding([]):
template_list = {
"wrong": template
}
with self.assertRaises(Exception):
AbstractListRenderer(xsd_data, template_list)
except AssertionError as error:
template_type = str(type(template))
error.message += ' (template type: ' + template_type + ')'
raise AssertionError(error.message)
def test_input_not_schema_element(self):
input_element = SchemaElement()
try:
for input_element in self.types_generator.possible_types:
with self.assertRaises(TypeError):
self.renderer._render_input(input_element)
except AssertionError as error:
input_type = str(type(input_element))
error.message += ' (input type: ' + input_type + ')'
raise AssertionError(error.message)
def get_updated_keys(request):
"""
updated_keys[key] = {'ids': [],
'tagIDs': []}
key = key name
ids = list of posssible values for a key
tagIDs = HTML element that needs to be updated with the values (keyrefs)
"""
# delete keys that have been deleted
for key, values in request.session['keys'].iteritems():
deleted_ids = []
for module_id in values['module_ids']:
try:
SchemaElement.objects().get(pk=module_id)
except Exception:
deleted_ids.append(module_id)
request.session['keys'][key]['module_ids'] = [
item for item in request.session['keys'][key]['module_ids']
if item not in deleted_ids
]
# delete keyrefs that have been deleted
for keyref, values in request.session['keyrefs'].iteritems():
deleted_ids = []
for module_id in values['module_ids']:
try:
SchemaElement.objects().get(pk=module_id)
except Exception:
deleted_ids.append(module_id)
request.session['keyrefs'][keyref]['module_ids'] = [
item for item in request.session['keyrefs'][keyref]['module_ids']
if item not in deleted_ids
]
# get the list of keyrefs to update
updated_keyrefs = []
for keyref, values in request.session['keyrefs'].iteritems():
updated_keyrefs.extend(values['module_ids'])
return HttpResponse(json.dumps(updated_keyrefs),
content_type='application/javascript')
def remove_element(request):
element_id = request.POST['id']
# sub_element = SchemaElement.objects.get(pk=element_id)
element_list = SchemaElement.objects(children=element_id)
if len(element_list) == 0:
raise ValueError("No SchemaElement found")
elif len(element_list) > 1:
raise ValueError("More than one SchemaElement found")
# Removing the element from the data structure
schema_element = element_list[0]
schema_element.update(pull__children=element_id)
schema_element.reload()
update_branch_xpath(schema_element)
# Deleting the branch from the database
delete_branch_from_db(element_id)
children_number = len(schema_element.children)
# TODO Move it to parser function
# FIXME Sequence elem it might not work
if len(schema_element.children) == 0:
elem_iter = SchemaElement()
if schema_element.tag == 'element':
elem_iter.tag = 'elem-iter'
elif schema_element.tag == 'choice':
elem_iter.tag = 'choice-iter'
elif schema_element.tag == 'sequence':
elem_iter.tag = 'sequence-iter'
elem_iter.save()
schema_element.update(add_to_set__children=[elem_iter])
schema_element.reload()
response = {
'code': 0,
'html': ""
}
if children_number > schema_element.options['min']:
return HttpResponse(json.dumps(response), status=HTTP_200_OK)
else: # len(schema_element.children) == schema_element.options['min']
if schema_element.options['min'] != 0:
response['code'] = 1
else: # schema_element.options['min'] == 0
renderer = ListRenderer(schema_element, request)
html_form = renderer.render(True)
response['code'] = 2
response['html'] = html_form
return HttpResponse(json.dumps(response))
def generate_xsd_form(request):
""" Renders HTMl form for display.
Parameters:
request:
Returns:
str: HTML form
"""
try:
if 'form_id' in request.session:
root_element_id = request.session['form_id']
template_id = request.session['currentTemplateID']
template_object = Template.objects.get(pk=template_id)
xsd_doc_data = template_object.content
flattener = XSDFlattenerURL(xsd_doc_data)
xml_doc_tree_str = flattener.get_flat()
request.session['xmlDocTree'] = xml_doc_tree_str
request.session['curate_edit'] = False
else: # If this is a new form, generate it and store the root ID
# get the xsd tree when going back and forth with review step
if 'xmlDocTree' in request.session:
xsd_doc_data = request.session['xmlDocTree']
else:
template_id = request.session['currentTemplateID']
template_object = Template.objects.get(pk=template_id)
xsd_doc_data = template_object.content
# get form data from the database (empty one or existing one)
form_data_id = request.session['curateFormData']
form_data = FormData.objects.get(pk=ObjectId(form_data_id))
if form_data.xml_data is not None:
xml_doc_data = form_data.xml_data
else:
xml_doc_data = None
root_element_id = generate_form(request, xsd_doc_data, xml_doc_data)
request.session['form_id'] = str(root_element_id)
root_element = SchemaElement.objects.get(pk=root_element_id)
renderer = ListRenderer(root_element, request)
html_form = renderer.render()
except Exception as e:
renderer = DefaultRenderer(SchemaElement(), {})
html_form = renderer._render_form_error(e.message)
return HttpResponse(json.dumps({'xsdForm': html_form}), content_type='application/javascript')
def get_updated_keys(request):
"""
updated_keys[key] = {'ids': [],
'tagIDs': []}
key = key name
ids = list of posssible values for a key
tagIDs = HTML element that needs to be updated with the values (keyrefs)
"""
# delete keys that have been deleted
for key, values in request.session['keys'].iteritems():
deleted_ids = []
for module_id in values['module_ids']:
try:
SchemaElement.objects().get(pk=module_id)
except Exception:
deleted_ids.append(module_id)
request.session['keys'][key]['module_ids'] = [item for item in request.session['keys'][key]['module_ids']
if item not in deleted_ids]
# delete keyrefs that have been deleted
for keyref, values in request.session['keyrefs'].iteritems():
deleted_ids = []
for module_id in values['module_ids']:
try:
SchemaElement.objects().get(pk=module_id)
except Exception:
deleted_ids.append(module_id)
request.session['keyrefs'][keyref]['module_ids'] = [item for item in request.session['keyrefs'][keyref]['module_ids']
if item not in deleted_ids]
# get the list of keyrefs to update
updated_keyrefs = []
for keyref, values in request.session['keyrefs'].iteritems():
updated_keyrefs.extend(values['module_ids'])
return HttpResponse(json.dumps(updated_keyrefs), content_type='application/javascript')
def _get_module(self, request):
# look for existing values
try:
# keyrefId = request.GET['keyref'] if 'keyref' in request.GET else None
module_id = request.GET['module_id']
module = SchemaElement.objects().get(pk=module_id)
keyrefId = module.options['params']['keyref']
# register the module id in the structure
if str(module_id
) not in request.session['keyrefs'][keyrefId]['module_ids']:
request.session['keyrefs'][keyrefId]['module_ids'].append(
str(module_id))
# get the list of values for this key
keyId = request.session['keyrefs'][keyrefId]['refer']
values = []
modules_ids = request.session['keys'][keyId]['module_ids']
for key_module_id in modules_ids:
key_module = SchemaElement.objects().get(pk=key_module_id)
if key_module.options['data'] is not None:
values.append(key_module.options['data'])
# add empty value
self.options.update({'': ''})
for value in values:
self.options.update({str(value): str(value)})
self.selected = ''
if 'data' in request.GET:
self.selected = request.GET['data']
elif 'data' in module.options and module.options[
'data'] is not None:
self.selected = str(module.options['data'])
except Exception:
self.options = {}
return OptionsModule.get_module(self, request)
def create_mock_db_input(value='', placeholder='', title=''):
input_element = SchemaElement()
input_element.tag = "input"
input_element.value = value
input_element.options = {'title': title, 'placeholder': placeholder}
input_element.pk = 'mock'
return input_element
from curate.models import SchemaElement
MONGODB_URI = 'mongodb://*****:*****@localhost/mgi'
projectIDs = set(["blank"])
DB_NAME = "mgi"
client = MongoClient(MONGODB_URI)
db = client[DB_NAME]
xmldata = db['xmldata']
for cursor in xmldata.find({
"content.amProjectDB.@xmlns:xsi":
"http://www.w3.org/2001/XMLSchema-instance"
}):
projectIDs.add(cursor["content"]["amProjectDB"]["amProject"]["projectID"])
product_element = SchemaElement()
product_element.tag = u'restriction'
product_element.value = u"blank"
product_element.options = {u'base': u'xs:string'}
product_element.children = []
product_element.save()
for ProjectID in projectIDs:
xsd_element = SchemaElement()
xsd_element.tag = u'enumeration'
xsd_element.value = str(ProjectID).decode('UTF-8')
xsd_element.options = {}
xsd_element.children = []
xsd_element.save()
product_element.children.append(xsd_element)
product_element.save()
def create_mock_html_renderer():
element = SchemaElement()
element.tag = "mock"
return HtmlRenderer(element)
def generate_xsd_form(request):
""" Renders HTMl form for display.
Parameters:
request:
Returns:
str: HTML form
"""
try:
if 'form_id' in request.session:
root_element_id = request.session['form_id']
form_data = None
request.session['curate_edit'] = False
else: # If this is a new form, generate it and store the root ID
# get the xsd tree when going back and forth with review step
if 'xmlDocTree' in request.session:
xsd_doc_data = request.session['xmlDocTree']
else:
template_id = request.session['currentTemplateID']
template_object = Template.objects.get(pk=template_id)
xsd_doc_data = template_object.content
# get form data from the database (empty one or existing one)
form_data_id = request.session['curateFormData']
form_data = FormData.objects.get(pk=ObjectId(form_data_id))
if form_data.xml_data is not None:
xml_doc_data = form_data.xml_data
else:
xml_doc_data = None
root_element_id = generate_form(request,
xsd_doc_data,
xml_doc_data,
config=load_config())
request.session['form_id'] = str(root_element_id)
root_element = SchemaElement.objects.get(pk=root_element_id)
##### xxxxxxxxxxxxxxx
text2choice(root_element)
if form_data is not None:
if form_data.schema_element_root is not None:
delete_branch_from_db(form_data.schema_element_root.pk)
form_data.update(set__schema_element_root=root_element)
form_data.reload()
renderer = ListRenderer(root_element, request)
html_form = renderer.render()
except Exception as e:
renderer = DefaultRenderer(SchemaElement(), {})
if e.message is not None:
err_message = e.message
else:
err_message = "An unknown error raised " + e.__class__.__name__
html_form = renderer._render_form_error(err_message)
#### add image upload button
try:
page = etree.fromstring(html_form)
hrefs = page.xpath(u"//li")
for href in hrefs:
if href.text.strip() == "imageID":
form = etree.SubElement(
href,
'form',
attrib={
'action':
'''javascript:var request = $.ajax({url: "/rest/blob?id=1243",
method: "POST",
data: new FormData(document.getElementById('blob321')),
processData: false,
contentType: false
}).done(function(res){document.getElementById('%s').value=res.handle;}).fail(function(res){});'''
% (href.getchildren()[0].attrib['id']),
'method':
'post',
'id':
'blob321',
'enctype':
'multipart/form-data'
})
attributes = href.getchildren()[0].attrib
attributes['type'] = 'submit'
attributes['value'] = 'upload'
etree.SubElement(form,
'input',
attrib={
'id': 'blob123',
'type': 'file',
'name': 'blob'
})
form.append(href.getchildren()[0])
html_form = etree.tostring(page)
except Exception as e:
pass
return HttpResponse(json.dumps({'xsdForm': html_form}),
content_type='application/javascript')
def create_mock_html_renderer():
element = SchemaElement()
element.tag = "mock"
return HtmlRenderer(element)
