Add frontend part of the domain import

rdmo/domain/forms.py

@@ -0,0 +1,7 @@
+from django import forms
+
+
+class UploadFileForm(forms.Form):
+    uploaded_file = forms.FileField(
+        label='Select a file',
+    )

rdmo/domain/imports.py

@@ -0,0 +1,129 @@
+from rdmo.core.utils import get_ns_tag
+from rdmo.conditions.models import Condition
+from rdmo.options.models import OptionSet
+
+from .models import AttributeEntity, Attribute, Range, VerboseName
+
+
+def import_domain(domain_node):
+
+    nsmap = domain_node.nsmap
+
+    for entity_node in domain_node.iterchildren():
+
+        if entity_node.tag == 'entity':
+            import_attribute_entity(entity_node, nsmap)
+        else:
+            import_attribute(entity_node, nsmap)
+
+
+def import_attribute_entity(entity_node, nsmap, parent=None):
+
+    uri = entity_node[get_ns_tag('dc:uri', nsmap)].text
+
+    try:
+        entity = AttributeEntity.objects.get(uri=uri, parent=parent)
+    except AttributeEntity.DoesNotExist:
+        entity = AttributeEntity()
+
+    entity.parent = parent
+    entity.uri_prefix = uri.split('/domain/')[0]
+    entity.key = uri.split('/')[-1]
+    entity.comment = entity_node[get_ns_tag('dc:comment', nsmap)]
+    entity.is_collection = entity_node['is_collection'] == 'True'
+    entity.save()
+
+    if hasattr(entity_node, 'verbosename'):
+        import_verbose_name(entity_node.verbosename, entity)
+
+    if hasattr(entity_node, 'conditions'):
+        for condition_node in entity_node.conditions.iterchildren():
+            try:
+                condition_uri = condition_node.get(get_ns_tag('dc:uri', nsmap))
+                condition = Condition.objects.get(uri=condition_uri)
+                entity.conditions.add(condition)
+            except Condition.DoesNotExist:
+                pass
+
+    if hasattr(entity_node, 'children'):
+        for child_node in entity_node.children.iterchildren():
+            if child_node.tag == 'entity':
+                import_attribute_entity(child_node, nsmap, parent=entity)
+            else:
+                import_attribute(child_node, nsmap, parent=entity)
+
+
+def import_attribute(attribute_node, nsmap, parent=None):
+
+    uri = attribute_node[get_ns_tag('dc:uri', nsmap)].text
+
+    try:
+        attribute = Attribute.objects.get(uri=uri)
+    except Attribute.DoesNotExist:
+        attribute = Attribute()
+
+    attribute.parent = parent
+    attribute.uri_prefix = uri.split('/domain/')[0]
+    attribute.key = uri.split('/')[-1]
+    attribute.comment = attribute_node[get_ns_tag('dc:comment', nsmap)]
+    attribute.is_collection = attribute_node['is_collection'] == 'True'
+    attribute.value_type = attribute_node['value_type']
+    attribute.unit = attribute_node['unit']
+    attribute.save()
+
+    if hasattr(attribute_node, 'range'):
+        import_verbose_name(attribute_node.range, attribute)
+
+    if hasattr(attribute_node, 'verbosename'):
+        import_verbose_name(attribute_node.verbosename, attribute)
+
+    if hasattr(attribute_node, 'optionsets'):
+        for optionset_node in attribute_node.optionsets.iterchildren():
+            try:
+                optionset_uri = optionset_node.get(get_ns_tag('dc:uri', nsmap))
+                optionset = OptionSet.objects.get(uri=optionset_uri)
+                attribute.optionsets.add(optionset)
+            except OptionSet.DoesNotExist:
+                pass
+
+    if hasattr(attribute_node, 'conditions'):
+        for condition_node in attribute_node.conditions.iterchildren():
+            try:
+                condition_uri = condition_node.get(get_ns_tag('dc:uri', nsmap))
+                condition = Condition.objects.get(uri=condition_uri)
+                attribute.conditions.add(condition)
+            except Condition.DoesNotExist:
+                pass
+
+
+def import_verbose_name(verbosename_node, entity):
+    if verbosename_node is not None:
+        try:
+            try:
+                verbosename = VerboseName.objects.get(attribute_entity=entity)
+            except VerboseName.DoesNotExist:
+                verbosename = VerboseName(attribute_entity=entity)
+
+            for element in verbosename_node['name']:
+                setattr(verbosename, 'name_' + element.get('lang'), element.text)
+            for element in verbosename_node['name_plural']:
+                setattr(verbosename, 'name_plural_' + element.get('lang'), element.text)
+            verbosename.save()
+        except AttributeError:
+            pass
+
+
+def import_range(range_node, attribute):
+    if range_node is not None:
+        try:
+            try:
+                range = Range.objects.get(attribute=attribute)
+            except Range.DoesNotExist:
+                range = Range(attribute=attribute)
+
+            range.minimum = range_node['minimum']
+            range.maximum = range_node['maximum']
+            range.step = range_node['step']
+            range.save()
+        except AttributeError:
+            pass

