OSSEval / Code / Diff of /OSSEval/methodology/models.py

Diff of /OSSEval/methodology/models.py [77e4cc] .. [d5fd9f]

Switch to unified view


from django.db import models
from entity.models import Entity
from OSSEval.utils import xmlMinidom
from xml.dom.minidom import Node

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)
...
    def __unicode__(self):
        return self.name
    
    def from_xml(self, xmldoc, insert = True):
        if not insert:
            self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.name = xmlMinidom.getStringAttribute(xmldoc, 'Name')

        self.description = xmlMinidom.getString(xmldoc, 'Description')
        self.documentation = xmlMinidom.getString(xmldoc, 'Documentation')
        self.active = xmlMinidom.getStringAttribute(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 = "<Description><![CDATA[" + self.description + "]]></Description>"
        str_xml += "<Documentation><![CDATA[" + self.documentation + "]]></Documentation>"

        str_xml += self.entity.to_xml()
        return '<Methodology Id="' + str(self.id) + '" Name="' + self.name + '" Active="' + str(self.active) + '">' + str_xml + "</Methodology>"


class MethodologyVersion(models.Model):
    number = models.IntegerField()
    created = models.DateField() 
    current = models.BooleanField(default=False)
...
    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 = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.number = xmldoc.attributes["Number"].firstChild.data
        self.created = xmlMinidom.getStringAttribute(xmldoc, 'Created')
        self.current = xmlMinidom.getStringAttribute(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:
            # Some nodes are text nodes (e.g. u'\n     ') I need to look just at ELEMENT_NODE
            if xml_child.nodeType == Node.ELEMENT_NODE and xml_child.tagName == 'Pages':
                xml_pages = xml_child
                break
        for xml_page in xml_pages.childNodes:
            if xml_page.nodeType == Node.ELEMENT_NODE and 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 = 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 Id="' + str(self.id) + '" Number="' + str(self.number) + '" Created="' + str(self.created) + '" Current="' + str(self.current) + '">' + 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)
...
    def __unicode__(self):
        return self.name
    
    def from_xml(self, xmldoc, methodology_version, parent_page, insert = True):
        if not insert:
            self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.name = xmlMinidom.getStringAttribute(xmldoc, 'Name')
        self.order = xmldoc.attributes["Order"].firstChild.data
        if methodology_version is not None:
            self.methodology_version = methodology_version
        if parent_page is not None:
#            print self.name + " is a child of " + parent_page.name
            self.parent = parent_page
        self.save()
        # Pages
        for xml_child in xmldoc.childNodes:
            # Some nodes are text nodes (e.g. u'\n     ') I need to look just at ELEMENT_NODE
            if xml_child.nodeType == Node.ELEMENT_NODE and xml_child.tagName == 'Pages':
                xml_pages = xml_child
                break
        for xml_page in xml_pages.childNodes:
            if xml_page.nodeType == Node.ELEMENT_NODE and xml_page.tagName == 'Page':
                p = Page()
                p.from_xml(xml_page, None, self, insert)
        # Questions
        for xml_child in xmldoc.childNodes:
            # Some nodes are text nodes (e.g. u'\n     ') I need to look just at ELEMENT_NODE
            if xml_child.nodeType == Node.ELEMENT_NODE and xml_child.tagName == 'Questions':
                xml_questions = xml_child
                break
        for xml_question in xml_questions.childNodes:
            if xml_question.nodeType == Node.ELEMENT_NODE and xml_question.tagName == 'Question':
                q = Question()
                q.from_xml(xml_question, self, insert)
        
    def to_xml(self):



        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 Id="' + str(self.id) + '" Name="' + self.name + '" Order="' + str(self.order) + '">' + str_xml + "</Page>"

    class Meta:
        ordering = ['order']

class QuestionType(models.Model):
    name = models.CharField(max_length=200)
    
    def from_xml(self, xmldoc, insert = True):
        if not insert:
            self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.name = xmlMinidom.getStringAttribute(xmldoc, 'Name')
    
    def to_xml(self):
        return '<QuestionType Id="' + str(self.id) + '" Name="' + self.name + '"/>'
    
class Question(models.Model):
    page = models.ForeignKey(Page)
    text = models.CharField(max_length=200)
    order = models.IntegerField()
    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):
        if not insert:
            self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.text = xmlMinidom.getStringAttribute(xmldoc, 'Text')
        self.order = xmlMinidom.getNaturalAttribute(xmldoc, 'Order')
        #Do so that QuestionType default is 1
        qt = QuestionType.objects.get(pk=1)
        self.page = page
        self.question_type = qt
        self.save()
        # Queries
        xml_queries = xmldoc.getElementsByTagName('Query')
        for xml_query in xml_queries:
            q = Query()
            q.from_xml(xml_query, self, insert)
        # Choices
        xml_choices = xmldoc.getElementsByTagName('Choice')
        for xml_choice in xml_choices:
            c = Choice()
            c.from_xml(xml_choice, self, insert)
        self.eval_description = xmlMinidom.getString(xmldoc, 'EvalDescription')
        self.eval_value = xmlMinidom.getString(xmldoc, 'EvalValue')
        

    def to_xml(self):


        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>"
#         We do not use question_type at the moment as we have just one type
#         str_xml += self.question_type.to_xml()
        str_xml += "<Queries>"
        for query in self.query_set.all():
            str_xml += query.to_xml()
        str_xml += "</Queries>"
        str_xml += "<Choices>"
        for choice in self.choice_set.all():
            str_xml += choice.to_xml()
        str_xml += "</Choices>"
        return '<Question Id="' + str(self.id) + '" Text="' + self.text + '" Order="' + str(self.order) + '">' + str_xml + '</Question>'

    class Meta:
        ordering = ['order']

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, question, insert = True):
        if not insert:
            self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.question = question
        self.eval_text = xmlMinidom.getString(xmldoc, 'EvalText')
        self.eval_site = xmlMinidom.getString(xmldoc, 'EvalSite')
        self.eval_site_exclude = xmlMinidom.getString(xmldoc, 'EvalSiteExclude')
        self.save()
        

    def to_xml(self):

        str_xml = "<EvalText>" + self.eval_text + "</EvalText>"
        str_xml += "<EvalSite>" + self.eval_site + "</EvalSite>"
        str_xml += "<EvalSiteExclude>" + self.eval_site_exclude + "</EvalSiteExclude>"
        return '<Query Id="' + str(self.id) + '">' + 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, question, insert = True):
        if not insert:
            self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
        self.question = question
        self.text = xmlMinidom.getStringAttribute(xmldoc, 'Text')
        self.order = xmlMinidom.getNaturalAttribute(xmldoc, 'Order')
        self.todo = xmlMinidom.getString(xmldoc, 'Todo')
        self.save()
    
    def to_xml(self):



        str_xml = "<Todo>" + self.todo + "</Todo>"
        return '<Choice Id="' + str(self.id) + '" Text="' + self.text + '" Order="' + str(self.order) + '">' + str_xml + '</Choice>'

    class Meta:
        ordering = ['order']

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 = "<Weights>"
        for weight in self.weight_set.all():
            str_xml += weight.to_xml()
        str_xml += "</Weights>"
        return '<WeightScenario Id="' + str(self.id) + '" Name="' + self.name + '" Active="' + str(self.active) + '">' + str_xml + '</WeightScenario>'

