def curate_from_schema(request):
try:
schema_name = request.GET['template']
templates = Template.objects(title=schema_name)
# if the schemas are all versions of the same schema
if len(set(templates.values_list('templateVersion'))) == 1:
template_id = TemplateVersion.objects().get(
pk=templates[0].templateVersion).current
request.session['currentTemplateID'] = template_id
form_data = FormData(user=str(request.user.id),
template=template_id,
name=schema_name)
form_data.save()
request.session['curateFormData'] = str(form_data.pk)
request.session['curate_edit'] = False
if 'xmlDocTree' in request.session:
del request.session['xmlDocTree']
else:
error_message = "The selection of template by name can't be used if the MDCS contain more than one "
error_message += "template with the same name."
raise MDCSError(error_message)
except:
raise MDCSError("The template you are looking for doesn't exist.")
def setUp(self):
xsd_files_path = join(XSD_FILES_PATH, 'choice')
self.xsd_handler = DataHandler(xsd_files_path)
html_files_path = join(HTML_FILES_PATH, 'choice')
self.html_handler = DataHandler(html_files_path)
engine = import_module('django.contrib.sessions.backends.db')
session = engine.SessionStore()
session.save()
self.client.cookies['sessionid'] = session.session_key
session['curate_edit'] = False
form_data = FormData()
form_data.name = ''
form_data.user = ''
form_data.template = ''
form_data.save()
session['curateFormData'] = str(form_data.pk)
session['nb_html_tags'] = 0
session['implicit_extension'] = True
session['mapTagID'] = {}
session['nbChoicesID'] = 0
session.save()
def curate_edit_data(request):
try:
xml_data_id = request.GET['id']
xml_data = XMLdata.get(xml_data_id)
xml_content = xml_data['xml_file']
request.session['curate_edit'] = True
request.session['currentTemplateID'] = xml_data['schema']
# remove previously created forms when editing a new one
previous_forms = FormData.objects(user=str(request.user.id),
xml_data_id__exists=True)
for previous_form in previous_forms:
if previous_form.schema_element_root is not None:
delete_branch_from_db(previous_form.schema_element_root.pk)
previous_form.delete()
form_data = FormData(user=str(request.user.id),
template=xml_data['schema'],
name=xml_data['title'],
xml_data=xml_content,
xml_data_id=xml_data_id)
form_data.save()
request.session['curateFormData'] = str(form_data.pk)
if 'form_id' in request.session:
del request.session['form_id']
if 'xmlDocTree' in request.session:
del request.session['xmlDocTree']
except:
raise MDCSError("The document you are looking for doesn't exist.")
def curate_edit_data(request):
try:
if 'useForm' in request.GET and request.GET['useForm'] == 'true':
pass
else:
xml_data_id = request.GET['id']
xml_data = XMLdata.get(xml_data_id)
json_content = xml_data['content']
xml_content = xmltodict.unparse(json_content)
request.session['curate_edit_data'] = xml_content
request.session['curate_edit'] = True
request.session['currentTemplateID'] = xml_data['schema']
# remove previously created forms when editing a new one
previous_forms = FormData.objects(user=str(request.user.id), xml_data_id__exists=True)
for previous_form in previous_forms:
# TODO: check if need to delete all SchemaElements
previous_form.delete()
form_data = FormData(
user=str(request.user.id),
template=xml_data['schema'],
name=xml_data['title'],
xml_data=xml_content,
xml_data_id=xml_data_id
)
form_data.save()
request.session['curateFormData'] = str(form_data.id)
if 'form_id' in request.session:
del request.session['form_id']
if 'formString' in request.session:
del request.session['formString']
if 'xmlDocTree' in request.session:
del request.session['xmlDocTree']
except:
raise MDCSError("The document you are looking for doesn't exist.")
def test_getListNameFromDependencies_FormData(self):
FormData(template='test',
name='testFormData',
xml_data='testest',
user=str(1)).save()
self.assertEquals(
'testFormData',
getListNameFromDependencies(
list(FormData.objects(name='testFormData'))))
def setUpClass(cls):
super(ParserGenerateFormTestSuite, cls).setUpClass()
form_data = FormData()
form_data.name = 'generate_form_test'
form_data.user = '******'
form_data.template = 'none'
form_data.save()
cls.form_id = form_data.pk
def test_delete_template_with_dependencies(self):
template = self.createTemplate()
XMLdata(schemaID=str(template.id),
title='testRecord',
xml='<test>test xmldata</test>').save()
FormData(template=str(template.id),
name='testFormData',
xml_data='testest',
user=str(1)).save()
listDependencies = delete_template(str(template.id))
self.assertEquals(len(Template.objects()), 1)
self.assertEquals(len(TemplateVersion.objects()), 1)
self.assertEquals(listDependencies, 'testFormData, testRecord')
def createFormData(self,
user='',
template='',
name='',
xml_data=None,
xml_data_id=None):
countFormData = len(FormData.objects())
formData = FormData(user=str(user),
template=template,
name=name,
xml_data=xml_data,
xml_data_id=xml_data_id).save()
self.assertEquals(len(FormData.objects()), countFormData + 1)
return formData
def setUp(self):
schema_data = join('curate', 'tests', 'data', 'parser')
self.schema_data_handler = DataHandler(schema_data)
self.request = HttpRequest()
engine = import_module('django.contrib.sessions.backends.db')
session_key = None
self.request.session = engine.SessionStore(session_key)
self.request.session['curate_edit'] = False # Data edition
form_data = FormData()
form_data.name = ''
form_data.user = ''
form_data.template = ''
form_data.save()
self.request.session['curateFormData'] = form_data.pk
def curate_edit_data(request):
try:
if 'useForm' in request.GET and request.GET['useForm'] == 'true':
pass
else:
xml_data_id = request.GET['id']
request.session['curate_edit'] = True
# remove previously created forms when editing a new one
previous_forms = FormData.objects(user=str(request.user.id),
xml_data_id__exists=True,
isNewVersionOfRecord=False)
for previous_form in previous_forms:
if previous_form.schema_element_root is not None:
delete_branch_from_db(previous_form.schema_element_root.pk)
previous_form.delete()
#Check if a form_data already exists for this record
form_data = FormData.objects(xml_data_id=xml_data_id).all().first()
if not form_data:
xml_data = XMLdata.get(xml_data_id)
json_content = xml_data['content']
xml_content = XMLdata.unparse(json_content)
form_data = FormData(user=str(request.user.id),
template=xml_data['schema'],
name=xml_data['title'],
xml_data=xml_content,
xml_data_id=xml_data_id,
isNewVersionOfRecord=xml_data.get(
'ispublished', False))
form_data.save()
request.session['currentTemplateID'] = form_data.template
request.session['curate_edit_data'] = form_data.xml_data
request.session['curateFormData'] = str(form_data.pk)
if 'form_id' in request.session:
del request.session['form_id']
if 'xmlDocTree' in request.session:
del request.session['xmlDocTree']
except:
raise MDCSError("The document you are looking for doesn't exist.")
def sandbox_viewer(request):
user = request.user.id
request.session['curate_edit'] = False
template_id = request.GET.get("id", None)
if template_id is None:
message = "The template doesn't exist anymore."
add_message(request, WARNING, message)
return redirect(reverse("xsd_viewer"), locals())
request.session['currentTemplateID'] = template_id
request.session.modified = True
request.session['xmlDocTree'] = etree.tostring(
etree.parse(
BytesIO(
Template.objects.get(pk=template_id).content.encode('utf-8'))))
list_names = FormData.objects.values_list("name")
form_name = "form_sandbox" + str(ObjectId())
while form_name in list_names:
form_name = "form_sandbox" + str(ObjectId())
new_form = NewForm(request.POST)
form_data = FormData(user=str(user), template=template_id, name=form_name)
form_data.save()
form_data_sb = FormDataSandbox()
form_data_sb.form_data = form_data
form_data_sb.save()
request.session['curateFormData'] = str(form_data.id)
context = {
'edit': True,
'sandbox': True,
'curate_form': ['new'],
'document_name': [form_name]
}
if 'form_id' in request.session:
del request.session['form_id']
template = loader.get_template('curate/curate_enter_data.html')
return HttpResponse(template.render(context))
def curate_edit_data(request):
try:
xml_data_id = request.GET['id']
xml_data = XMLdata.get(xml_data_id)
json_content = xml_data['content']
xml_content = xmltodict.unparse(json_content)
request.session['curate_edit_data'] = xml_content
request.session['curate_edit'] = True
request.session['currentTemplateID'] = xml_data['schema']
# remove previously created forms when editing a new one
previous_forms = FormData.objects(user=str(request.user.id), xml_data_id__exists=True)
for previous_form in previous_forms:
# cascade delete references
for form_element_id in previous_form.elements.values():
try:
form_element = FormElement.objects().get(pk=form_element_id)
if form_element.xml_element is not None:
try:
xml_element = XMLElement.objects().get(pk=str(form_element.xml_element.id))
xml_element.delete()
except:
# raise an exception when element not found
pass
form_element.delete()
except:
# raise an exception when element not found
pass
previous_form.delete()
form_data = FormData(user=str(request.user.id), template=xml_data['schema'], name=xml_data['title'], xml_data=xml_content, xml_data_id=xml_data_id).save()
request.session['curateFormData'] = str(form_data.id)
if 'formString' in request.session:
del request.session['formString']
if 'xmlDocTree' in request.session:
del request.session['xmlDocTree']
except:
raise MDCSError("The document you are looking for doesn't exist.")
def start_curate(request):
if 'currentTemplateID' not in request.session and 'template' not in request.GET:
return redirect('/curate/select-template')
else:
if request.method == 'POST':
# parameters to build FormData object in db
user = request.user.id
template_id = request.session['currentTemplateID']
form_data = None
selected_option = request.POST['curate_form']
if selected_option == "new":
request.session['curate_edit'] = False
new_form = NewForm(request.POST)
try:
form_data = FormData(user=str(user),
template=template_id,
name=new_form.data['document_name'])
form_data.save()
except:
return HttpResponseBadRequest(
'Unable to create the form. A form with the same name may already exist.'
)
elif selected_option == "open":
request.session['curate_edit'] = True
open_form = OpenForm(request.POST)
form_data = FormData.objects.get(
pk=ObjectId(open_form.data['forms']))
elif selected_option == "upload":
request.session['curate_edit'] = True
upload_form = UploadForm(request.POST, request.FILES)
xml_file = request.FILES['file']
# put the cursor at the beginning of the file
xml_file.seek(0)
# read the content of the file
xml_data = xml_file.read()
# check XML data or not?
try:
etree.fromstring(xml_data)
except XMLSyntaxError:
return HttpResponseBadRequest(
'Uploaded File is not well formed XML.')
try:
form_data = FormData(user=str(user),
template=template_id,
name=xml_file.name,
xml_data=xml_data).save()
except:
return HttpResponseBadRequest(
'Unable to create the form. A form with the same name may already exist.'
)
# parameters that will be used during curation
request.session['curateFormData'] = str(form_data.id)
return HttpResponse('ok')
else:
try:
ajaxCall = False
context_params = dict()
if 'template' in request.GET:
schema_name = request.GET['template']
context_params['template_name'] = schema_name
try:
templates = Template.objects(title=schema_name)
except:
raise MDCSError(
"The template you are looking for doesn't exist.")
# if the schemas are all versions of the same schema
if len(set(templates.values_list('templateVersion'))) == 1:
template_id = TemplateVersion.objects().get(
pk=templates[0].templateVersion).current
request.session['currentTemplateID'] = template_id
else:
raise MDCSError(
"The selection of template by name can't be used if the MDCS contain more than "
"one template with the same name.")
template = loader.get_template(
'curate/curate_full_start.html')
if 'xmlDocTree' in request.session:
del request.session['xmlDocTree']
else:
ajaxCall = True
template = loader.get_template('curate/curate_start.html')
open_form = OpenForm(forms=FormData.objects(
user=str(request.user.id),
template=request.session['currentTemplateID'],
xml_data_id__exists=False))
new_form = NewForm()
upload_form = UploadForm()
context_params['new_form'] = new_form
context_params['open_form'] = open_form
context_params['upload_form'] = upload_form
context = RequestContext(
request,
context_params) # , 'options_form': options_form})
if ajaxCall:
return HttpResponse(json.dumps(
{'template': template.render(context)}),
content_type='application/javascript')
else:
return HttpResponse(template.render(context))
except MDCSError, e:
template = loader.get_template('curate/errors.html')
context = RequestContext(request, {
'errors': e.message,
})
return HttpResponse(template.render(context))
