--- a/OSSEval/methodology/models.py
+++ b/OSSEval/methodology/models.py
@@ -1,6 +1,6 @@
 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)
@@ -9,54 +9,240 @@
     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)
+    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>"