class Weight(models.Model):
    question = models.ForeignKey(Question)
    weight = models.FloatField()
    scenario = models.ForeignKey(WeightScenario)
...
        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 '<Weight Id="' + str(self.id) + '" Active="' + str(self.active) + '">' + str_xml + '</Weight>'

	a/OSSEval/methodology/models.py		b/OSSEval/methodology/models.py
1	from django.db import models	1	from django.db import models
2	from entity.models import Entity	2	from entity.models import Entity
3	from OSSEval.utils import xmlMinidom	3	from OSSEval.utils import xmlMinidom
4		4	from xml.dom.minidom import Node
		5
5	class Methodology(models.Model):	6	class Methodology(models.Model):
6	name = models.CharField(max_length=200)	7	name = models.CharField(max_length=200)
7	description = models.CharField(max_length=2000,null=True,blank=True)	8	description = models.CharField(max_length=2000,null=True,blank=True)
8	documentation = models.TextField(null=True,blank=True)	9	documentation = models.TextField(null=True,blank=True)
9	active = models.BooleanField(default=True)	10	active = models.BooleanField(default=True)
	...		...
13	def __unicode__(self):	14	def __unicode__(self):
14	return self.name	15	return self.name
15		16
16	def from_xml(self, xmldoc, insert = True):	17	def from_xml(self, xmldoc, insert = True):
17	if not insert:	18	if not insert:
18	self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data	19	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
19	self.name = xmlMinidom.getString(xmldoc, 'Name')	20	self.name = xmlMinidom.getStringAttribute(xmldoc, 'Name')
20	print str(self.id) + " " + self.name
21	self.description = xmlMinidom.getString(xmldoc, 'Description')	21	self.description = xmlMinidom.getString(xmldoc, 'Description')
22	self.documentation = xmlMinidom.getString(xmldoc, 'Documentation')	22	self.documentation = xmlMinidom.getString(xmldoc, 'Documentation')
23	self.active = xmlMinidom.getString(xmldoc, 'Active')	23	self.active = xmlMinidom.getStringAttribute(xmldoc, 'Active')
24	e = Entity()	24	e = Entity()
25	xml_entity = xmldoc.getElementsByTagName('Entity')[0]	25	xml_entity = xmldoc.getElementsByTagName('Entity')[0]
26	e.from_xml(xml_entity, insert)	26	e.from_xml(xml_entity, insert)
27	self.entity = e	27	self.entity = e
28	# I save so I get the ID (if insert == True)	28	# I save so I get the ID (if insert == True)
29	self.save()	29	self.save()
30		30
31	def to_xml(self):	31	def to_xml(self):
32	str_xml = "<Id>" + str(self.id) + "</Id>"
33	str_xml += "<Name>" + self.name + "</Name>"
34	str_xml += "<Description>" + self.description + "</Description>"	32	str_xml = "<Description><![CDATA[" + self.description + "]]></Description>"
35	str_xml += "<Documentation>" + self.documentation + "</Documentation>"	33	str_xml += "<Documentation><![CDATA[" + self.documentation + "]]></Documentation>"
36	str_xml += "<Active>" + str(self.active) + "</Active>"
37	str_xml += self.entity.to_xml()	34	str_xml += self.entity.to_xml()
38	return "<Methodology>" + str_xml + "</Methodology>"	35	return '<Methodology Id="' + str(self.id) + '" Name="' + self.name + '" Active="' + str(self.active) + '">' + str_xml + "</Methodology>"
39
40		36
41	class MethodologyVersion(models.Model):	37	class MethodologyVersion(models.Model):
42	number = models.IntegerField()	38	number = models.IntegerField()
43	created = models.DateField()	39	created = models.DateField()
44	current = models.BooleanField(default=False)	40	current = models.BooleanField(default=False)
	...		...
