Open Source Projects Europe

from django.conf import settings

from django.core.urlresolvers import reverse

from django.http import HttpResponseRedirect

from django.template import RequestContext

from xml.dom import minidom

from forms import AnalysisForm, UploadFileForm, ImportChoice

from analysis.models import Analysis, UploadedFile

from methodology.models import Methodology, MethodologyVersion

def analysis_new(request, analysis_id=0):

    if analysis_id>0:

        analysis = get_object_or_404(Analysis, pk=analysis_id)

        form = AnalysisForm(instance = analysis)

    else:

        form = AnalysisForm()

    return render(request, 'analysis/analysis_new.html', {'form': form})

    #"Content-Type: text/html; charset=utf-8" has to be removed as these methods return just a partial

    search_html_ui = str(search_html_form(request, analysis_id))[len("Content-Type: text/html; charset=utf-8"):]

    analysis_detail = str(instance_list_html(request, analysis_id))[len("Content-Type: text/html; charset=utf-8"):]

def export(request, analysis_id):

    a = get_object_or_404(Analysis, pk=analysis_id)

    mv = a.methodology_version

    exported_xml = "<osseval>" + a.to_xml() + mv.to_xml() + "</osseval>"

    return render(request, 'analysis/export.xml', {'xml': exported_xml}, content_type="application/xhtml+xml")

def upload_page(request):

    message = ''

    if request.method == 'POST':

        form = UploadFileForm(request.POST, request.FILES)

        if form.is_valid():

            xml_uploaded = request.FILES['file'].read()

            new_uploaded_file = UploadedFile(docfile = request.FILES['file'])

            # we save it on disk so that we can process it after the user has told us which part to import and how to import it

            new_uploaded_file.save()

            # we parse it so that we check what is on the file against what is on the database and we show this info to the user

            try:

                xmldoc = minidom.parseString(xml_uploaded)

                analysis_on_file = Analysis()

                analysis_xml = xmldoc.getElementsByTagName('Analysis')

                analysis_on_file.id = int(analysis_xml[0].getElementsByTagName('Id')[0].firstChild.data)

                analysis_on_file.name = analysis_xml[0].getElementsByTagName('Name')[0].firstChild.data

                analysis_on_file.created = analysis_xml[0].getElementsByTagName('Created')[0].firstChild.data

                analysis_on_file.user_login = analysis_xml[0].getElementsByTagName('UserLogin')[0].firstChild.data

                analysis_on_db = Analysis()

                try: 

                    analysis_on_db = Analysis.objects.get(pk=analysis_on_file.id)

                except:

                    pass

                methodology_on_file = Methodology()

                methodology_version_on_file = MethodologyVersion()

                methodology_version_on_file.methodology = methodology_on_file

                methodology_version_xml = xmldoc.getElementsByTagName('MethodologyVersion')

                methodology_version_on_file.id = methodology_version_xml[0].getElementsByTagName('Id')[0].firstChild.data

                methodology_version_on_file.number = methodology_version_xml[0].getElementsByTagName('Number')[0].firstChild.data

                methodology_xml = methodology_version_xml[0].getElementsByTagName('Methodology')

                methodology_on_file.id = methodology_xml[0].getElementsByTagName('Id')[0].firstChild.data

                methodology_on_file.name = methodology_xml[0].getElementsByTagName('Name')[0].firstChild.data

                analysis_on_file.methodology_version = methodology_version_on_file

                import_choice_form = ImportChoice(initial={'uploaded_file_id': new_uploaded_file.id, 'new_uploaded_file_relpath': new_uploaded_file.docfile.url}) # An unbound form

                return render(request, 'analysis/import_file.html', {'prettyxml': xmldoc.toprettyxml(indent="    "),'file': request.FILES['file'], 'analysis_on_file': analysis_on_file, 'analysis_on_db': analysis_on_db, 'new_uploaded_file': new_uploaded_file, 'import_choice_form': import_choice_form})

            except Exception as ex:

                message = 'Error parsing uploaded file: ' + str(ex)

    else:

        form = UploadFileForm()

    return render_to_response('analysis/upload_page.html', {'form': form, 'message': message}, context_instance=RequestContext(request))

def perform_import(request):

    new_uploaded_file_relpath = request.POST["new_uploaded_file_relpath"]

    # how_to_import = true ==> always_insert 

    always_insert = (int(request.POST.get("how_to_import", "")) == 1)

    import_methodology = request.POST.get("import_methodology", "")

    import_analysis = request.POST.get("import_analysis", "")

    with open(settings.BASE_DIR + "/" + new_uploaded_file_relpath, 'r') as content_file:

        xml_uploaded = content_file.read()

    xmldoc = minidom.parseString(xml_uploaded)

    # I assume there's only one

    methodology_version_xml = xmldoc.getElementsByTagName('MethodologyVersion')[0]

    mv = MethodologyVersion()

    if import_methodology:

        mv.from_xml(methodology_version_xml, always_insert)

    else:

        #If I am not importing the methodology I still need to associate it to the analysis

        mv.id = methodology_version_xml.getElementsByTagName('Id')[0].firstChild.data

    a = Analysis()

    a.methodology_version = mv

    analysis_xml = xmldoc.getElementsByTagName('Analysis')[0]

    if import_analysis:

        a.from_xml(analysis_xml, always_insert)

    else:

        a.id = analysis_xml.getElementsByTagName('Id')[0].firstChild.data

    return HttpResponseRedirect(reverse('analysis_detail', args=(a.id,)))

#     what_to_import = request.POST.get("what_to_import", "")

#     

#     uf = UploadedFile.objects.get(pk=uploaded_file_id)

#     response = urllib2.urlopen(uf.docfile.url)

#     xml = response.read()

#     from forms.ImportChoice

#     HOW_TO_IMPORT = [['0','Update if ID exists, create if ID is empty or non existent'],['1','Always create new records']]

#     WHAT_TO_IMPORT = [['0','Import methodology'],['1','Import analysis']]

#     if how_to_import == 0:

#         

#     else:

#     xml_uploaded = request.FILES['file'].read()

#     uploaded_file_id = UploadedFile(docfile = request.FILES['file'])

#     HOW_TO_IMPORT = [['0','Update if ID exists, create if ID is empty or non existent'],['1','Always create new records']]

#     WHAT_TO_IMPORT = [['0','Import methodology'],['1','Import analysis']]

#     how_to_import = forms.ChoiceField( widget=RadioSelect(), choices=HOW_TO_IMPORT)

#     what_to_import = forms.MultipleChoiceField(required=False, widget=forms.CheckboxSelectMultiple, choices=WHAT_TO_IMPORT, label='What to import (select at least one):')

#     uploaded_file_id = forms.CharField(widget=forms.HiddenInput())