rdmo/domain/urls.py

@@ -2,7 +2,7 @@
 
 from rest_framework import routers
 
-from .views import DomainView, DomainExportView
+from .views import DomainView, DomainExportView, DomainImportXMLView
 from .viewsets import (
     AttributeEntityViewSet,
     AttributeViewSet,
@@ -20,6 +20,8 @@
 domain_patterns = [
     url(r'^$', DomainView.as_view(), name='domain'),
     url(r'^export/(?P<format>[a-z]+)/$', DomainExportView.as_view(), name='domain_export'),
+    # TODO: change link below when there is a real function to use
+    url(r'^import/(?P<format>[a-z]+)/$', DomainImportXMLView.as_view(), name='domain_import'),
 ]
 
 # internal AJAX API

rdmo/domain/views.py

@@ -1,15 +1,24 @@
+import logging
 from django.conf import settings
-from django.http import HttpResponse
+from django.contrib import messages
+from django.contrib.auth.models import User
+from django.http import HttpResponse, HttpResponseRedirect
+from django.shortcuts import render
 from django.utils.translation import ugettext_lazy as _
 from django.views.generic import TemplateView, ListView
 
-from rdmo.core.views import ModelPermissionMixin
+from rdmo.core.imports import handle_uploaded_file, validate_xml
+from rdmo.domain.imports import import_domain
+from rdmo.core.views import ModelPermissionMixin, ObjectPermissionMixin
 from rdmo.core.utils import get_model_field_meta, render_to_format, render_to_csv
 
-from .models import AttributeEntity, Attribute, VerboseName, Range
+from .forms import UploadFileForm
+from .models import AttributeEntity, Attribute, Range, VerboseName
 from .serializers.export import AttributeEntitySerializer as ExportSerializer
 from .renderers import XMLRenderer
 
+log = logging.getLogger(__name__)
+
 
 class DomainView(ModelPermissionMixin, TemplateView):
     template_name = 'domain/domain.html'
@@ -59,3 +68,40 @@ def render_to_response(self, context, **response_kwargs):
             return render_to_csv(self.request, _('Domain'), rows)
         else:
             return render_to_format(self.request, format, _('Domain'), 'domain/domain_export.html', context)
+
+
+class DomainImportXMLView(ObjectPermissionMixin, TemplateView):
+    # model = Project
+    permission_required = 'projects.export_project_object'
+    # form_class = ProjectForm
+    success_url = '/'
+    template_name = 'projects/project_upload.html'
+
+    def get(self, request, *args, **kwargs):
+        form = UploadFileForm()
+        return render(request, self.template_name, {'form': form})
+
+    def post(self, request, *args, **kwargs):
+        # context = self.get_context_data(**kwargs)
+        tempfilename = handle_uploaded_file(request.FILES['uploaded_file'])
+        exit_code, xmltree = validate_xml(tempfilename, 'project')
+        if exit_code == 0:
+            self.importProject(xmltree, request)
+            return HttpResponseRedirect(self.success_url)
+        else:
+            log.info('Xml parsing error. Import failed.')
+            return HttpResponse('Xml parsing error. Import failed.')
+
+    def form_valid(self, form, request, *args, **kwargs):
+        form.save(commit=True)
+        messages.success(request, 'File uploaded!')
+        # return super(ProjectImportXMLView, self).form_valid(form)
+        return
+
+    def importProject(self, xml_root, request):
+        try:
+            user = request.user
+        except User.DoesNotExist:
+            log.info('Unable to detect user name. Import failed.')
+        else:
+            import_domain(xml_root, user)