47	def __unicode__(self):	43	def __unicode__(self):
48	return self.methodology.name + " - " + str(self.number) + (" (Active version)" if self.current else "")	44	return self.methodology.name + " - " + str(self.number) + (" (Active version)" if self.current else "")
49		45
50	def from_xml(self, xmldoc, insert = True):	46	def from_xml(self, xmldoc, insert = True):
51	if not insert:	47	if not insert:
52	self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data	48	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
53	self.number = xmldoc.getElementsByTagName('Number')[0].firstChild.data	49	self.number = xmldoc.attributes["Number"].firstChild.data
54	self.created = xmlMinidom.getString(xmldoc, 'Created')	50	self.created = xmlMinidom.getStringAttribute(xmldoc, 'Created')
55	self.current = xmlMinidom.getString(xmldoc, 'Current')	51	self.current = xmlMinidom.getStringAttribute(xmldoc, 'Current')
56	m = Methodology()	52	m = Methodology()
57	xml_methodology = xmldoc.getElementsByTagName('Methodology')[0]	53	xml_methodology = xmldoc.getElementsByTagName('Methodology')[0]
58	m.from_xml(xml_methodology, insert)	54	m.from_xml(xml_methodology, insert)
59	self.methodology = m	55	self.methodology = m
60	# I save so I get the ID (if insert == True)	56	# I save so I get the ID (if insert == True)
61	self.save()	57	self.save()
62	# Pages	58	# Pages
63	for xml_child in xmldoc.childNodes:	59	for xml_child in xmldoc.childNodes:
64	if xml_child.tagName == 'Pages':	60	# Some nodes are text nodes (e.g. u'\n ') I need to look just at ELEMENT_NODE
		61	if xml_child.nodeType == Node.ELEMENT_NODE and xml_child.tagName == 'Pages':
