|
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 |
|
3 |
from OSSEval.utils import xmlMinidom
|
| 4 |
|
4 |
|
| 5 |
class Methodology(models.Model):
|
5 |
class Methodology(models.Model):
|
| 6 |
name = models.CharField(max_length=200)
|
6 |
name = models.CharField(max_length=200)
|
| 7 |
description = models.CharField(max_length=2000,null=True,blank=True)
|
7 |
description = models.CharField(max_length=2000,null=True,blank=True)
|
| 8 |
documentation = models.TextField(null=True,blank=True)
|
8 |
documentation = models.TextField(null=True,blank=True)
|
| 9 |
active = models.BooleanField(default=True)
|
9 |
active = models.BooleanField(default=True)
|
| 10 |
# The entity type the methodology helps you assess
|
10 |
# The entity type the methodology helps you assess
|
| 11 |
entity = models.ForeignKey(Entity)
|
11 |
entity = models.ForeignKey(Entity)
|
|
|
12 |
|
| 12 |
def __unicode__(self):
|
13 |
def __unicode__(self):
|
| 13 |
return self.name
|
14 |
return self.name
|
|
|
15 |
|
|
|
16 |
def from_xml(self, xmldoc, insert = True):
|
|
|
17 |
if not insert:
|
|
|
18 |
self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data
|
|
|
19 |
self.name = xmlMinidom.getString(xmldoc, 'Name')
|
|
|
20 |
print str(self.id) + " " + self.name
|
|
|
21 |
self.description = xmlMinidom.getString(xmldoc, 'Description')
|
|
|
22 |
self.documentation = xmlMinidom.getString(xmldoc, 'Documentation')
|
|
|
23 |
self.active = xmlMinidom.getString(xmldoc, 'Active')
|
|
|
24 |
e = Entity()
|
|
|
25 |
xml_entity = xmldoc.getElementsByTagName('Entity')[0]
|
|
|
26 |
e.from_xml(xml_entity, insert)
|
|
|
27 |
self.entity = e
|
|
|
28 |
# I save so I get the ID (if insert == True)
|
|
|
29 |
self.save()
|
|
|
30 |
|
|
|
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>"
|
|
|
35 |
str_xml += "<Documentation>" + self.documentation + "</Documentation>"
|
|
|
36 |
str_xml += "<Active>" + str(self.active) + "</Active>"
|
|
|
37 |
str_xml += self.entity.to_xml()
|
|
|
38 |
return "<Methodology>" + str_xml + "</Methodology>"
|
|
|
39 |
|
| 14 |
|
40 |
|
| 15 |
class MethodologyVersion(models.Model):
|
41 |
class MethodologyVersion(models.Model):
|
| 16 |
number = models.IntegerField()
|
42 |
number = models.IntegerField()
|
| 17 |
created = models.DateField()
|
43 |
created = models.DateField()
|
| 18 |
current = models.BooleanField(default=False)
|
44 |
current = models.BooleanField(default=False)
|
| 19 |
methodology = models.ForeignKey(Methodology)
|
45 |
methodology = models.ForeignKey(Methodology)
|
|
|
46 |
|
| 20 |
def __unicode__(self):
|
47 |
def __unicode__(self):
|
| 21 |
return self.methodology.name + " - " + str(self.number) + (" (Active version)" if self.current else "")
|
48 |
return self.methodology.name + " - " + str(self.number) + (" (Active version)" if self.current else "")
|
|
|
49 |
|
|
|
50 |
def from_xml(self, xmldoc, insert = True):
|
|
|
51 |
if not insert:
|
|
|
52 |
self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data
|
|
|
53 |
self.number = xmldoc.getElementsByTagName('Number')[0].firstChild.data
|
|
|
54 |
self.created = xmlMinidom.getString(xmldoc, 'Created')
|
|
|
55 |
self.current = xmlMinidom.getString(xmldoc, 'Current')
|
|
|
56 |
m = Methodology()
|
|
|
57 |
xml_methodology = xmldoc.getElementsByTagName('Methodology')[0]
|
|
|
58 |
m.from_xml(xml_methodology, insert)
|
|
|
59 |
self.methodology = m
|
|
|
60 |
# I save so I get the ID (if insert == True)
|
|
|
61 |
self.save()
|
|
|
62 |
# Pages
|
|
|
63 |
for xml_child in xmldoc.childNodes:
|
|
|
64 |
if xml_child.tagName == 'Pages':
|
|
|
65 |
xml_pages = xml_child
|
|
|
66 |
break
|
|
|
67 |
for xml_page in xml_pages.childNodes:
|
|
|
68 |
if xml_page.tagName == 'Page':
|
|
|
69 |
p = Page()
|
|
|
70 |
p.from_xml(xml_page, self, None, insert)
|
|
|
71 |
#WeightScenarios
|
|
|
72 |
xml_weight_scenarios = xmldoc.getElementsByTagName('WeightScenarios')
|
|
|
73 |
for xml_weight_scenario in xml_weight_scenarios:
|
|
|
74 |
ws = WeightScenario()
|
|
|
75 |
ws.from_xml(xml_weight_scenario, self, insert)
|
|
|
76 |
|
|
|
77 |
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()
|
|
|
83 |
str_xml += "<Pages>"
|
|
|
84 |
for page in self.page_set.all():
|
|
|
85 |
str_xml += page.to_xml()
|
|
|
86 |
str_xml += "</Pages>"
|
|
|
87 |
str_xml += "<WeightScenarios>"
|
|
|
88 |
for weight_scenario in self.weightscenario_set.all():
|
|
|
89 |
str_xml += weight_scenario.to_xml()
|
|
|
90 |
str_xml += "</WeightScenarios>"
|
|
|
91 |
|
|
|
92 |
return "<MethodologyVersion>" + str_xml + "</MethodologyVersion>"
|
| 22 |
|
93 |
|
| 23 |
class Page(models.Model):
|
94 |
class Page(models.Model):
|
| 24 |
name = models.CharField(max_length=200)
|
95 |
name = models.CharField(max_length=200)
|
| 25 |
order = models.IntegerField(null=False,blank=False)
|
96 |
order = models.IntegerField(null=False,blank=False)
|
| 26 |
parent = models.ForeignKey('self',null=True,blank=True)
|
97 |
parent = models.ForeignKey('self',null=True,blank=True)
|
| 27 |
methodology_version = models.ForeignKey(MethodologyVersion)
|
98 |
methodology_version = models.ForeignKey(MethodologyVersion,null=True,blank=True)
|
|
|
99 |
|
| 28 |
def __unicode__(self):
|
100 |
def __unicode__(self):
|
| 29 |
return self.name
|
101 |
return self.name
|
| 30 |
|
102 |
|
|
|
103 |
def from_xml(self, xmldoc, methodology_version, parent_page, insert = True):
|
|
|
104 |
if not insert:
|
|
|
105 |
self.id = xmldoc.getElementsByTagName('Id')[0].firstChild.data
|
|
|
106 |
self.name = xmlMinidom.getString(xmldoc, 'Name')
|
|
|
107 |
self.order = xmldoc.getElementsByTagName('Order')[0].firstChild.data
|
|
|
108 |
if methodology_version is not None:
|
|
|
109 |
self.methodology_version = methodology_version
|
|
|
110 |
if parent_page is not None:
|
|
|
111 |
self.parent = parent_page
|
|
|
112 |
# Pages
|
|
|
113 |
for xml_child in xmldoc.childNodes:
|
|
|
114 |
if xml_child.tagName == 'Pages':
|
|
|
115 |
xml_pages = xml_child
|
|
|
116 |
break
|
|
|
117 |
for xml_page in xml_pages.childNodes:
|
|
|
118 |
if xml_page.tagName == 'Page':
|
|
|
119 |
p = Page()
|
|
|
120 |
p.from_xml(xml_page, None, self, insert)
|
|
|
121 |
# Questions
|
|
|
122 |
xml_questions = xmldoc.getElementsByTagName('Questions')
|
|
|
123 |
for xml_question in xml_questions:
|
|
|
124 |
q = Question()
|
|
|
125 |
q.from_xml(xml_question, self, insert)
|
|
|
126 |
|
|
|
127 |
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>"
|
|
|
132 |
for page in self.page_set.all():
|
|
|
133 |
str_xml += page.to_xml()
|
|
|
134 |
str_xml += "</Pages>"
|
|
|
135 |
str_xml += "<Questions>"
|
|
|
136 |
for question in self.question_set.all():
|
|
|
137 |
str_xml += question.to_xml()
|
|
|
138 |
str_xml += "</Questions>"
|
|
|
139 |
return "<Page>" + str_xml + "</Page>"
|
|
|
140 |
|
| 31 |
class QuestionType(models.Model):
|
141 |
class QuestionType(models.Model):
|
| 32 |
name = models.CharField(max_length=200)
|
142 |
name = models.CharField(max_length=200)
|
| 33 |
|
143 |
|
|
|
144 |
def from_xml(self, xmldoc, insert = True):
|
|
|
145 |
pass
|
|
|
146 |
|
|
|
147 |
def to_xml(self):
|
|
|
148 |
return "<QuestionType><Id>" + str(self.id) + "</Id><Name>" + self.name + "</Name></QuestionType>"
|
|
|
149 |
|
| 34 |
class Question(models.Model):
|
150 |
class Question(models.Model):
|
| 35 |
page = models.ForeignKey(Page)
|
151 |
page = models.ForeignKey(Page)
|
| 36 |
text = models.CharField(max_length=200)
|
152 |
text = models.CharField(max_length=200)
|
| 37 |
eval_description = models.TextField(null=True,blank=True)
|
153 |
eval_description = models.TextField(null=True,blank=True)
|
| 38 |
eval_value = models.TextField(null=True,blank=True)
|
154 |
eval_value = models.TextField(null=True,blank=True)
|
| 39 |
question_type = models.ForeignKey(QuestionType)
|
155 |
question_type = models.ForeignKey(QuestionType)
|
|
|
156 |
|
| 40 |
def __unicode__(self):
|
157 |
def __unicode__(self):
|
| 41 |
return self.page.name + " - " + self.text
|
158 |
return self.page.name + " - " + self.text
|
|
|
159 |
|
|
|
160 |
def from_xml(self, xmldoc, page, insert = True):
|
|
|
161 |
pass
|
|
|
162 |
|
|
|
163 |
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>"
|
|
|
167 |
str_xml += "<EvalValue>" + ("" if self.eval_value is None else self.eval_value) + "</EvalValue>"
|
|
|
168 |
str_xml += self.question_type.to_xml()
|
|
|
169 |
str_xml += "<Queries>"
|
|
|
170 |
for query in self.query_set.all():
|
|
|
171 |
str_xml += query.to_xml()
|
|
|
172 |
for choice in self.choice_set.all():
|
|
|
173 |
str_xml += choice.to_xml()
|
|
|
174 |
str_xml += "</Queries>"
|
|
|
175 |
return "<Question>" + str_xml + "</Question>"
|
| 42 |
|
176 |
|
| 43 |
class Query(models.Model):
|
177 |
class Query(models.Model):
|
|
|
178 |
'''
|
|
|
179 |
Queries against web search engines used to automate the answer to a question and/or as a hint to the reviewer
|
|
|
180 |
'''
|
| 44 |
question = models.ForeignKey(Question)
|
181 |
question = models.ForeignKey(Question)
|
| 45 |
eval_text = models.CharField(max_length=2000)
|
182 |
eval_text = models.CharField(max_length=2000)
|
| 46 |
eval_site = models.CharField(max_length=2000)
|
183 |
eval_site = models.CharField(max_length=2000)
|
| 47 |
eval_site_exclude = models.CharField(max_length=2000)
|
184 |
eval_site_exclude = models.CharField(max_length=2000)
|
|
|
185 |
|
|
|
186 |
def from_xml(self, xmldoc, insert = True):
|
|
|
187 |
pass
|
|
|
188 |
|
|
|
189 |
def to_xml(self):
|
|
|
190 |
str_xml = "<Id>" + str(self.id) + "</Id>"
|
|
|
191 |
str_xml += "<EvalText>" + self.eval_text + "</EvalText>"
|
|
|
192 |
str_xml += "<EvalSite>" + self.eval_site + "</EvalSite>"
|
|
|
193 |
str_xml += "<EvalSiteExclude>" + self.eval_site_exclude + "</EvalSiteExclude>"
|
|
|
194 |
return "<Query>" + str_xml + "</Query>"
|
| 48 |
|
195 |
|
| 49 |
class Choice(models.Model):
|
196 |
class Choice(models.Model):
|
|
|
197 |
'''
|
|
|
198 |
'''
|
| 50 |
question = models.ForeignKey(Question)
|
199 |
question = models.ForeignKey(Question)
|
|
|
200 |
text = models.CharField(max_length=200)
|
| 51 |
order = models.IntegerField()
|
201 |
order = models.IntegerField()
|
| 52 |
todo = models.CharField(max_length=2000)
|
202 |
todo = models.CharField(max_length=2000)
|
|
|
203 |
|
|
|
204 |
def from_xml(self, xmldoc, insert = True):
|
|
|
205 |
pass
|
|
|
206 |
|
|
|
207 |
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>"
|
|
|
212 |
return "<Choice>" + str_xml + "</Choice>"
|
| 53 |
|
213 |
|
| 54 |
class WeightScenario(models.Model):
|
214 |
class WeightScenario(models.Model):
|
| 55 |
name = models.CharField(max_length=200)
|
215 |
name = models.CharField(max_length=200)
|
| 56 |
methodology_version = models.ForeignKey(MethodologyVersion)
|
216 |
methodology_version = models.ForeignKey(MethodologyVersion)
|
| 57 |
active = models.BooleanField(blank=False)
|
217 |
active = models.BooleanField(blank=False)
|
|
|
218 |
|
|
|
219 |
def from_xml(self, xmldoc, methodology_version, insert = True):
|
|
|
220 |
self.methodology_version = methodology_version
|
|
|
221 |
pass
|
|
|
222 |
|
|
|
223 |
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>"
|
|
|
228 |
for weight in self.weight_set.all():
|
|
|
229 |
str_xml += weight.to_xml()
|
|
|
230 |
str_xml += "</Weights>"
|
|
|
231 |
return "<WeightScenario>" + str_xml + "</WeightScenario>"
|
| 58 |
|
232 |
|
| 59 |
class Weight(models.Model):
|
233 |
class Weight(models.Model):
|
| 60 |
question = models.ForeignKey(Question)
|
234 |
question = models.ForeignKey(Question)
|
| 61 |
weight = models.FloatField()
|
235 |
weight = models.FloatField()
|
| 62 |
scenario = models.ForeignKey(WeightScenario)
|
236 |
scenario = models.ForeignKey(WeightScenario)
|
|
|
237 |
|
|
|
238 |
def from_xml(self, xmldoc, insert = True):
|
|
|
239 |
pass
|
|
|
240 |
|
|
|
241 |
def to_xml(self):
|
|
|
242 |
str_xml = "<Id>" + str(self.id) + "</Id>"
|
|
|
243 |
str_xml += "<Active>" + self.active + "</Active>"
|
|
|
244 |
str_xml += "<Weights>"
|
|
|
245 |
for weight in self.weight_set.all():
|
|
|
246 |
str_xml += weight.to_xml()
|
|
|
247 |
str_xml += "</Weights>"
|
|
|
248 |
return "<WeightScenario>" + str_xml + "</WeightScenario>"
|