def import_options(root):
elements = flat_xml_to_elements(root)
for element in filter_elements_by_type(elements, 'optionset'):
import_optionset(element)
for element in filter_elements_by_type(elements, 'option'):
import_option(element)
def post(self, request):
try:
uploaded_file = request.FILES['uploaded_file']
except KeyError:
return HttpResponseRedirect(self.get_success_url())
else:
import_tmpfile_name = handle_uploaded_file(uploaded_file)
root = read_xml_file(import_tmpfile_name)
if root is None:
logger.info('Xml parsing error. Import failed.')
return render(
request,
'core/error.html', {
'title':
_('Import error'),
'errors': [
_('The content of the xml file does not consist of well formed data or markup.'
)
]
},
status=400)
else:
try:
elements = flat_xml_to_elements(root)
except (KeyError, TypeError):
return render(
request,
'core/error.html', {
'title': _('Import error'),
'errors': [_('This is not a RDMO XML file.')]
},
status=400)
if check_permissions(elements, request.user):
# store information in session for ProjectCreateImportView
request.session['import_file_name'] = uploaded_file.name
request.session['import_tmpfile_name'] = import_tmpfile_name
request.session['import_success_url'] = self.get_success_url()
return render(
request, 'management/upload.html', {
'file_name': uploaded_file.name,
'elements': import_elements(elements)
})
else:
return render(request,
'core/error.html', {
'title': _('Import error'),
'errors': [_('Forbidden.')]
},
status=403)
def handle(self, *args, **options):
root = read_xml_file(options['xmlfile'])
if root is None:
raise CommandError(
_('The content of the xml file does not consist of well formed data or markup.'
))
elif root.tag != 'rdmo':
raise CommandError(_('This XML does not contain RDMO content.'))
else:
elements = flat_xml_to_elements(root)
save = {element.get('uri'): True for element in elements}
import_elements(elements, save=save)
def import_questions(root):
elements = flat_xml_to_elements(root)
for element in filter_elements_by_type(elements, 'catalog'):
import_catalog(element)
for element in filter_elements_by_type(elements, 'section'):
import_section(element)
for element in filter_elements_by_type(elements, 'questionset'):
import_questionset(element)
for element in filter_elements_by_type(elements, 'question'):
import_question(element)
def test_missing_parent(db, settings):
count = Option.objects.count()
xml_file = os.path.join(settings.BASE_DIR, 'xml',
'options-missing-parent.xml')
root = read_xml_file(xml_file)
elements = flat_xml_to_elements(root)
checked = {element.get('uri'): True for element in elements}
instances = import_elements(elements, parents={}, save=checked)
# one instance has an error
assert len([instance.errors for instance in instances
if instance.errors]) == 1
# no option has been imported
assert Option.objects.count() == count
def test_non_unique_path(db, settings):
count = Attribute.objects.count()
xml_file = os.path.join(settings.BASE_DIR, 'xml',
'domain-non-unique-path.xml')
root = read_xml_file(xml_file)
elements = flat_xml_to_elements(root)
checked = {element.get('uri'): True for element in elements}
instances = import_elements(elements, parents={}, save=checked)
# one instance has an error
assert len([instance.errors for instance in instances
if instance.errors]) == 1
# two instances have no error
assert len([
instance.errors for instance in instances if not instance.errors
]) == 2
# only 2 attributes have been imported
assert Attribute.objects.count() == count + 2
def test_import_post(db, settings, client, username, password, file_name):
client.login(username=username, password=password)
xml_file = os.path.join(settings.BASE_DIR, 'xml', file_name)
session = client.session
session['import_file_name'] = file_name
session['import_tmpfile_name'] = xml_file
session.save()
root = read_xml_file(xml_file)
elements = flat_xml_to_elements(root)
checked = [element.get('uri') for element in elements]
data = {uri: ['on'] for uri in checked}
url = reverse('import')
response = client.post(url, data)
assert response.status_code == status_map['import_post'][username]
if not password:
assert response.url.startswith('/account/login/'), response.content
def import_domain(root):
elements = flat_xml_to_elements(root)
for element in filter_elements_by_type(elements, 'attribute'):
import_attribute(element)
def post(self, request):
impor_file_name = request.session['import_file_name']
import_tmpfile_name = request.session.get('import_tmpfile_name')
# parse the form data, which is <uri: [parent, checked]> or <uri: [checked]>
parents = {}
checked = {}
for key, values in request.POST.lists():
if key.startswith('http'):
try:
parents[key] = None if values[0] == 'null' else values[0]
checked[key] = True if values[1] == 'on' else False
except IndexError:
parents[key] = False
checked[key] = True if values[0] == 'on' else False
root = read_xml_file(import_tmpfile_name)
if root is None:
logger.info('Xml parsing error. Import failed.')
return render(
request,
'core/error.html', {
'title':
_('Import error'),
'errors': [
_('The content of the xml file does not consist of well formed data or markup.'
)
]
},
status=400)
else:
try:
elements = flat_xml_to_elements(root)
except (KeyError, TypeError):
return render(
request,
'core/error.html', {
'title': _('Import error'),
'errors': [_('This is not a RDMO XML file.')]
},
status=400)
if check_permissions(elements, request.user):
if checked:
return render(
request, 'management/import.html', {
'file_name':
impor_file_name,
'elements':
import_elements(
elements, parents=parents, save=checked),
'success_url':
self.get_success_url()
})
else:
# if nothing was checked, just return to the success_url
return HttpResponseRedirect(self.get_success_url())
else:
return render(request,
'core/error.html', {
'title': _('Import error'),
'errors': [_('Forbidden.')]
},
status=403)
def import_conditions(root):
elements = flat_xml_to_elements(root)
for element in filter_elements_by_type(elements, 'condition'):
import_condition(element)
def import_views(root):
elements = flat_xml_to_elements(root)
for element in filter_elements_by_type(elements, 'view'):
import_view(element)
def import_tasks(root):
elements = flat_xml_to_elements(root)
for element in filter_elements_by_type(elements, 'task'):
import_task(element)