65	xml_pages = xml_child	62	xml_pages = xml_child
66	break	63	break
67	for xml_page in xml_pages.childNodes:	64	for xml_page in xml_pages.childNodes:
68	if xml_page.tagName == 'Page':	65	if xml_page.nodeType == Node.ELEMENT_NODE and xml_page.tagName == 'Page':
69	p = Page()	66	p = Page()
70	p.from_xml(xml_page, self, None, insert)	67	p.from_xml(xml_page, self, None, insert)
71	#WeightScenarios	68	#WeightScenarios
72	xml_weight_scenarios = xmldoc.getElementsByTagName('WeightScenarios')	69	xml_weight_scenarios = xmldoc.getElementsByTagName('WeightScenarios')
73	for xml_weight_scenario in xml_weight_scenarios:	70	for xml_weight_scenario in xml_weight_scenarios:
74	ws = WeightScenario()	71	ws = WeightScenario()
75	ws.from_xml(xml_weight_scenario, self, insert)	72	ws.from_xml(xml_weight_scenario, self, insert)
76		73
77	def to_xml(self):	74	def to_xml(self):
78	str_xml = "<Id>" + str(self.id) + "</Id>"
79	str_xml += "<Number>" + str(self.number) + "</Number>"
80	str_xml += "<Created>" + str(self.created) + "</Created>"
81	str_xml += "<Current>" + str(self.current) + "</Current>"
82	str_xml += self.methodology.to_xml()	75	str_xml = self.methodology.to_xml()
83	str_xml += "<Pages>"	76	str_xml += "<Pages>"
84	for page in self.page_set.all():	77	for page in self.page_set.all():
85	str_xml += page.to_xml()	78	str_xml += page.to_xml()
86	str_xml += "</Pages>"	79	str_xml += "</Pages>"
87	str_xml += "<WeightScenarios>"	80	str_xml += "<WeightScenarios>"
88	for weight_scenario in self.weightscenario_set.all():	81	for weight_scenario in self.weightscenario_set.all():
89	str_xml += weight_scenario.to_xml()	82	str_xml += weight_scenario.to_xml()
90	str_xml += "</WeightScenarios>"	83	str_xml += "</WeightScenarios>"
91		84
92	return "<MethodologyVersion>" + str_xml + "</MethodologyVersion>"	85	return '<MethodologyVersion Id="' + str(self.id) + '" Number="' + str(self.number) + '" Created="' + str(self.created) + '" Current="' + str(self.current) + '">' + str_xml + "</MethodologyVersion>"
93		86
94	class Page(models.Model):	87	class Page(models.Model):
95	name = models.CharField(max_length=200)	88	name = models.CharField(max_length=200)
96	order = models.IntegerField(null=False,blank=False)	89	order = models.IntegerField(null=False,blank=False)
97	parent = models.ForeignKey('self',null=True,blank=True)	90	parent = models.ForeignKey('self',null=True,blank=True)
	...		...
100	def __unicode__(self):	93	def __unicode__(self):
101	return self.name	94	return self.name
102		95
103	def from_xml(self, xmldoc, methodology_version, parent_page, insert = True):	96	def from_xml(self, xmldoc, methodology_version, parent_page, insert = True):
104	if not insert:	97	if not insert:
105	self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data	98	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
106	self.name = xmlMinidom.getString(xmldoc, 'Name')	99	self.name = xmlMinidom.getStringAttribute(xmldoc, 'Name')
107	self.order = xmldoc.getElementsByTagName('Order')[0].firstChild.data	100	self.order = xmldoc.attributes["Order"].firstChild.data
108	if methodology_version is not None:	101	if methodology_version is not None:
109	self.methodology_version = methodology_version	102	self.methodology_version = methodology_version
110	if parent_page is not None:	103	if parent_page is not None:
		104	# print self.name + " is a child of " + parent_page.name
111	self.parent = parent_page	105	self.parent = parent_page
		106	self.save()
112	# Pages	107	# Pages
113	for xml_child in xmldoc.childNodes:	108	for xml_child in xmldoc.childNodes:
114	if xml_child.tagName == 'Pages':	109	# Some nodes are text nodes (e.g. u'\n ') I need to look just at ELEMENT_NODE
		110	if xml_child.nodeType == Node.ELEMENT_NODE and xml_child.tagName == 'Pages':
