# This Source Code Form of OSSEval is subject to the terms of the GNU AFFERO
# GENERAL PUBLIC LICENSE, v. 3.0. If a copy of the AGPL was not
# distributed with this file, You can obtain one at http://www.gnu.org/licenses/agpl.txt
#
# OSSeval is powered by the SOS Open Source AGPL edition.
# The AGPL requires that you do not remove the SOS Open Source attribution and copyright
# notices from the user interface (see section 5.d below).
# Commercial licenses are available and do not require any SOS Open Source attributions
# or visible copyright notices but they are not permitted under this license.
# OSSEval Copyright 2014 Bitergium SLL
# SOS Open Source Copyright 2012 Roberto Galoppini
# Author: Davide Galletti
from django.conf import settings
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render, get_object_or_404, render_to_response, redirect
from django.template import RequestContext
from django.utils import simplejson, timezone
from django.views.generic import ListView
from xml.dom import minidom
from forms import AnalysisForm, UploadFileForm, ImportChoice
from analysis.models import Analysis, Instance, UploadedFile, Answer, Methodology, MethodologyVersion, Question, Page
#from methodology.models import Methodology, MethodologyVersion, Question, Page
from OSSEval.utils import xmlMinidom, TrivialJSONEncoder, SearchEngine
def analysis_new(request):
if request.method == "POST":
form = AnalysisForm(request.POST)
if form.is_valid():
if reverse('analysis_new') in request.META['HTTP_REFERER']:
# creating a new
model_instance = form.save()
model_instance.visible = True
weight_scenarios = model_instance.methodology_version.weightscenario_set.filter(active=True)
if len(weight_scenarios) == 1:
model_instance.weight_scenario = weight_scenarios[0]
else:
raise Exception("There should be exactly one active WeightScenario for MethodologyVersion " + str(model_instance.methodology_version.id))
model_instance.protected = False
model_instance.created = timezone.now()
model_instance.save()
return HttpResponseRedirect(reverse('analysis_detail', args=(model_instance.pk,)))
else:
# editing an existing one
id = request.META['HTTP_REFERER'].rsplit('/')[len(request.META['HTTP_REFERER'].rsplit('/'))-1]
a = Analysis.objects.get(pk = id)
a.name = form.cleaned_data['name']
a.description = form.cleaned_data['description']
a.comment = form.cleaned_data['comment']
a.created = form.cleaned_data['created']
a.methodology_version = form.cleaned_data['methodology_version']
a.user_login = form.cleaned_data['user_login']
a.visible = form.cleaned_data['visible']
a.protected = form.cleaned_data['protected']
a.save()
return HttpResponseRedirect(reverse('analysis_detail', args=(a.id,)))
else:
form = AnalysisForm()
return render(request, 'analysis/analysis_new.html', {'form': form})
def analysis_edit(request, analysis_id):
if request.method == "POST":
form = AnalysisForm(request.POST)
if form.is_valid():
model_instance = form.save()
model_instance.visible = True
weight_scenarios = model_instance.methodology_version.weightscenario_set.filter(active=True)
if len(weight_scenarios) == 1:
model_instance.weight_scenario = weight_scenarios[0]
else:
raise Exception("There should be exactly one active WeightScenario for MethodologyVersion " + str(model_instance.methodology_version.id))
model_instance.protected = False
model_instance.created = timezone.now()
model_instance.save()
return HttpResponseRedirect(reverse('analysis_list'))
return render(request, 'analysis/analysis_edit.html', {'form': form})
else:
analysis = get_object_or_404(Analysis, pk=analysis_id)
form = AnalysisForm(request.POST or None, instance = analysis)
return render(request, 'analysis/analysis_edit.html', {'form': form, 'analysis': analysis})
class AnalysisList(ListView):
queryset = Analysis.objects.order_by('-created')
context_object_name = 'analises_list'
def detail(request, analysis_id):
analysis = get_object_or_404(Analysis, pk=analysis_id)
entity = analysis.methodology_version.methodology.entity
weight_scenarios = analysis.methodology_version.weightscenario_set.all()
exec("from " + entity.actual_entity_app + ".views import search_html_form, instance_list_html")
#"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"):]
return render(request, 'analysis/analysis_detail.html', {'analysis': analysis, 'analysis_detail': analysis_detail, 'search_html_ui': search_html_ui, 'weight_scenarios': weight_scenarios})
def analysis_questions(request, analysis_id):
analysis = get_object_or_404(Analysis, pk=analysis_id)
weight_scenarios = analysis.methodology_version.weightscenario_set.all()
entity = analysis.methodology_version.methodology.entity
exec("from " + entity.actual_entity_app + ".views import search_html_form, instance_list_html")
#"Content-Type: text/html; charset=utf-8" has to be removed as these methods return just a partial
analysis_detail = str(instance_list_html(request, analysis_id))[len("Content-Type: text/html; charset=utf-8"):]
return render(request, 'analysis/analysis_questions.html', {'analysis': analysis, 'analysis_detail': analysis_detail, 'methodology_version': analysis.methodology_version, 'weight_scenarios': weight_scenarios})
def analysis_report(request, analysis_id, weight_scenario_id = 0):
analysis = get_object_or_404(Analysis, pk=analysis_id)
weight_scenario = analysis.calculate_scores(weight_scenario_id)
td_width = 100 / (1 + len(analysis.instance_set.all()))
trend_script = "<script type=\"text/javascript\" src=\"//www.google.com/trends/embed.js?hl=it&q="
comma = ""
for instance in analysis.instance_set.all():
trend_script += comma + instance.name
comma = ","
trend_script += "&cmpt=q&content=1&cid=TIMESERIES_GRAPH_0&export=5&w=500&h=330\"></script>"
return render(request, 'analysis/analysis_report.html', {'analysis': analysis, 'td_width': td_width, 'trend_script': trend_script, 'weight_scenario': weight_scenario})
def save_answer(request):
try:
question_id = request.POST.get("question_id", "")
id_selected_instance = request.POST.get("id_selected_instance", "")
value = request.POST.get("value", "")
notes = request.POST.get("notes", "")
# I look for an answer for the same question and instance
try:
a = Answer.objects.get(instance_id=id_selected_instance, question_id=question_id)
except:
# I didn't find one; let's create it
a = Answer()
a.instance = Instance.objects.get(pk=id_selected_instance)
a.question = Question.objects.get(pk=question_id)
a.value_integer = value
a.notes = notes
a.save()
except Exception as ex:
return HttpResponse(simplejson.dumps({'response': ex.message}))
return HttpResponse(simplejson.dumps({'response': 'OK', 'question_id': question_id}))
def get_answers(request):
id_instance = request.GET.get("id_instance", "")
answers = Answer.objects.filter(instance_id=id_instance)
return HttpResponse(TrivialJSONEncoder().encode(list(answers)))
def get_metadata(request):
metadata = []
id_instance = request.GET.get("id_instance", "")
instance = Instance.objects.get(pk = id_instance)
entity = instance.analysis.methodology_version.methodology.entity
#list of questions; just a plain list, I do not care in which page they are
list_of_questions = []
pages = Page.objects.filter(methodology_version = instance.analysis.methodology_version)
for page in pages:
list_of_questions += page.questions()
#all metadata about this instance
i = instance.actual_instance.getInstanceInfo()
#eval python; python code assumes that all the information is in a structure called "i" which stands for "instance"
for question in list_of_questions:
description = ""
value = -1
#run queries on search engine
for query in question.query_set.all():
description=""
# eval_text defines the variable "description"
exec(query.eval_text)
sites = []
# eval_site defines the variable "sites"
exec(query.eval_site)
search_count = str(SearchEngine.search_count(q, sites))
search_url = SearchEngine.search_url(q, sites)
search_engine_name = SearchEngine.search__engine_name()
description += "<a target='_blank' href='" + search_url + "'>'" + SearchEngine.readable_query(q, sites) + "' on " + search_engine_name + ": (" + search_count + " results)</a><br>"
# eval_description and eval_value might use the results from the above queries so have to be run after them
exec(question.eval_description)
exec(question.eval_value)
q = {}
q["question_id"] = question.id
print "question.id: " + str(question.id)
q["description"] = description
q["value"] = value
metadata.append(q)
#restituire la lista delle domande con le elaborazioni allegate
# answers = Answer.objects.filter(instance_id=id_instance)
return HttpResponse(TrivialJSONEncoder().encode(list(metadata)))
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')
try:
analysis_on_file.id = int(analysis_xml[0].attributes["Id"].firstChild.data)
analysis_on_file.name = analysis_xml[0].attributes["Name"].firstChild.data
analysis_on_file.created = analysis_xml[0].attributes["Created"].firstChild.data
analysis_on_file.user_login = analysis_xml[0].attributes["UserLogin"].firstChild.data
except:
# no analysis in the import file
pass
analysis_on_db = Analysis()
if analysis_on_file.id:
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 = xmlMinidom.getNaturalAttribute(methodology_version_xml, 'Id')
methodology_version_on_file.number = methodology_version_xml[0].attributes["Number"].firstChild.data
methodology_xml = methodology_version_xml[0].getElementsByTagName('Methodology')
methodology_on_file.id = xmlMinidom.getNaturalAttribute(methodology_xml, 'Id')
methodology_on_file.name = methodology_xml[0].attributes["Name"].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.attributes["Id"].firstChild.data
a = Analysis()
a.methodology_version = mv
if import_analysis:
analysis_xml = xmldoc.getElementsByTagName('Analysis')[0]
a.from_xml(analysis_xml, always_insert)
return HttpResponseRedirect(reverse('analysis_detail', args=(a.id,)))
else:
return HttpResponseRedirect(reverse('analysis_list'))