from django.db import models
from entity.models import Entity
from OSSEval.utils import xmlMinidom
class Methodology(models.Model):
name = models.CharField(max_length=200)
description = models.CharField(max_length=2000,null=True,blank=True)
documentation = models.TextField(null=True,blank=True)
active = models.BooleanField(default=True)
# The entity type the methodology helps you assess
entity = models.ForeignKey(Entity)
def __unicode__(self):
return self.name
def from_xml(self, xmldoc, insert = True):
if not insert:
self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data
self.name = xmlMinidom.getString(xmldoc, 'Name')
print str(self.id) + " " + self.name
self.description = xmlMinidom.getString(xmldoc, 'Description')
self.documentation = xmlMinidom.getString(xmldoc, 'Documentation')
self.active = xmlMinidom.getString(xmldoc, 'Active')
e = Entity()
xml_entity = xmldoc.getElementsByTagName('Entity')[0]
e.from_xml(xml_entity, insert)
self.entity = e
# I save so I get the ID (if insert == True)
self.save()
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Name>" + self.name + "</Name>"
str_xml += "<Description>" + self.description + "</Description>"
str_xml += "<Documentation>" + self.documentation + "</Documentation>"
str_xml += "<Active>" + str(self.active) + "</Active>"
str_xml += self.entity.to_xml()
return "<Methodology>" + str_xml + "</Methodology>"
class MethodologyVersion(models.Model):
number = models.IntegerField()
created = models.DateField()
current = models.BooleanField(default=False)
methodology = models.ForeignKey(Methodology)
def __unicode__(self):
return self.methodology.name + " - " + str(self.number) + (" (Active version)" if self.current else "")
def from_xml(self, xmldoc, insert = True):
if not insert:
self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data
self.number = xmldoc.getElementsByTagName('Number')[0].firstChild.data
self.created = xmlMinidom.getString(xmldoc, 'Created')
self.current = xmlMinidom.getString(xmldoc, 'Current')
m = Methodology()
xml_methodology = xmldoc.getElementsByTagName('Methodology')[0]
m.from_xml(xml_methodology, insert)
self.methodology = m
# I save so I get the ID (if insert == True)
self.save()
# Pages
for xml_child in xmldoc.childNodes:
if xml_child.tagName == 'Pages':
xml_pages = xml_child
break
for xml_page in xml_pages.childNodes:
if xml_page.tagName == 'Page':
p = Page()
p.from_xml(xml_page, self, None, insert)
#WeightScenarios
xml_weight_scenarios = xmldoc.getElementsByTagName('WeightScenarios')
for xml_weight_scenario in xml_weight_scenarios:
ws = WeightScenario()
ws.from_xml(xml_weight_scenario, self, insert)
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Number>" + str(self.number) + "</Number>"
str_xml += "<Created>" + str(self.created) + "</Created>"
str_xml += "<Current>" + str(self.current) + "</Current>"
str_xml += self.methodology.to_xml()
str_xml += "<Pages>"
for page in self.page_set.all():
str_xml += page.to_xml()
str_xml += "</Pages>"
str_xml += "<WeightScenarios>"
for weight_scenario in self.weightscenario_set.all():
str_xml += weight_scenario.to_xml()
str_xml += "</WeightScenarios>"
return "<MethodologyVersion>" + str_xml + "</MethodologyVersion>"
class Page(models.Model):
name = models.CharField(max_length=200)
order = models.IntegerField(null=False,blank=False)
parent = models.ForeignKey('self',null=True,blank=True)
methodology_version = models.ForeignKey(MethodologyVersion,null=True,blank=True)
def __unicode__(self):
return self.name
def from_xml(self, xmldoc, methodology_version, parent_page, insert = True):
if not insert:
self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data
self.name = xmlMinidom.getString(xmldoc, 'Name')
self.order = xmldoc.getElementsByTagName('Order')[0].firstChild.data
if methodology_version is not None:
self.methodology_version = methodology_version
if parent_page is not None:
self.parent = parent_page
# Pages
for xml_child in xmldoc.childNodes:
if xml_child.tagName == 'Pages':
xml_pages = xml_child
break
for xml_page in xml_pages.childNodes:
if xml_page.tagName == 'Page':
p = Page()
p.from_xml(xml_page, None, self, insert)
# Questions
xml_questions = xmldoc.getElementsByTagName('Questions')
for xml_question in xml_questions:
q = Question()
q.from_xml(xml_question, self, insert)
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Name>" + self.name + "</Name>"
str_xml += "<Order>" + str(self.order) + "</Order>"
str_xml += "<Pages>"
for page in self.page_set.all():
str_xml += page.to_xml()
str_xml += "</Pages>"
str_xml += "<Questions>"
for question in self.question_set.all():
str_xml += question.to_xml()
str_xml += "</Questions>"
return "<Page>" + str_xml + "</Page>"
class QuestionType(models.Model):
name = models.CharField(max_length=200)
def from_xml(self, xmldoc, insert = True):
pass
def to_xml(self):
return "<QuestionType><Id>" + str(self.id) + "</Id><Name>" + self.name + "</Name></QuestionType>"
class Question(models.Model):
page = models.ForeignKey(Page)
text = models.CharField(max_length=200)
eval_description = models.TextField(null=True,blank=True)
eval_value = models.TextField(null=True,blank=True)
question_type = models.ForeignKey(QuestionType)
def __unicode__(self):
return self.page.name + " - " + self.text
def from_xml(self, xmldoc, page, insert = True):
pass
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Text>" + self.text + "</Text>"
str_xml += "<EvalDescription>" + ("" if self.eval_description is None else self.eval_description) + "</EvalDescription>"
str_xml += "<EvalValue>" + ("" if self.eval_value is None else self.eval_value) + "</EvalValue>"
str_xml += self.question_type.to_xml()
str_xml += "<Queries>"
for query in self.query_set.all():
str_xml += query.to_xml()
for choice in self.choice_set.all():
str_xml += choice.to_xml()
str_xml += "</Queries>"
return "<Question>" + str_xml + "</Question>"
class Query(models.Model):
'''
Queries against web search engines used to automate the answer to a question and/or as a hint to the reviewer
'''
question = models.ForeignKey(Question)
eval_text = models.CharField(max_length=2000)
eval_site = models.CharField(max_length=2000)
eval_site_exclude = models.CharField(max_length=2000)
def from_xml(self, xmldoc, insert = True):
pass
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<EvalText>" + self.eval_text + "</EvalText>"
str_xml += "<EvalSite>" + self.eval_site + "</EvalSite>"
str_xml += "<EvalSiteExclude>" + self.eval_site_exclude + "</EvalSiteExclude>"
return "<Query>" + str_xml + "</Query>"
class Choice(models.Model):
'''
'''
question = models.ForeignKey(Question)
text = models.CharField(max_length=200)
order = models.IntegerField()
todo = models.CharField(max_length=2000)
def from_xml(self, xmldoc, insert = True):
pass
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Text>" + self.text + "</Text>"
str_xml += "<Order>" + str(self.order) + "</Order>"
str_xml += "<Todo>" + self.todo + "</Todo>"
return "<Choice>" + str_xml + "</Choice>"
class WeightScenario(models.Model):
name = models.CharField(max_length=200)
methodology_version = models.ForeignKey(MethodologyVersion)
active = models.BooleanField(blank=False)
def from_xml(self, xmldoc, methodology_version, insert = True):
self.methodology_version = methodology_version
pass
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Name>" + self.name + "</Name>"
str_xml += "<Active>" + str(self.active) + "</Active>"
str_xml += "<Weights>"
for weight in self.weight_set.all():
str_xml += weight.to_xml()
str_xml += "</Weights>"
return "<WeightScenario>" + str_xml + "</WeightScenario>"
class Weight(models.Model):
question = models.ForeignKey(Question)
weight = models.FloatField()
scenario = models.ForeignKey(WeightScenario)
def from_xml(self, xmldoc, insert = True):
pass
def to_xml(self):
str_xml = "<Id>" + str(self.id) + "</Id>"
str_xml += "<Active>" + self.active + "</Active>"
str_xml += "<Weights>"
for weight in self.weight_set.all():
str_xml += weight.to_xml()
str_xml += "</Weights>"
return "<WeightScenario>" + str_xml + "</WeightScenario>"