115	xml_pages = xml_child	111	xml_pages = xml_child
116	break	112	break
117	for xml_page in xml_pages.childNodes:	113	for xml_page in xml_pages.childNodes:
118	if xml_page.tagName == 'Page':	114	if xml_page.nodeType == Node.ELEMENT_NODE and xml_page.tagName == 'Page':
119	p = Page()	115	p = Page()
120	p.from_xml(xml_page, None, self, insert)	116	p.from_xml(xml_page, None, self, insert)
121	# Questions	117	# Questions
122	xml_questions = xmldoc.getElementsByTagName('Questions')	118	for xml_child in xmldoc.childNodes:
		119	# Some nodes are text nodes (e.g. u'\n ') I need to look just at ELEMENT_NODE
		120	if xml_child.nodeType == Node.ELEMENT_NODE and xml_child.tagName == 'Questions':
		121	xml_questions = xml_child
		122	break
123	for xml_question in xml_questions:	123	for xml_question in xml_questions.childNodes:
		124	if xml_question.nodeType == Node.ELEMENT_NODE and xml_question.tagName == 'Question':
124	q = Question()	125	q = Question()
125	q.from_xml(xml_question, self, insert)	126	q.from_xml(xml_question, self, insert)
126		127
127	def to_xml(self):	128	def to_xml(self):
128	str_xml = "<Id>" + str(self.id) + "</Id>"
129	str_xml += "<Name>" + self.name + "</Name>"
130	str_xml += "<Order>" + str(self.order) + "</Order>"
131	str_xml += "<Pages>"	129	str_xml = "<Pages>"
132	for page in self.page_set.all():	130	for page in self.page_set.all():
133	str_xml += page.to_xml()	131	str_xml += page.to_xml()
134	str_xml += "</Pages>"	132	str_xml += "</Pages>"
135	str_xml += "<Questions>"	133	str_xml += "<Questions>"
136	for question in self.question_set.all():	134	for question in self.question_set.all():
137	str_xml += question.to_xml()	135	str_xml += question.to_xml()
138	str_xml += "</Questions>"	136	str_xml += "</Questions>"
139	return "<Page>" + str_xml + "</Page>"	137	return '<Page Id="' + str(self.id) + '" Name="' + self.name + '" Order="' + str(self.order) + '">' + str_xml + "</Page>"
140		138
		139	class Meta:
		140	ordering = ['order']
		141
141	class QuestionType(models.Model):	142	class QuestionType(models.Model):
142	name = models.CharField(max_length=200)	143	name = models.CharField(max_length=200)
143		144
144	def from_xml(self, xmldoc, insert = True):	145	def from_xml(self, xmldoc, insert = True):
145	pass	146	if not insert:
		147	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
		148	self.name = xmlMinidom.getStringAttribute(xmldoc, 'Name')
146		149
147	def to_xml(self):	150	def to_xml(self):
148	return "<QuestionType><Id>" + str(self.id) + "</Id><Name>" + self.name + "</Name></QuestionType>"	151	return '<QuestionType Id="' + str(self.id) + '" Name="' + self.name + '"/>'
149		152
150	class Question(models.Model):	153	class Question(models.Model):
151	page = models.ForeignKey(Page)	154	page = models.ForeignKey(Page)
152	text = models.CharField(max_length=200)	155	text = models.CharField(max_length=200)
		156	order = models.IntegerField()
153	eval_description = models.TextField(null=True,blank=True)	157	eval_description = models.TextField(null=True,blank=True)
154	eval_value = models.TextField(null=True,blank=True)	158	eval_value = models.TextField(null=True,blank=True)
155	question_type = models.ForeignKey(QuestionType)	159	question_type = models.ForeignKey(QuestionType)
156		160
157	def __unicode__(self):	161	def __unicode__(self):
158	return self.page.name + " - " + self.text	162	return self.page.name + " - " + self.text
159		163
160	def from_xml(self, xmldoc, page, insert = True):	164	def from_xml(self, xmldoc, page, insert = True):
		165	if not insert:
		166	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
		167	self.text = xmlMinidom.getStringAttribute(xmldoc, 'Text')
		168	self.order = xmlMinidom.getNaturalAttribute(xmldoc, 'Order')
		169	#Do so that QuestionType default is 1
		170	qt = QuestionType.objects.get(pk=1)
		171	self.page = page
		172	self.question_type = qt
		173	self.save()
		174	# Queries
		175	xml_queries = xmldoc.getElementsByTagName('Query')
		176	for xml_query in xml_queries:
		177	q = Query()
		178	q.from_xml(xml_query, self, insert)
		179	# Choices
		180	xml_choices = xmldoc.getElementsByTagName('Choice')
		181	for xml_choice in xml_choices:
		182	c = Choice()
		183	c.from_xml(xml_choice, self, insert)
		184	self.eval_description = xmlMinidom.getString(xmldoc, 'EvalDescription')
		185	self.eval_value = xmlMinidom.getString(xmldoc, 'EvalValue')
161	pass	186
162
163	def to_xml(self):	187	def to_xml(self):
164	str_xml = "<Id>" + str(self.id) + "</Id>"
165	str_xml += "<Text>" + self.text + "</Text>"
166	str_xml += "<EvalDescription>" + ("" if self.eval_description is None else self.eval_description) + "</EvalDescription>"	188	str_xml = "<EvalDescription>" + ("" if self.eval_description is None else self.eval_description) + "</EvalDescription>"
167	str_xml += "<EvalValue>" + ("" if self.eval_value is None else self.eval_value) + "</EvalValue>"	189	str_xml += "<EvalValue>" + ("" if self.eval_value is None else self.eval_value) + "</EvalValue>"
		190	# We do not use question_type at the moment as we have just one type
168	str_xml += self.question_type.to_xml()	191	# str_xml += self.question_type.to_xml()
169	str_xml += "<Queries>"	192	str_xml += "<Queries>"
170	for query in self.query_set.all():	193	for query in self.query_set.all():
171	str_xml += query.to_xml()	194	str_xml += query.to_xml()
		195	str_xml += "</Queries>"
		196	str_xml += "<Choices>"
172	for choice in self.choice_set.all():	197	for choice in self.choice_set.all():
173	str_xml += choice.to_xml()	198	str_xml += choice.to_xml()
174	str_xml += "</Queries>"	199	str_xml += "</Choices>"
175	return "<Question>" + str_xml + "</Question>"	200	return '<Question Id="' + str(self.id) + '" Text="' + self.text + '" Order="' + str(self.order) + '">' + str_xml + '</Question>'
		201
		202	class Meta:
		203	ordering = ['order']
176		204
177	class Query(models.Model):	205	class Query(models.Model):
178	'''	206	'''
179	Queries against web search engines used to automate the answer to a question and/or as a hint to the reviewer	207	Queries against web search engines used to automate the answer to a question and/or as a hint to the reviewer
180	'''	208	'''
181	question = models.ForeignKey(Question)	209	question = models.ForeignKey(Question)
182	eval_text = models.CharField(max_length=2000)	210	eval_text = models.CharField(max_length=2000)
183	eval_site = models.CharField(max_length=2000)	211	eval_site = models.CharField(max_length=2000)
184	eval_site_exclude = models.CharField(max_length=2000)	212	eval_site_exclude = models.CharField(max_length=2000)
185		213
186	def from_xml(self, xmldoc, insert = True):	214	def from_xml(self, xmldoc, question, insert = True):
		215	if not insert:
		216	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
		217	self.question = question
		218	self.eval_text = xmlMinidom.getString(xmldoc, 'EvalText')
		219	self.eval_site = xmlMinidom.getString(xmldoc, 'EvalSite')
		220	self.eval_site_exclude = xmlMinidom.getString(xmldoc, 'EvalSiteExclude')
		221	self.save()
187	pass	222
188
189	def to_xml(self):	223	def to_xml(self):
190	str_xml = "<Id>" + str(self.id) + "</Id>"
191	str_xml += "<EvalText>" + self.eval_text + "</EvalText>"	224	str_xml = "<EvalText>" + self.eval_text + "</EvalText>"
192	str_xml += "<EvalSite>" + self.eval_site + "</EvalSite>"	225	str_xml += "<EvalSite>" + self.eval_site + "</EvalSite>"
193	str_xml += "<EvalSiteExclude>" + self.eval_site_exclude + "</EvalSiteExclude>"	226	str_xml += "<EvalSiteExclude>" + self.eval_site_exclude + "</EvalSiteExclude>"
194	return "<Query>" + str_xml + "</Query>"	227	return '<Query Id="' + str(self.id) + '">' + str_xml + '</Query>'
195		228
196	class Choice(models.Model):	229	class Choice(models.Model):
197	'''	230	'''
198	'''	231	'''
199	question = models.ForeignKey(Question)	232	question = models.ForeignKey(Question)
200	text = models.CharField(max_length=200)	233	text = models.CharField(max_length=200)
201	order = models.IntegerField()	234	order = models.IntegerField()
202	todo = models.CharField(max_length=2000)	235	todo = models.CharField(max_length=2000)
203		236
204	def from_xml(self, xmldoc, insert = True):	237	def from_xml(self, xmldoc, question, insert = True):
205	pass	238	if not insert:
		239	self.id = xmlMinidom.getNaturalAttribute(xmldoc, 'Id')
		240	self.question = question
		241	self.text = xmlMinidom.getStringAttribute(xmldoc, 'Text')
		242	self.order = xmlMinidom.getNaturalAttribute(xmldoc, 'Order')
		243	self.todo = xmlMinidom.getString(xmldoc, 'Todo')
		244	self.save()
206		245
207	def to_xml(self):	246	def to_xml(self):
208	str_xml = "<Id>" + str(self.id) + "</Id>"
209	str_xml += "<Text>" + self.text + "</Text>"
210	str_xml += "<Order>" + str(self.order) + "</Order>"
211	str_xml += "<Todo>" + self.todo + "</Todo>"	247	str_xml = "<Todo>" + self.todo + "</Todo>"
212	return "<Choice>" + str_xml + "</Choice>"	248	return '<Choice Id="' + str(self.id) + '" Text="' + self.text + '" Order="' + str(self.order) + '">' + str_xml + '</Choice>'
		249
		250	class Meta:
		251	ordering = ['order']
213		252
214	class WeightScenario(models.Model):	253	class WeightScenario(models.Model):
215	name = models.CharField(max_length=200)	254	name = models.CharField(max_length=200)
216	methodology_version = models.ForeignKey(MethodologyVersion)	255	methodology_version = models.ForeignKey(MethodologyVersion)
217	active = models.BooleanField(blank=False)	256	active = models.BooleanField(blank=False)
	...		...
219	def from_xml(self, xmldoc, methodology_version, insert = True):	258	def from_xml(self, xmldoc, methodology_version, insert = True):
220	self.methodology_version = methodology_version	259	self.methodology_version = methodology_version
221	pass	260	pass
222		261
223	def to_xml(self):	262	def to_xml(self):
224	str_xml = "<Id>" + str(self.id) + "</Id>"
225	str_xml += "<Name>" + self.name + "</Name>"
226	str_xml += "<Active>" + str(self.active) + "</Active>"
227	str_xml += "<Weights>"	263	str_xml = "<Weights>"
228	for weight in self.weight_set.all():	264	for weight in self.weight_set.all():
229	str_xml += weight.to_xml()	265	str_xml += weight.to_xml()
230	str_xml += "</Weights>"	266	str_xml += "</Weights>"
231	return "<WeightScenario>" + str_xml + "</WeightScenario>"	267	return '<WeightScenario Id="' + str(self.id) + '" Name="' + self.name + '" Active="' + str(self.active) + '">' + str_xml + '</WeightScenario>'
232		268
233	class Weight(models.Model):	269	class Weight(models.Model):
234	question = models.ForeignKey(Question)	270	question = models.ForeignKey(Question)
235	weight = models.FloatField()	271	weight = models.FloatField()
236	scenario = models.ForeignKey(WeightScenario)	272	scenario = models.ForeignKey(WeightScenario)
	...		...
243	str_xml += "<Active>" + self.active + "</Active>"	279	str_xml += "<Active>" + self.active + "</Active>"
244	str_xml += "<Weights>"	280	str_xml += "<Weights>"
245	for weight in self.weight_set.all():	281	for weight in self.weight_set.all():
246	str_xml += weight.to_xml()	282	str_xml += weight.to_xml()
247	str_xml += "</Weights>"	283	str_xml += "</Weights>"
248	return "<WeightScenario>" + str_xml + "</WeightScenario>"	284	return '<Weight Id="' + str(self.id) + '" Active="' + str(self.active) + '">' + str_xml + '</Weight>'