Merge branch 'master' of https://github.com/gnowgi/gnowsys-studio

Conflicts:
	gstudio/templates/gstudio/skeleton.html

14 files changed, 1682 insertions, 130 deletions

diff --git a/gstudio/CNL.py b/gstudio/CNL.py
new file mode 100644
index 0000000..4139474
--- /dev/null
+++ b/gstudio/CNL.py
@@ -0,0 +1,825 @@
+from gstudio.models import *
+from django.template.defaultfilters import slugify
+import inflect
+
+
+def get_CNL_list(self):
+	x = []
+	a = get_lex_sentence(self)
+	if not a:
+		pass
+	else:
+		x.extend(a)
+	b = lex_sentence_optional(self)
+	if not b:
+		pass
+	else:
+		x.extend(b)
+	c = contains_subtypes_sentence(self)
+        if not c:
+		pass
+	else:
+		x.extend(c)
+	d = typeof_sentence(self)
+	if not d:
+		pass
+	else:
+		x.extend(d)
+	e = get_CNL_dependency(self)
+	if not e:
+		pass
+	else:
+		x.extend(e)
+	f = get_rel(self)
+	if not f:
+		pass
+	else:
+		x.extend(f)
+	g = get_attr_sentence(self)
+	if not g:		
+		pass
+	else:
+		x.extend(g)
+	return x
+
+
+def advanced_CNL(self):
+	y = []
+	h = get_leftST_sentence(self)	
+	if not h:                
+		pass
+	else:
+		y.extend(h)
+	i = get_rightST_sentence(self)
+	if not i:
+		pass
+	else:
+		y.extend(i)
+        j = get_ST_sentence(self)
+	if not j:
+		pass
+	else:
+		y.extend(j)
+	k = get_CNL_sentence_authors(self)
+	if not k:
+		pass
+	else:
+		y.extend(k)
+        """To generate CNL data about RT/R"""	
+        a = get_RT_sentence(self)
+        if not a:
+               pass
+        else:
+               y.extend(a)
+	return y
+
+#Returns lex sentence - Title 
+def get_lex_sentence(self):  
+    if self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attribute':
+       pass
+    else:      
+       # If AT or RT       
+       at = []
+       if self.title:
+           title = slugify(self.title)
+           title_slug = slugify(title)
+           if self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Objecttype':
+                g = "A "+str(title_slug).lower()+" is a common-noun."                       
+           elif self.ref.__class__.__name__ is 'Metatype':                 
+                g = "A "+str(title_slug).lower()+" is a metatype."    
+              
+           at.append(g)        
+       return at
+
+#Returns CNL sentences - Plural & Alternate names
+def lex_sentence_optional(self): 
+      
+      # If AT, MT or OT
+      a = []
+      if self.ref.__class__.__name__ is 'Attribute' or self.ref.__class__.__name__ is 'Relationtype':
+	pass
+      elif self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
+         title_slug = slugify(self.title)
+         if self.altnames:
+           alt = self.altnames
+           alt_slug = slugify(alt)
+           e = "A "+str(alt_slug)+" is an alternate name for it."
+           a.append(e.capitalize())
+      
+      # If MT or OT
+      if self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
+         if self.plural:
+           plu_slug = slugify(self.plural)
+           m="Some "+str(plu_slug)+" are a plural of a "+str(title_slug)+"."
+           a.append(m.capitalize())
+      return a    
+
+#Generates CNL sentence for RT for which OT or MT is the left-subjecttype
+def get_leftST_sentence(self):    
+    if self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attribute':
+         pass     
+    else:
+      #If OT or MT
+      cns=self.ref.get_nbh
+      d = []
+      for k in cns:
+         title = str(cns['title'])
+         title_slug = slugify(title)
+         if self.ref.__class__.__name__ is 'Objecttype' or 'Metatype':
+           if k == 'left_subjecttype_of':
+               if not cns[k]:
+                     pass
+               else:                 
+                   l_s_a = []
+                   l_s_a = self.left_subjecttype_of.all() 
+                   len_lsa=len(l_s_a)                   
+                   if len_lsa == 1:
+                     #If singular:
+                     for each in l_s_a:                     
+                       al=slugify(each) 
+                       #A person is a n:left_subjecttype of a n:relation_type a:teaches and a:student-of and a:sibling-of and a:friend-of.    
+                       if self.ref.__class__.__name__ is 'Objecttype':                                    
+                          c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+str(al)+"."  
+                       elif self.ref.__class__.__name__ is 'Metatype':
+                          c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+str(al)+"." 
+                       d.append(c.capitalize())
+                                         
+                   else:                     
+                       #If plural:
+                       y=[]
+                       for each in self.left_subjecttype_of.all():                             
+                             a=each
+                             a_slug=slugify(a)
+                             y.append(a_slug)
+                       for e_i in y:                            
+                             if y.index(e_i) == 0:
+                                sen = str(e_i)
+                             else:
+                                sen = str(sen)+" and "+str(e_i)                  
+                       if self.ref.__class__.__name__ is 'Objecttype':
+                            c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+sen+"."                       
+                       elif self.ref.__class__.__name__ is 'Metatype':
+                            c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+sen+"."     
+                       
+                       d.append(c.capitalize())
+      return d   
+
+#Generates CNL sentence for RT for which OT or MT is the right-subjecttype
+def get_rightST_sentence(self):    
+    if self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attribute':
+         pass     
+    else:
+      #If OT or MT
+      cns=self.ref.get_nbh
+      d = []
+      for k in cns:
+          title = str(cns['title'])
+          title_slug = slugify(title)
+          if self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
+            if k == 'right_subjecttype_of':
+               if not cns[k]:
+                     pass
+               else:                 
+                   r_s_a = []
+                   r_s_a = self.right_subjecttype_of.all() 
+                   len_rsa=len(r_s_a)                   
+                   if len_rsa == 1:
+                     #If singular:
+                     for each in r_s_a:                     
+                       al=slugify(each)     
+                       if self.ref.__class__.__name__ is 'Objecttype':                                    
+                          c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+str(al)+"."  
+                       elif self.ref.__class__.__name__ is 'Metatype':
+                          c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+str(al)+"." 
+                       d.append(c.capitalize())
+                                         
+                   else:
+                     #If plural:
+                       y=[]
+                       for each in self.right_subjecttype_of.all():                             
+                             a=each
+                             a_slug=slugify(a)
+                             y.append(a_slug)
+                       for e_i in y:                            
+                             if y.index(e_i) == 0:
+                                sen = str(e_i)
+                             else:
+                                sen = str(sen)+" and "+str(e_i)                  
+                       if self.ref.__class__.__name__ is 'Objecttype':
+                            c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+sen+"."                       
+                       elif self.ref.__class__.__name__ is 'Metatype':
+                            c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+sen+"."     
+                       
+                       d.append(c.capitalize())
+      return d   
+
+#Generates Subject-type sentence for AT
+def get_ST_sentence(self):
+     if self.ref.__class__.__name__ is 'Attribute':
+	pass
+     elif self.ref.__class__.__name__ is 'Attributetype':
+        a = []
+        if self.subjecttype:     
+           subjecttype = self.subjecttype
+           st_type = subjecttype.ref.__class__.__name__
+           if st_type == 'Gbobject':
+              c = str(subjecttype)+" is a subject_type_name for it."
+           else:
+              c = "A "+str(subjecttype)+" is a subject_type_name for it."
+           a.append(c.capitalize())
+        return a 
+
+
+#Generates contains-subtypes for MT or OT
+def contains_subtypes_sentence(self):          
+    if self.ref.__class__.__name__ is 'Metatype' or self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Attribute':
+	pass
+    elif self.ref.__class__.__name__ is 'Metatype' or self.ref.__class__.__name__ is 'Objecttype':
+        #print "is a mt or OT"
+	#print "it just entered the loop"
+        cns=self.ref.get_nbh
+        d = []
+        for k in cns:
+          title = str(cns['title'])
+          title_slug = slugify(title)
+          if k=='contains_subtypes':              
+                 if not cns[k]:
+                    pass
+                 else:
+                    if self.ref.__class__.__name__ is 'Metatype':
+                       nof=self.children.get_query_set()                    
+                    elif self.ref.__class__.__name__ is 'Objecttype':       
+                       nof=Nodetype.objects.filter(parent=self.id)         
+ 	            len_nof=len(nof)
+                    #print "nof----" ,nof   
+                    #print len_nof, "len - nof"                                 
+                    if len_nof == 1:
+                      for each in nof:                     
+                        nf=slugify(each) 
+                        l = "A "+str(nf)+" is a subtype of a "+str(title_slug)+"."
+                        d.append(l.capitalize())                                        
+                    else:
+                       #print "len not 1"
+                       y=[]
+                       for each in nof:                             
+                             a=each
+                             a_slug=slugify(a)
+                             y.append(a_slug)
+                       for e_i in y:                             
+                             if y.index(e_i) == 0:
+                                sen = str(e_i)
+                             else:
+                                sen = str(sen)+" and a "+str(e_i)                 
+
+                       l = "A "+sen+" are some subtypes of "+str(title_slug)+"."                      
+                       d.append(l.capitalize())
+        return d  
+
+#Generates Type-Of sentence for OT or MT
+#get_nbh type_of --- Metatype
+def typeof_sentence(self):       
+   d = []
+   if self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Attribute':
+     pass
+   elif self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
+     #print "mt or ot"
+     cns = self.ref.get_nbh
+     for k in cns:
+       title = str(cns['title'])
+       title_slug = slugify(title)
+       if k=='type_of':
+                 if not cns[k]:
+                     pass
+                 else:                   
+                   if self.ref.__class__.__name__ is 'Objecttype':                     
+                     n = self.parent
+		     n_slug=slugify(n)
+                   elif self.ref.__class__.__name__ is 'Metatype':                      
+                     n = str(cns[k])                    
+                     n_slug=slugify(n)
+                   an = "A "+str(title_slug)+" is a type of a "+str(n_slug)+"."                   
+                   d.append(an.capitalize())
+                 return d
+
+#Generates CNL Sentence - Prior & Posterior Nodes
+def get_CNL_dependency(self): 
+    if self.ref.__class__.__name__ is 'Attribute':
+	pass   
+    elif self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Attributetype' :      
+      title = self.title
+      title_slug = slugify(title)
+      d=[]                          
+      if self.prior_nodes.all():
+                   p_n_a = [] 
+                   p_n_a = self.prior_nodes.all()
+                   #print len(p_n_a)
+                   len_pna=len(p_n_a)                   
+                   if len_pna == 1:
+                     for each in p_n_a:                     
+                       pn=slugify(each)                                       
+                       h="A "+str(title_slug)+" depends on a "+str(pn)+"."
+                       d.append(h.capitalize()) 
+                   else:                       
+                       sen = dependency_plural(p_n_a)
+                       h = "A "+str(sen)+". It is required for the meaning of a "+str(title_slug)+"."
+                       d.append(h)
+      
+      if self.posterior_nodes.all():                
+                   p_n_a = []
+                   p_n_a = self.posterior_nodes.all() 
+                   #print "length of posterior nodes-----" ,len(p_n_a)
+                   len_pna=len(p_n_a)                   
+                   if len_pna == 1:
+                     for each in p_n_a:                     
+                       pn = slugify(each)                                         
+                       p = "A "+str(title_slug)+" is required for the meaning of a "+str(pn)+"."
+                       d.append(p.capitalize()) 
+                   else:                      
+		       sen = dependency_plural(p_n_a)
+                       p = "A "+str(sen)+". It depends on "+str(title_slug)+"."
+                       d.append(p)
+      return d
+
+#Generates dependency sentence for plural
+def dependency_plural(p_n_a):                                              
+                      y=[]
+                      #print "len not 1"
+                      for each in p_n_a:
+                         each_r = each.ref.__class__.__name__
+                         apn = each
+                         apn_slug = slugify(apn)
+                         if len(y) == 0:
+                                "If Y is empty, for first item"
+                                if each_r == 'Relationtype':
+                                    b_slug = str(apn_slug)+" is an adjective" 
+                                else:
+                                    b_slug = str(apn_slug)+" is a common-noun"
+                                y.append(b_slug)
+                         else:
+                                if each_r != 'Relationtype':
+                                   #print "Its not a relation_type, but a noun, so appending an 'a' "
+                                   aa_slug = "a "+str(apn_slug)+" is a common-noun"
+                                   y.append(aa_slug)
+                                else:
+                                   #print "It is a relationtype"
+                                   ab_slug = str(apn_slug)+" is an adjective"
+                                   y.append(ab_slug)
+                      for e_i in y:
+                             if y.index(e_i) == 0:
+                                sen = str(e_i).lower()
+                             else:                             
+                                sen = str(sen)+" and "+str(e_i).lower()  
+                      return sen 
+
+
+
+#Generates CNL sentence for authors, in OT and AT
+def get_CNL_sentence_authors(self):      
+      title = self.title
+      title_slug = slugify(title)
+      d=[]
+      if self.ref.__class__.__name__ is 'Attribute':
+	pass
+      elif self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Attributetype':
+        if self.authors.all():
+                   auth = []
+                   auth = self.authors.all() 
+ 	           len_auth=len(auth)                   
+                   if len_auth == 1:
+                     for each in auth:                     
+                       aut=slugify(each)                                         
+                       e=str(aut).title()+" is an author to a "+str(title_slug)+"."
+                       d.append(e.capitalize())                                         
+                   else:
+                       #print "len not 1"                       
+                       y=[]
+                       for each in self.authors.all():                             
+                          a=each
+                          a_slug=slugify(a)
+                          y.append(a_slug)
+                          for e_i in y:                             
+                             if y.index(e_i) == 0:
+                                sen = str(e_i)
+                             else:
+                                sen = str(sen)+" and "+str(e_i)
+
+                          e = str(sen).title()+" are all chosen authors to a "+str(title_slug)+"."                       
+                       d.append(e.capitalize())                       
+      return d
+
+
+    
+         
+	 
+
+#Checks if RT-title is a transitive verb finite singular or an iterative adjective
+def istv_title(self):        
+        p = inflect.engine()
+        from django.template.defaultfilters import slugify
+        destination = open( "/home/user/gnowsys-studio/demo/aFile.pl", "r+"  )        
+        f = destination.read()
+        a_t = self.title
+        a = slugify(a_t)               
+        if '-' not in a:
+            if a[-1] == 's':
+                  a_s = p.singular_noun(a)
+                  a_lex = "tv_finsg("+a+", "+str(a_s)+")."
+                  strpos = f.find(a_lex)
+                  if strpos != -1: 
+                       return True
+                  else:
+                       return False
+
+#Checks if RT-inverse is a transitive verb finite singular or an iterative adjective
+def istv_inverse(self):
+        p = inflect.engine()        
+        destination = open( "/home/user/gnowsys-studio/demo/aFile.pl", "r+"  )        
+        f = destination.read()
+        a_t = self.inverse
+        a = slugify(a_t)               
+        if '-' not in a:
+            if a[-1] == 's':
+                  a_s = p.singular_noun(a)
+                  a_lex = "tv_finsg("+a+", "+str(a_s)+")."
+                  strpos = f.find(a_lex)
+                  if strpos != -1: 
+                       return True
+                  else:
+                       return False
+
+
+#Returns attributes for the given OT
+def get_attr_sentence(self):
+   if self.ref.__class__.__name__ is 'Objecttype':
+     from django.template.defaultfilters import slugify
+     ot = self.get_attributes
+     if not ot:
+          pass
+     else:
+       a = []
+       title = self.title
+       title_slug = slugify(title)
+       for k,v in ot.iteritems():
+             attr = k
+             for each in v:
+                  value = each
+       attr_slug = slugify(attr)
+       sen = "The "+str(attr_slug)+" of a "+str(title_slug)+" is "+str(value)+"."
+       a.append(sen)
+       return a
+   else:
+     pass
+
+
+def get_list_relation(self, lr):
+      """Returns the list of relations"""     
+      gbr = self.get_relations1
+      if not gbr:
+            pass
+      else:
+          for k,v in gbr.iteritems():
+               if k == 'lrelations':
+                    val_l = v
+               if k == 'rrelations':
+                    val_r = v
+          
+          if lr == 0:
+                return val_l
+          elif lr == 1:
+                return val_r
+
+#Generating CNL for RT and Relations:
+#(**Execute get_lex property to update new RT's in lexicon before executing CNL sentences.)
+def get_CNL_sentence_RT(self, lst, rst, detail_level):      
+      if self.ref.__class__.__name__ is 'Relationtype':
+         core = [] #core data list
+         core_t = []
+         core_i = []
+         reflexive = []
+	 adv = [] # advanced data list             
+         title=self.title
+         title_slug=slugify(title)
+         inverse=self.inverse
+         inverse_slug=slugify(inverse)
+         is_symmetrical=self.is_symmetrical
+         is_reflexive=self.is_reflexive
+         llist = []
+         rlist = []
+         llist = lst
+         rlist = rst
+         #print "lst",llist
+         #print "rst",rlist
+         #Flag variable that checks if plural or not
+         plural_l = 0
+         plural_r = 0
+         #print "ll--",llist 
+         #print "rr---",rlist
+         if isinstance(llist,list):
+            """If llist is a list"""
+            ll = []
+            for each in llist:                
+                if each.ref.__class__.__name__ is not 'Gbobject':
+                    """Common-noun"""
+                    lst = "a "+str(each).lower()
+                else:
+                    """Proper-noun"""
+                    lst = str(each).title()
+                ll.append(lst)
+		#print "ll",ll
+            if len(ll) == 1:
+                   for e in ll: 
+                       left_subtype = e
+		       #print "e in ll",left_subtype
+            else: 
+                   plural_l = 1 
+                   for e in ll:
+                        if ll.index(e)==0:
+                             sen = str(e)
+                        else:
+                             sen = str(sen)+" and "+str(e)
+                   left_subtype = sen                    
+         else:
+                 """If llist is not a list"""
+                 if lst.ref.__class__.__name__ is 'Gbobject':  
+                     left_subtype = lst
+                 else:
+                     left_subtype = "a "+str(lst) 
+         #print "left_subtype---",left_subtype  
+         
+         if isinstance(rlist,list):
+            """If rlist is a list"""
+            rl = []
+            for each in rlist:                
+                if each.ref.__class__.__name__ is not 'Gbobject':
+                    """Common-noun"""
+                    rst = "a "+str(each)
+                else:
+                    rst = each
+                rl.append(rst)
+            if len(rl) == 1:
+                   for e in rl: 
+                       right_subtype = e
+                       #print "rst in e---",right_subtype
+            else:  
+                   plural_r = 1
+                   for e in rl:
+                        if rl.index(e)==0:
+                             sen = str(e)
+                        else:
+                             sen = str(sen)+" and "+str(e)
+                   right_subtype = sen                    
+         else:
+                 """If Rlist is not a list"""
+                 if rst.ref.__class__.__name__ is 'Gbobject':
+                    right_subtype = rst 
+                 else:
+                    right_subtype = "a "+str(rst)     
+         #print "right_subtype---",right_subtype   
+         
+         
+         #Core sentence - title       
+         
+         rel = rel_CNL(self, left_subtype, right_subtype, plural_l)
+         #print rel, "the sentence"
+         #print left_subtype
+         #print right_subtype
+         core_t.extend(rel)               
+         
+        
+         rlex = rel_lex_sentence(self)
+         adv.extend(rlex)
+         #print "rlex---",rlex
+ 
+         app_NT = get_app_NT(self)
+         adv.extend(app_NT)
+         #print "app_NT",app_NT
+         
+         st = get_RT_subjecttype(self, left_subtype, right_subtype)
+         adv.extend(st)
+         #print "st---",st
+         
+        
+    
+         #Is symmetrical
+         if is_symmetrical:
+            symm = is_symmetrical_RT(self, left_subtype, right_subtype, plural_r)
+            core_i.extend(symm)               
+            #print "symm---",symm
+         
+         else:
+            asymm = is_asymmetrical_RT(self, left_subtype, right_subtype, plural_r)
+            core_i.extend(asymm)
+            #print "asymm--",asymm
+         #Is reflexive 
+         if is_reflexive:
+           if detail_level == 1 or plural_l == 1:
+                 st = right_subtype
+           else:
+                 st = left_subtype
+           is_refl = is_reflexive_sentence(self, st)          
+           core.extend(is_refl)
+           reflexive.extend(is_refl)                              
+           #print "is_refl" ,is_refl            
+                    
+         if detail_level==0:
+               #Title,Reflexive
+               for e in core_t:
+                   a = e
+               reflexive.insert(0, a)
+               return reflexive
+	 elif detail_level==1:
+               #Inverse,reflexive
+	       for e in core_i:
+                    a = e
+               reflexive.insert(0,a)
+               return reflexive
+         elif detail_level==2:
+               #Title, Inverse & Reflexive
+               core.extend(core_t)
+               core.extend(core_i)
+               core.extend(reflexive)
+               return core
+         elif detail_level==3:
+               #Return advanced grammatical information
+	       return adv
+	 elif detail_level==4:
+                #Return all info - Core & Advanced Info
+	 	newlist = []
+	 	newlist.extend(core)
+	 	newlist.extend(adv)
+	  	return newlist
+
+def rel_CNL(self, left_subtype, right_subtype, plural_l):
+   """To generate sentence for relation"""
+   title = self.title
+   title_slug = slugify(title)
+   if self.ref.__class__.__name__ is 'Relationtype':
+     rel = []
+     if istv_title(self):
+           st = str(left_subtype)+" "+str(title).lower()+" "+str(right_subtype)+"."
+     else: 
+        if plural_l == 0:
+              st = str(left_subtype)+" is "+str(title).lower()+" "+str(right_subtype)+"."
+        elif plural_l == 1:
+              st = str(left_subtype)+" are "+str(title).lower()+" "+str(right_subtype)+"."
+     rel.append(st.capitalize())
+   return rel  
+         
+         
+def is_reflexive_sentence(self, st):
+      refl = []
+      title = self.title
+      title_slug = slugify(title)
+      if istv_title(self): 
+         j= "It is a reflexive sentence. "+str(st).title()+" "+str(title)+" "+str(st)+"."
+      else:
+         j= "It is a reflexive sentence. "+str(st).title()+" is "+str(title)+" "+str(st)+"."
+      refl.append(j)  
+      return refl
+
+def is_symmetrical_RT(self, left_subtype, right_subtype, plural_r):
+          """Generates CNL Sentence for Relation/RT if symmetrical"""
+          symm = []
+          title = self.title
+          title_slug = slugify(title)
+          if istv_title(self):
+             g = str(right_subtype).title()+" "+str(title)+" "+str(left_subtype).title()+"."
+          else:
+            if plural_r == 0:
+               g = str(right_subtype).title()+" is "+str(title)+" "+str(left_subtype).title()+"."  
+            else:
+               g = str(right_subtype).title()+" are "+str(title)+" "+str(left_subtype).title()+"."  
+          symm.append(g.capitalize())
+          return symm
+
+def is_asymmetrical_RT(self, left_subtype, right_subtype, plural_r):
+      """Generates CNL Sentence for Relation/RT if symmetrical"""
+      asymm = []
+      inverse = self.inverse
+      inverse_slug = slugify(inverse)
+      if istv_inverse(self):
+             g = str(right_subtype).title()+" "+str(inverse)+" "+str(left_subtype).title()+"."
+      else:
+         if plural_r == 0:
+             g = str(right_subtype).title()+" is "+str(inverse)+" "+str(left_subtype).title()+"."
+         elif plural_r == 1:
+             g = str(right_subtype).title()+" is "+str(inverse)+" "+str(left_subtype).title()+"."
+      asymm.append(g.capitalize())          
+      return asymm
+
+
+def rel_lex_sentence(self):
+   """Generates RT's title & inverse sentence"""
+   if self.ref.__class__.__name__ is 'Relationtype':
+      rlex = []
+      title=self.title
+      title_slug=slugify(title)
+      inverse=self.inverse
+      inverse_slug=slugify(inverse)
+      h="A relation_type's title is "+str(title_slug)+"."
+      rlex.append(h.capitalize())
+      
+      if (title==inverse):
+             b="Its title and its inverse are equal."
+      else:
+             b="Its inverse is "+str(inverse_slug)+"."
+      rlex.append(b.capitalize())
+      return rlex
+
+
+def get_app_NT(self):
+     """Generates CNL Sentences for left & right applicable NT for RT"""
+     if self.ref.__class__.__name__ is 'Relationtype':
+         a = []
+         l_app = self.left_applicable_nodetypes         
+         r_app=self.right_applicable_nodetypes   
+         e = "Its left_applicable_nodetype is "+str(l_app).upper()+"."
+         a.append(e)
+         
+         f = "Its right_applicable_nodetype is "+str(r_app).upper()+"."
+         a.append(f) 
+         return a     
+         
+         
+        
+def get_RT_sentence(self):
+       #Generates CNL Sentences in RT
+       if self.ref.__class__.__name__ is 'Relationtype':
+          sentence = get_CNL_sentence_RT(self, self.left_subjecttype, self.right_subjecttype, 4)
+          return sentence  
+
+       #Generates CNL sentences in Relation
+       elif self.ref.__class__.__name__ is 'Relation':
+          sentence = get_CNL_sentence_RT(self.relationtype, self.left_subject, self.right_subject, 4)
+          return sentence
+       else:
+         pass
+
+
+
+
+def get_rel(self):
+  if not self.ref.__class__.__name__ is 'Objecttype':
+    pass
+  else:
+    sen = []
+    sentence = []
+    lr = Relation.objects.filter(left_subject = self.id)
+    rr = Relation.objects.filter(right_subject = self.id)
+    
+       
+    if lr:
+      """List which stores each right subject"""
+      lst = get_list_relation(self, 0)
+      #print "LR",lst
+      for k,v in lst.iteritems():      
+          rel = Relationtype.objects.filter(title = k)
+          val = v   
+          for rt in rel:  
+             sen = get_CNL_sentence_RT(rt, self, val, 0)
+             #print "sen----lr",sen
+             sentence.extend(sen)
+      #print "sentence lr",sentence
+          
+    if rr:
+       """List which stores each left subject"""
+       lst = get_list_relation(self, 1)
+       #print "RR",lst
+       for k,v in lst.iteritems():      
+          rel = Relationtype.objects.filter(inverse = k)
+          val = v 
+          #print "rel ",rel
+          #print "v ",v  
+          for rt in rel:  
+             sen = get_CNL_sentence_RT(rt, val, self, 1)
+             #print sen,"sen"
+             sentence.extend(sen)     
+    return sentence
+
+
+
+def get_RT_subjecttype(self,lst,rst):
+   """Returns CNL sentence of left & right subject type of RT"""
+   if self.ref.__class__.__name__ is 'Relationtype':
+       left_subtype = lst
+       right_subtype = rst
+       st = []
+       ce = "Its left_subjecttype is "+str(left_subtype)+"."
+       c = ce.capitalize()
+       st.append(c)
+        
+       de = "Its right_subjecttype is "+str(right_subtype)+"."
+       d = de.capitalize()
+       st.append(d)
+       return st
+   else:
+       pass    
+
+
+
+	
+
+      
+
+
+
diff --git a/gstudio/createhtml.py b/gstudio/createhtml.py
new file mode 100755
index 0000000..7841408
--- /dev/null
+++ b/gstudio/createhtml.py
@@ -0,0 +1,19 @@
+#! /usr/bin/env python
+
+import sys
+import os
+import commands
+
+def main(argv):
+    #f_name =sys.argv[1]
+    f_name = "/tmp/file.org"
+    s1='commands.getoutput("emacs --batch '
+    s2=" --eval '"
+    s3="(org-export-as-html nil)'"
+    s4='")'
+    out = str(s1)+str(f_name)+str(s2)+str(s3)+str(s4)
+    exec out
+
+if __name__ == "__main__":
+    main(sys.argv)
+
diff --git a/gstudio/lex.py b/gstudio/lex.py
new file mode 100644
index 0000000..a0a90ed
--- /dev/null
+++ b/gstudio/lex.py
@@ -0,0 +1,147 @@
+from gstudio.models import *
+from objectapp.models import *
+from django.template.defaultfilters import slugify
+import inflect
+
+
+def get_lex_author(self):
+         """
+         Generating lexicon file for authors-Proper name
+         """
+         author=self.authors.all()
+         author_list=[]
+         for each in author:              
+              author_each=str(each).capitalize()
+              aut="pn_sg('"+author_each+"', '"+author_each+"', neutr)."
+              author_list.append(aut)
+         return author_list 
+
+
+
+def get_lex_GB(self):
+    if self.ref.__class__.__name__ is 'Gbobject':
+         a=[]            
+         title=self.title
+         title_slug=slugify(title)
+         
+         alt=self.altnames 
+         alt_slug=slugify(alt)  
+         singular="pn_sg('"+title_slug.title()+"', '"+title_slug.title()+"', neutr)."   
+         a.append(singular)
+         
+         if alt:
+           alts="pn_sg('"+str(alt_slug).title()+"', '"+str(alt_slug).title()+"', neutr)." 
+           a.append(alts)
+         return a  
+
+
+
+def get_lex_RT(self):
+     if self.ref.__class__.__name__ is 'Relationtype':
+         p = inflect.engine()   
+         a=[]
+         title=self.title
+         st=str(title)
+         rst=slugify(st)
+         if '-' in rst:
+           i=rst.index('-')
+           j=i+1           
+           l=len(rst)         
+           ss=rst[j:l]                
+           lext = "adj_tr('"+rst+"', '"+rst+"', "+ss+")."           
+           a.append(lext)
+           lex_p = "prep("+ss+", "+ss+")."
+           a.append(lex_p)
+         else:
+           if rst[-1] == 's':
+             rst_sing = p.singular_noun(rst)             
+             lex_tv = "tv_finsg("+rst+", "+rst_sing+")."             
+             a.append(lex_tv)
+           else:
+             lexa = "adj_tr('"+rst+"', '"+rst+"', -)."             
+             a.append(lexa)
+         inverse=self.inverse
+         if title!=inverse:           
+           sti=str(inverse)
+           rsti=slugify(sti)           
+           if '-' in rsti:
+             ii=rsti.index('-')
+             ji=ii+1
+             li=len(rsti)              
+             ssi=rsti[ji:li]               
+             lexi="adj_tr('"+rsti+"', '"+rsti+"', "+ssi+")."             
+             a.append(lexi)
+             lex_pi = "prep("+ssi+", "+ssi+")."             
+             a.append(lex_pi)
+           else:
+            if rsti[-1] == 's':
+              rsti_sing = p.singular_noun(rsti)              
+              lex_tvi = "tv_finsg("+rsti+", "+rsti_sing+")."             
+              a.append(lex_tvi)
+            else:
+              lexi_a = "adj_tr('"+rsti+"', '"+rsti+"', -)."                 
+              a.append(lexi_a)    
+         return a 
+
+
+def get_lex_AT(self):
+      if self.ref.__class__.__name__ is 'Attributetype':
+         """Generates Lexicon entries for AT"""
+         a=[]
+         title = self.title
+         st=str(title)         
+         rst=slugify(st)                        
+         singular="noun_sg("+rst+", "+rst+", neutr)."                    
+         a.append(singular)
+         alt=self.altnames 
+         if alt:  
+           st_a=str(alt)           
+           rst_a=slugify(st_a)                         
+           singular_a="noun_sg("+rst_a+", "+rst_a+", neutr)."                    
+           a.append(singular_a)
+         return a
+
+
+def get_lex_MT(self):
+    if self.ref.__class__.__name__ is 'Metatype':
+         a=[]
+         from django.template.defaultfilters import slugify   
+         title=self.title
+         title_slug=slugify(title)
+         plural=self.plural
+         plural_slug=slugify(plural) 
+         alt=self.altnames 
+         alt_slug=slugify(alt)  
+         singular="noun_sg("+title_slug+", "+title_slug+", neutr)."                    
+         a.append(singular)
+         if plural:         
+           pl="noun_pl("+str(plural_slug)+", "+str(title_slug)+", neutr)."  
+           a.append(pl)
+         if alt:
+           alts="noun_sg("+str(alt_slug)+", "+str(alt_slug)+", neutr)." 
+           a.append(alts)
+         return a 
+
+
+
+def get_lex_OT(self):
+         """
+         Generating lexicon file for Objecttype-Noun singular, plural
+         """
+         a=[]
+         title=self.title
+         slug_title=slugify(title)         
+         plural=self.plural
+         slug_plural=slugify(plural)    
+         alt=self.altnames
+         slug_alt=slugify(alt)
+         singular="noun_sg("+slug_title+", "+slug_title+", neutr)."                    
+         a.append(singular)
+         if plural:
+            pl="noun_pl("+str(slug_plural)+", "+str(slug_title)+", neutr)."  
+            a.append(pl)
+         if alt:
+            alts="noun_sg("+str(slug_alt)+", "+str(slug_alt)+", neutr)." 
+            a.append(alts)
+         
+         return a 
diff --git a/gstudio/models.py b/gstudio/models.py
index 690fccc..1518229 100644
--- a/gstudio/models.py
+++ b/gstudio/models.py
@@ -755,7 +755,7 @@ class Nodetype(Node):
                       (PUBLISHED, _('published')))
 
     content = models.TextField(_('content'), null=True, blank=True)
-   # content_org = models.TextField(_('content'), null=True, blank=True)
+    content_org = models.TextField(_('content_org'), null=True, blank=True)
     parent = models.ForeignKey('self', null=True, blank=True,
                                verbose_name=_('is a kind of'),
                                related_name='children')
diff --git a/gstudio/static/gstudio/js/orgitdown/orgitdown/jquery.orgitdown.js b/gstudio/static/gstudio/js/orgitdown/orgitdown/jquery.orgitdown.js
index fe3a487..c766300 100755
--- a/gstudio/static/gstudio/js/orgitdown/orgitdown/jquery.orgitdown.js
+++ b/gstudio/static/gstudio/js/orgitdown/orgitdown/jquery.orgitdown.js
@@ -438,7 +438,34 @@
 				} 
 				return selection;
 			}
-
+	                function save() {
+			         var org_data = $("#gnoweditor").val();
+			         var id =  document.getElementById("objectid").value
+			         document.getElementById("orgcontent").value = org_data;
+			         var encode_data = encodeURIComponent(org_data);
+                                                       
+		         $.ajax({
+			       url: '/nodetypes/ajax/contentorgadd/?id=' + id + '&contentorg=' + encode_data,
+			       success: function(data) {
+			         $.ajax({
+				    url: '/nodetypes/ajax/ajaxcreatefile/?id=' +id+ '&content_org=' +encode_data,
+				    success: function(data) {
+				    	$.ajax({
+				    		url: '/nodetypes/ajax/ajaxcreatehtml/',
+				    		success: function(data) {
+				    		    $.ajax({
+				    			    url: '/nodetypes/ajax/contentadd/?id=' +id,
+                                                            success: function(data) {
+                                                              alert("Data Saved");
+                                                              location.reload();}
+				    			});
+				    		}      
+				     	    });
+				     }
+				}); 
+			    
+                    }
+                 });}
 			// open preview window
 			function preview() {
 				if (typeof options.previewHandler === 'function') {
diff --git a/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/images/save.jpeg b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/images/save.jpeg
new file mode 100644
index 0000000..fb92d0b
--- /dev/null
+++ b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/images/save.jpeg
diff --git a/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/set.js b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/set.js
index 5eed850..25b118e 100644
--- a/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/set.js
+++ b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/set.js
@@ -14,6 +14,7 @@ var mySettings = {
 	onAltEnter:     {keepDefault:false, replaceWith:'\n* '},
 	onAltrightArrow: {keepDefault:false, replaceWith:'*'},
 	markupSet:  [ 	
+                {name:'Save', key:'S',call:'save' },
 		{name:'Bold', key:'B', openWith:'*', closeWith:'*' },
 		{name:'Italic', key:'I', openWith:'/', closeWith:'/'  },
 		{name:'Stroke through', key:'S', openWith:'+', closeWith:'+' },
@@ -21,7 +22,7 @@ var mySettings = {
 		{name:'Bulleted List', openWith:'    - ', closeWith:'', multiline:true, openBlockWith:'\n', closeBlockWith:'\n'},
 		{name:'Numeric List', openWith:'    1. ', closeWith:'', multiline:true, openBlockWith:'\n', closeBlockWith:'\n'},
 		{separator:'---------------' },
-		{name:'Picture', key:'P', replaceWith:'[[file:fileName.jpg]]' },
+		{name:'Picture', key:'P', replaceWith:'[[http:fileName.jpg]]' },
 		{name:'Link', key:'L', openWith:'[[http://your.address.com here/][Your visible link text here]]', closeWith:'', placeHolder:'' },
 		{separator:'---------------' },
 		{name:'Clean', className:'clean', replaceWith:function(orgitdown) { return orgitdown.selection.replace(/<(.*?)>/g, "") } },		
diff --git a/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/savedata.js b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/savedata.js
index f407075..eaf728c 100644
--- a/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/savedata.js
+++ b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/savedata.js
@@ -1,15 +1,13 @@
  $.noConflict();
   jQuery(document).ready(function($) {
-    // Code that uses jQuery's $ can follow here.
-	$("#editdata").click(function(){
-		//	$("html").css({"margin":"0","padding": "0","overflow":"hidden","height": "100%"});
+   	$("#editdata").one("click",function() {
 	$("#chart").hide();
+	var orgdata = document.getElementById('orgcontent').value;
 	document.getElementById('gnoweditor').style.visibility="visible";
-	//$("#gnoweditor").show();
-       	$("#gnoweditor").orgitdown(mySettings);
-	//	alert($("#gnoweditor").val());
+	$("#gnoweditor").orgitdown(mySettings);
+	$("#gnoweditor").val(orgdata);
 
-	    });
+	      });
        
   });
 
diff --git a/gstudio/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor.png b/gstudio/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor.png
deleted file mode 100644
index 31fae12..0000000
--- a/gstudio/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor.png
+++ /dev/null
diff --git a/gstudio/templates/gstudio/nodetype_detail.html b/gstudio/templates/gstudio/nodetype_detail.html
index ee7cfcb..c6b86eb 100644
--- a/gstudio/templates/gstudio/nodetype_detail.html
+++ b/gstudio/templates/gstudio/nodetype_detail.html
@@ -60,150 +60,156 @@
 <!-- Neighbourhood listing starts -->
 <!--Name,Plural Name , Alternate Name ,Type of -->
                            <b>Name:<nbsp></b> {{ object.title }} <br/>
+<!-- Include CNL -->
+			   <b>CNL:<nbsp></b><br>
+			   {% get_CNL object as cnlobj %}
+			   {% for obj in cnlobj %}
+			        {{obj}}<br>
+			   {% endfor %}
                            
-			   {% if object.get_rendered_nbh.plural %}
-                                <b> Plural Name:<nbsp></b>
-                                         {{object.get_rendered_nbh.plural}} <br/>
-                           {% endif %}
-                            {% if object.get_rendered_nbh.altnames %}
-                               <b> Alternate names:<nbsp></b>
-                                         {{object.get_rendered_nbh.altnames}} <br/>
-		           {% endif %}
-	                   {% if object.get_rendered_nbh.type_of %}
-                                <b> Type of:<nbsp></b>
-                                {% for typekey,typevalue in object.get_rendered_nbh.type_of.items %}
-                                       <a href="{{typevalue}}" title = "{{typekey}}">{{typekey}}</a>;
-                                {% endfor %}<br/>
-                           {% endif %}
+<!-- 			   {% if object.get_rendered_nbh.plural %} -->
+<!--                                 <b> Plural Name:<nbsp></b> -->
+<!--                                          {{object.get_rendered_nbh.plural}} <br/> -->
+<!--                            {% endif %} -->
+<!--                             {% if object.get_rendered_nbh.altnames %} -->
+<!--                                <b> Alternate names:<nbsp></b> -->
+<!--                                          {{object.get_rendered_nbh.altnames}} <br/> -->
+<!-- 		           {% endif %} -->
+<!-- 	                   {% if object.get_rendered_nbh.type_of %} -->
+<!--                                 <b> Type of:<nbsp></b> -->
+<!--                                 {% for typekey,typevalue in object.get_rendered_nbh.type_of.items %} -->
+<!--                                        <a href="{{typevalue}}" title = "{{typekey}}">{{typekey}}</a>; -->
+<!--                                 {% endfor %}<br/> -->
+<!--                            {% endif %} -->
 
-<!-- Member of metatypes -->
-			    {% if object.get_rendered_nbh.member_of_metatypes %}
+<!-- <\!-- Member of metatypes -\-> -->
+<!-- 			    {% if object.get_rendered_nbh.member_of_metatypes %} -->
                            
                           
-                                <b> Member of Metatypes:<nbsp></b>
-                                    {% for mkey,mvalue in object.get_rendered_nbh.member_of_metatypes.items %}
-                                        <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>;
-                                    {% endfor %}<br/>
-                           {% endif %}
+<!--                                 <b> Member of Metatypes:<nbsp></b> -->
+<!--                                     {% for mkey,mvalue in object.get_rendered_nbh.member_of_metatypes.items %} -->
+<!--                                         <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>; -->
+<!--                                     {% endfor %}<br/> -->
+<!--                            {% endif %} -->
                           
 			   
-<!-- Subtypes -->			        
-                           {% if object.get_rendered_nbh.contains_subtypes %}
-                                <b> Contains SubTypes:<nbsp></b>
-                                {% for stkey,stvalue in object.get_rendered_nbh.contains_subtypes.items %}
-                                        <a href="{{stvalue}}" title = "{{stkey}}">{{stkey}}</a>;
-                                {% endfor %}<br/>
-                           {% endif %}
+<!-- <\!-- Subtypes -\->			         -->
+<!--                            {% if object.get_rendered_nbh.contains_subtypes %} -->
+<!--                                 <b> Contains SubTypes:<nbsp></b> -->
+<!--                                 {% for stkey,stvalue in object.get_rendered_nbh.contains_subtypes.items %} -->
+<!--                                         <a href="{{stvalue}}" title = "{{stkey}}">{{stkey}}</a>; -->
+<!--                                 {% endfor %}<br/> -->
+<!--                            {% endif %} -->
                           
-<!-- Members -->                          
-                           {% if object.get_rendered_nbh.contains_members %}
+<!-- <\!-- Members -\->                           -->
+<!--                            {% if object.get_rendered_nbh.contains_members %} -->
                          
                           
-                                <b>Contains Members:<nbsp></b>
-                                    {% for mkey,mvalue in object.get_rendered_nbh.contains_members.items %}
-                                        <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>;
-                                    {% endfor %}<br/>
-                           {% endif %}
+<!--                                 <b>Contains Members:<nbsp></b> -->
+<!--                                     {% for mkey,mvalue in object.get_rendered_nbh.contains_members.items %} -->
+<!--                                         <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>; -->
+<!--                                     {% endfor %}<br/> -->
+<!--                            {% endif %} -->
                          
-<!-- Authors -->                           
-                           {% if object.get_rendered_nbh.authors %}
+<!-- <\!-- Authors -\->                            -->
+<!--                            {% if object.get_rendered_nbh.authors %} -->
                          
                            
                                 
-				   <b>Authors: <nbsp> </b>
+<!-- 				   <b>Authors: <nbsp> </b> -->
                                 
 				       
-	                   {% endif %}
+<!-- 	                   {% endif %} -->
 			
-                              {% for author in object.authors.all %}
-      			<span class="vcard author">
-        		<a href="{% url gstudio_author_detail author %}" class="fn nickname url" rel="author"
-           		title="{% blocktrans with author as author %}Show {{ author }} nodetypes{% endblocktrans %}">{{ author }}</a>
-      			</span>{% if not forloop.last %}, {% endif %}
-      				{% endfor %} <br/>
+<!--                               {% for author in object.authors.all %} -->
+<!--       			<span class="vcard author"> -->
+<!--         		<a href="{% url gstudio_author_detail author %}" class="fn nickname url" rel="author" -->
+<!--            		title="{% blocktrans with author as author %}Show {{ author }} nodetypes{% endblocktrans %}">{{ author }}</a> -->
+<!--       			</span>{% if not forloop.last %}, {% endif %} -->
+<!--       				{% endfor %} <br/> -->
                          
-<!-- Prior nodes -->                            
+<!-- <\!-- Prior nodes -\->                             -->
                             
-                            {% if object.get_rendered_nbh.priornodes %}
+<!--                             {% if object.get_rendered_nbh.priornodes %} -->
                          
                            
-                                <b>Prior nodes:<nbsp></b>
-                                    {% for mkey,mvalue in object.get_rendered_nbh.priornodes.items %}
-                                        <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>;
-                                    {% endfor %}<br/>
-                           {% endif %}
-<!-- Posterior nodes -->                           
-                           {% if object.get_rendered_nbh.posteriornodes %}
+<!--                                 <b>Prior nodes:<nbsp></b> -->
+<!--                                     {% for mkey,mvalue in object.get_rendered_nbh.priornodes.items %} -->
+<!--                                         <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>; -->
+<!--                                     {% endfor %}<br/> -->
+<!--                            {% endif %} -->
+<!-- <\!-- Posterior nodes -\->                            -->
+<!--                            {% if object.get_rendered_nbh.posteriornodes %} -->
                          
                            
-                                <b>Posterior nodes:<nbsp></b>
-                                    {% for mkey,mvalue in object.get_rendered_nbh.posteriornodes.items %}
-                                        <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>;
-                                    {% endfor %}<br/>
-                           {% endif %}
-<!-- Relations -->                             
-                            {% if object.get_rendered_nbh.relations %}
+<!--                                 <b>Posterior nodes:<nbsp></b> -->
+<!--                                     {% for mkey,mvalue in object.get_rendered_nbh.posteriornodes.items %} -->
+<!--                                         <a href="{{mvalue}}" title = "{{mkey}}">{{mkey}}</a>; -->
+<!--                                     {% endfor %}<br/> -->
+<!--                            {% endif %} -->
+<!-- <\!-- Relations -\->                              -->
+<!--                             {% if object.get_rendered_nbh.relations %} -->
                          
                          
-                                 {% for relkey,relvalue in object.get_rendered_nbh.relations.items %}
-                                          <b>{{relkey}}:<nbsp></b>
-					{% for relk, relv in relvalue.items %}
-					    <a href="{{relv}}" title = "{{relk}}">{{relk}}</a>;	      
-                                        {% endfor %}<br/>
-				 {% endfor %}      
-	                   {% endif %}
-<!-- Attributes -->                           
-                           {% if object.get_rendered_nbh.attributes %}
+<!--                                  {% for relkey,relvalue in object.get_rendered_nbh.relations.items %} -->
+<!--                                           <b>{{relkey}}:<nbsp></b> -->
+<!-- 					{% for relk, relv in relvalue.items %} -->
+<!-- 					    <a href="{{relv}}" title = "{{relk}}">{{relk}}</a>;	       -->
+<!--                                         {% endfor %}<br/> -->
+<!-- 				 {% endfor %}       -->
+<!-- 	                   {% endif %} -->
+<!-- <\!-- Attributes -\->                            -->
+<!--                            {% if object.get_rendered_nbh.attributes %} -->
                            
-				    {% for atkey,atvalue in object.get_rendered_nbh.attributes.items %}
-                                      {% if atvalue %}
-                                       <b>{{atkey}}:<nbsp> </b>
-                                        {% for atr in atvalue %}
+<!-- 				    {% for atkey,atvalue in object.get_rendered_nbh.attributes.items %} -->
+<!--                                       {% if atvalue %} -->
+<!--                                        <b>{{atkey}}:<nbsp> </b> -->
+<!--                                         {% for atr in atvalue %} -->
 						
-                                            {% for urlkey,urlvalue in object.get_edit_url_for_ats.items %}
+<!--                                             {% for urlkey,urlvalue in object.get_edit_url_for_ats.items %} -->
                                                      
-                                                   {% ifequal atr urlvalue %}
-                                                         {{atr}}<a href="{{ urlkey}}" title = "edit">[edit]</a> ;
-                                                   {% endifequal %}
-       					     {% endfor %} 
-                                         {% endfor %} <br/>
-                                      {% endif %}
-				    {% endfor %}       
-	                   {% endif %}
-<!-- Left roles -->
-                            {% if object.get_rendered_nbh.leftroles %}
+<!--                                                    {% ifequal atr urlvalue %} -->
+<!--                                                          {{atr}}<a href="{{ urlkey}}" title = "edit">[edit]</a> ; -->
+<!--                                                    {% endifequal %} -->
+<!--        					     {% endfor %}  -->
+<!--                                          {% endfor %} <br/> -->
+<!--                                       {% endif %} -->
+<!-- 				    {% endfor %}        -->
+<!-- 	                   {% endif %} -->
+<!-- <\!-- Left roles -\-> -->
+<!--                             {% if object.get_rendered_nbh.leftroles %} -->
                          
                                                          
-				   <b>Left roles:<nbsp> </b>
+<!-- 				   <b>Left roles:<nbsp> </b> -->
                                 
-				    {% for lrkey,lrvalue in object.get_rendered_nbh.leftroles.items %}
-                                        <a href="{{lrvalue}}" title = "{{lrkey}}">{{lrkey}}</a>;	      
-				    {% endfor %}       <br/>
-	                   {% endif %}
-<!-- Right roles -->                           
-                           {% if object.get_rendered_nbh.rightroles %}
+<!-- 				    {% for lrkey,lrvalue in object.get_rendered_nbh.leftroles.items %} -->
+<!--                                         <a href="{{lrvalue}}" title = "{{lrkey}}">{{lrkey}}</a>;	       -->
+<!-- 				    {% endfor %}       <br/> -->
+<!-- 	                   {% endif %} -->
+<!-- <\!-- Right roles -\->                            -->
+<!--                            {% if object.get_rendered_nbh.rightroles %} -->
                         
-			      <b>Right roles:<nbsp> </b>
+<!-- 			      <b>Right roles:<nbsp> </b> -->
                                 
-				    {% for rrkey,rrvalue in object.get_rendered_nbh.rightroles.items %}
-                                        <a href="{{rrvalue}}" title = "{{rrkey}}">{{rrkey}}</a>;	      
-				    {% endfor %}       <br/>
-	                   {% endif %}
-<!-- Attributes -->                           
+<!-- 				    {% for rrkey,rrvalue in object.get_rendered_nbh.rightroles.items %} -->
+<!--                                         <a href="{{rrvalue}}" title = "{{rrkey}}">{{rrkey}}</a>;	       -->
+<!-- 				    {% endfor %}       <br/> -->
+<!-- 	                   {% endif %} -->
+<!-- <\!-- Attributes -\->                            -->
                           
-                           {% if object.get_rendered_nbh.ats %}
+<!--                            {% if object.get_rendered_nbh.ats %} -->
                                              
                                 
-				   <b>Subjecttype of:<nbsp> </b>
+<!-- 				   <b>Subjecttype of:<nbsp> </b> -->
                                 
-				    {% for atkey,atvalue in object.get_rendered_nbh.ats.items %}
-                                        <a href="{{atvalue}}" title = "{{atkey}}">{{atkey}}</a>;	      
-				    {% endfor %}       <br/>
-	                   {% endif %}
+<!-- 				    {% for atkey,atvalue in object.get_rendered_nbh.ats.items %} -->
+<!--                                         <a href="{{atvalue}}" title = "{{atkey}}">{{atkey}}</a>;	       -->
+<!-- 				    {% endfor %}       <br/> -->
+<!-- 	                   {% endif %} -->
 
 
 				
-<!-- Content -->                           
+<!-- <\!-- Content -\->                            -->
 			    {% if object.content %}
                             <b>
 					Content:<nbsp>
diff --git a/gstudio/templates/gstudio/skeleton.html b/gstudio/templates/gstudio/skeleton.html
index 45466cd..170c898 100644
--- a/gstudio/templates/gstudio/skeleton.html
+++ b/gstudio/templates/gstudio/skeleton.html
@@ -1,4 +1,417 @@
+<<<<<<< HEAD
+
+=======
+{% load gstudio_tags i18n  %}
+{% get_tags as nodetype_tags %}
+{% load adminmedia  grp_tags %}
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xml:lang="{{ LANGUAGE_CODE }}" lang="{{ LANGUAGE_CODE }}" version="-//W3C//DTD XHTML 1.1//EN" xmlns="http://www.w3.org/1999/xhtml">
+	<head>
+		<style type="text/css">
+			.link {
+				stroke: #ccc;
+			}
+			.nodetext {
+				#pointer-events: none;
+				font: 12px Serif;
+				font-style:italic;
+			}
+			.mainnode{
+
+ 				font: 15px sans-serif;
+			        fill:black;
+				border-width: 1px;
+				font-weight:bold;
+				border-color: gray;
+
+			}
+			.relnode {
+ 				font: 12px sans-serif;
+				font-weight:bold;
+			           fill:#000;
+			}
+			
+
+			.node {
+				border-width: 1px;
+				border-color: gray;
+			      	font: 12px sans-serif;
+					fill:#25587E;
+				font-weight:bold;
+			}
+			body {
+				background-color: white;
+			}
+			#chart {
+				height: 90%;
+				margin: 0 auto;
+				width: 90%;
+				display: block;
+			}
+			svg {
+				margin-left: 0%;
+				margin-right: 10%;
+				display: block;
+				position: absolute;
+			}
+.orgitdown .orgitdownButton1 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/org/images/save.jpeg);
+}
+.orgitdown .orgitdownButton2 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/bold.png);
+}
+.orgitdown .orgitdownButton3 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/italic.png);
+}
+.orgitdown .orgitdownButton4 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/stroke.png);
+}
+
+.orgitdown .orgitdownButton5 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/list-bullet.png); 
+}
+.orgitdown .orgitdownButton6 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/list-numeric.png);
+}
+
+.orgitdown .orgitdownButton7 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/picture.png); 
+}
+.orgitdown .orgitdownButton8 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/link.png);
+}
 
+.orgitdown .orgitdownButton9 a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/clean.png);
+}
+.orgitdown .preview a {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/preview.png);
+}
+
+.orgitdown * {
+	margin:0px; padding:0px;
+	outline:none;
+}
+.orgitdown a:link,
+.orgitdown a:visited {
+	color:#000;
+	text-decoration:none;
+}
+.orgitdown  {
+	width:700px;
+	margin:5px 0 5px 0;
+		
+}
+.orgitdownContainer  {
+	border:1px solid #3C769D;	
+	background:#FFF url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-container.png) repeat-x top left; 
+	padding:5px 5px 2px 5px;
+	font:11px Verdana, Arial, Helvetica, sans-serif;
+        margin-left:450px;
+        width:450px;
+        margin-top:30px;
+}
+.orgitdownEditor {
+	font:12px 'Courier New', Courier, monospace;
+	padding:5px 5px 5px 35px;
+	border:3px solid #3C769D;
+	width:643px;
+	height:320px;
+	background:#FFF url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor.png) no-repeat;
+	clear:both;
+	line-height:18px;
+	overflow:auto;
+}
+.orgitdownPreviewFrame	{
+	overflow:auto;
+	background-color:#FFFFFF;
+	border:1px solid #3C769D;
+	width:99.9%;
+	height:300px;
+	margin:5px 0;
+}
+.orgitdownFooter {
+	width:100%;
+	cursor:n-resize;
+}
+.orgitdownResizeHandle {
+	overflow:hidden;
+	width:22px; height:5px;
+	margin-left:auto;
+	margin-right:auto;
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/handle.png);
+	cursor:n-resize;
+}
+/***************************************************************************************/
+/* first row of buttons */
+.orgitdownHeader ul li	{
+	list-style:none;
+	float:left;
+	position:relative;
+}
+.orgitdownHeader ul li ul{
+	display:none;
+}
+.orgitdownHeader ul li:hover > ul{
+	display:block;
+}
+.orgitdownHeader ul .orgitdownDropMenu {
+	background:transparent url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/menu.png) no-repeat 115% 50%;
+	margin-right:5px;
+}
+.orgitdownHeader ul .orgitdownDropMenu li {
+	margin-right:0px;
+}
+.orgitdownHeader ul .orgitdownSeparator {
+	margin:0 10px;
+	width:1px;
+	height:16px;
+	overflow:hidden;
+	background-color:#CCC;
+}
+.orgitdownHeader ul ul .orgitdownSeparator {
+	width:auto; height:1px;
+	margin:0px;
+}
+/* next rows of buttons */
+.orgitdownHeader ul ul {
+	display:none;
+	position:absolute;
+	top:18px; left:0px;	
+	background:#F5F5F5;
+	border:1px solid #3C769D;
+	height:inherit;
+}
+.orgitdownHeader ul ul li {
+	float:none;
+	border-bottom:1px solid #3C769D;
+}
+.orgitdownHeader ul ul .orgitdownDropMenu {
+	background:#F5F5F5 url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/submenu.png) no-repeat 100% 50%;
+}
+/* next rows of buttons */
+.orgitdownHeader ul ul ul {
+	position:absolute;
+	top:-1px; left:150px;
+}
+.orgitdownHeader ul ul ul li {
+	float:none;
+}
+.orgitdownHeader ul a {
+	display:block;
+	width:16px; height:16px;
+	text-indent:-10000px;
+	background-repeat:no-repeat;
+	padding:3px;
+	margin:0px;
+}
+.orgitdownHeader ul ul a {
+	display:block;
+	padding-left:0px;
+	text-indent:0;
+	width:120px; 
+	padding:5px 5px 5px 25px;
+	background-position:2px 50%;
+}
+.orgitdownHeader ul ul a:hover  {
+	color:#FFF;
+	background-color:#3C769D;
+}
+/***************************************************************************************/
+.html .orgitdownEditor {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor-html.png);
+}
+.markdown .orgitdownEditor {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor-markdown.png);
+}
+.textile .orgitdownEditor {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor-textile.png);
+}
+.bbcode .orgitdownEditor {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor-bbcode.png);
+}
+.wiki .orgitdownEditor,
+.dotclear .orgitdownEditor {
+	background-image:url(/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor-wiki.png);
+}
+
+		</style>
+		<!-- the header lines from grappelli -->
+		{% block blockbots %}
+		<meta name="robots" content="NONE,NOARCHIVE" />
+		{% endblock %} <!-- STYLESHEETS -->
+		{% block stylesheets %}
+		<link href="{% admin_media_prefix %}css/base.css" rel="stylesheet" type="text/css" />
+		{% if LANGUAGE_BIDI %}
+		<link href="{% block stylesheet_rtl %}{% admin_media_prefix %}css/rtl.css{% endblock %}" rel="stylesheet" type="text/css" />
+		{% endif %}
+		<link href="{% admin_media_prefix %}jquery/ui/css/custom-theme/jquery-ui-1.8.custom.css" rel="stylesheet" type="text/css" media="screen" title="no title" charset="utf-8" />
+		<link href="{% admin_media_prefix %}css/jquery-ui-grappelli-extensions.css" rel="stylesheet" type="text/css" />
+		{% endblock %} <!-- EXTRASTYLES -->
+		{% block extrastyle %}{% endblock %} <!-- JAVASCRIPTS -->
+		{% block javascripts %}
+		<script type="text/javascript">
+			// GLOBALS
+			var grappelli = {},
+			// TODO: klemens: drop ADMIN_URL
+			ADMIN_URL = "{% url admin:index %}",
+			MODEL_URL_ARRAY = {% get_content_types %}, DATE_FORMAT = "{% get_date_format %}", TIME_FORMAT = "{% get_time_format %}", DATETIME_FORMAT = "{% get_datetime_format %}";
+		</script>
+		<!-- jQuery, jQuery-UI -->
+		<script src="{% admin_media_prefix %}jquery/jquery-1.6.2.min.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}jquery/ui/js/jquery-ui-1.8.15.custom.min.js" type="text/javascript"></script>
+		<!-- Grappelli Main JS -->
+		<script src="{% admin_media_prefix %}js/grappelli/grappelli.js" type="text/javascript"></script>
+		<!-- Grappelli jQuery Plugins, Widgets -->
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_collapsible.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_collapsible_group.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_timepicker.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_related_fk.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_related_m2m.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_related_generic.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_autocomplete_fk.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_autocomplete_m2m.js" type="text/javascript"></script>
+		<script src="{% admin_media_prefix %}js/grappelli/jquery.grp_autocomplete_generic.js" type="text/javascript"></script>
+
+    <script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
+
+<!-- orgitdowm css,js -->
+            <script type="text/javascript" src="http://code.jquery.com/jquery-1.7.2.min.js"></script>
+	    <script type="text/javascript" src="{{STATIC_URL}}gstudio/js/orgitdown/orgitdown/sets/org/set.js"></script>
+
+	    <script type="text/javascript" src="{{STATIC_URL}}gstudio/js/orgitdown/orgitdown/jquery.orgitdown.js"></script>
+
+	    <script type="text/javascript" src="{{STATIC_URL}}gstudio/js/orgitdown/orgitdown/sets/savedata.js"></script>
+
+		<!-- EXTRAHEAD -->
+		{% block extrahead %}{% endblock %}
+
+		{% endblock %} <!-- the header lines from gstudio -->
+		<meta http-equiv="content-type" content="text/html; charset=utf-8" />
+		<meta http-equiv="cache-control" content="public" />
+		<meta name="robots" content="follow, all" />
+		<meta name="language" content="{{ LANGUAGE_CODE }}" />
+		<meta name="description" content="{% block meta-description %}Demonstration of the Gstudio Blog application.{% endblock %}" />
+		<meta name="keywords" content="{% block meta-keywords %}django, blog, gstudio, {{ nodetype_tags|join:", "}}{% endblock %}" />
+		<meta name="author" content="gnowgi" />
+		{% block meta %}{% endblock %}
+		<link rel="pingback" href="/xmlrpc/" />
+		<link rel="shortcut icon" href="{{ STATIC_URL }}gstudio/img/favicon.ico" />
+		<link rel="home" href="{% url gstudio_nodetype_archive_index %}" />
+
+		<link rel="stylesheet" type="text/css" media="screen, projection" href="{{ STATIC_URL }}gstudio/css/screen.css" />
+
+		<link rel="stylesheet" type="text/css" media="print" href="{{ STATIC_URL }}gstudio/css/print.css" />
+		<!--[if lt IE 8]>
+		<link rel="stylesheet" type="text/css" media="screen, projection" href="{{ STATIC_URL }}gstudio/css/ie.css" />
+		<![endif]-->
+		{% block link %}{% endblock %}
+		{% block script %}{% endblock %} <title>Gnowledge Studio - {% block title %}{% endblock %}</title>
+	</head>
+	<body id="gstudio">
+		
+				<!--
+				<div id="relation_type" class="ui-buttonset">
+				<span>Relation type:</span>
+				<input checked="checked" value="follows" type="radio" id="follows" name="radio" class="ui-helper-hidden-accessible"><label for="follows" class="ui-button ui-widget ui-state-default ui-button-text-only ui-corner-left" aria-pressed="false" role="button" aria-disabled="false"><span class="ui-button-text">Followers</span></label>
+				<input value="mentions" type="radio" id="mentions" name="radio" class="ui-helper-hidden-accessible"><label for="mentions" aria-pressed="true" class="ui-button ui-widget ui-state-default ui-button-text-only ui-corner-right ui-state-active" role="button" aria-disabled="false"><span class="ui-button-text">Mentions</span></label>
+				<input value="hashtags" type="radio" id="hashtags" name="radio"/><label for="hashtags">Shared interests</label>
+				</div>
+				-->
+				
+
+
+	
+		
+		
+			{% include "gstudio/_header.html" %}
+			<div id="breadcrumbs" class="">
+				/ {% block breadcrumbs %}{% endblock %}
+			</div>
+			<div id="body" class="span-24 last">
+				<div id="content" class="hfeed span-16 border">
+					{% block content %} <h3>The content block need to be overrided!</h3>
+					{% endblock %}
+				</div>
+
+				<textarea id="gnoweditor" style="visibility:hidden;">
+				</textarea>
+				
+				
+				<div id="graphcss">
+				<div id="chart">
+					
+				</div>
+				<script type="text/javascript" src="/static/gstudio/js/jquery.min.js" ></script>
+				<script type="text/javascript" src="/static/gstudio/js/jquery-ui.js" ></script>
+				<script type="text/javascript" src="/static/gstudio/js/underscore.js" ></script>
+				<script type="text/javascript" src="/static/gstudio/js/d3.js"></script>
+				<script type="text/javascript" src="/static/gstudio/js/d3.layout.js"></script>
+				<script type="text/javascript" src="/static/gstudio/js/d3.geom.js"></script>
+				<!-- <script type="text/javascript" src="/static/gstudio/js/force.js"></script>
+
+				Javascript for Object type force graph
+				-->
+				
+<script type="text/javascript" >
+
+function init(a,b)
+{
+
+ 
+  nodes_by_id = _.reduce(a, function(acc, n) {
+        acc[n._id] = n;
+        return acc;
+      }, {});
+     
+     
+	all_edges=new Array();  
+
+	//this contains all the links between the nodes
+  all_edges =_(b).chain().map(function(e) {
+        e.source = nodes_by_id[e.from];
+        e.target = nodes_by_id[e.to];
+	//`e.type = nodes_by_id[e.type]
+        return e;
+      }).filter(function(e){
+        return nodes_by_id[e.from] && nodes_by_id[e.to]&& e.type!="title" && e.type!="content" 
+      }).value();
+
+ 
+}
+
+$(function fgraph() {
+neighbour_node= new Array();
+clicked_node=new Array();
+prev_node=new Array();
+neighbour_node= neighbour_node.concat({{object.id}});		  
+
+$.getJSON('/nodetypes/graphs/graph_json/' + {{object.id}}, function (json1) { 
+										metadata=json1.node_metadata;
+  										relations=json1.relations;
+									
+										init(metadata,relations);
+										load({{object.id}}) });
+
+
+function load(key)
+{
+  
+			if (s > 0 ){
+			var a = 50 * s;
+			var w = 1000;
+	   		var p = 140 + "%";
+			var h = 650;
+   			var q = 3 * s + 75 + "%";
+			}else{
+			var w = 1000;
+	   		var p = 140 + "%";
+			var h = 650;
+   			var q = 110 + "%";			
+			}
+        fill = d3.scale.category20();
+ 
+>>>>>>> 184877f00ded7fe61420111de4ec8d48d3bee634
   var vis = d3.select("#chart")
         .append("svg:svg")
 	.attr("id", "amazingViz") 
diff --git a/gstudio/templatetags/gstudio_tags.py b/gstudio/templatetags/gstudio_tags.py
index 47dbbff..66b5f17 100644
--- a/gstudio/templatetags/gstudio_tags.py
+++ b/gstudio/templatetags/gstudio_tags.py
@@ -23,7 +23,7 @@ from datetime import datetime
 
 from django.db.models import Q
 from django.db import connection
-from django.template import Node
+from django.template import Node as nd
 from django.template import Library
 from django.template import TemplateSyntaxError
 from django.contrib.comments.models import CommentFlag
@@ -46,6 +46,8 @@ from gstudio.comparison import pearson_score
 from gstudio.templatetags.zcalendar import GstudioCalendar
 from gstudio.templatetags.zbreadcrumbs import retrieve_breadcrumbs
 
+from gstudio.CNL import *
+
 register = Library()
 
 VECTORS = None
@@ -217,6 +219,7 @@ def get_calendar_nodetypes(context, year=None, month=None,
 def get_recent_comments(number=5, template='gstudio/tags/recent_comments.html'):
     """Return the most recent comments"""
     # Using map(smart_unicode... fix bug related to issue #8554
+    #Modified comments to include CNL
     nodetype_published_pks = map(smart_unicode,
                               Nodetype.published.values_list('id', flat=True))
     content_type = ContentType.objects.get_for_model(Nodetype)
@@ -225,12 +228,29 @@ def get_recent_comments(number=5, template='gstudio/tags/recent_comments.html'):
         Q(flags=None) | Q(flags__flag=CommentFlag.MODERATOR_APPROVAL),
         content_type=content_type, object_pk__in=nodetype_published_pks,
         is_public=True).order_by('-submit_date')[:number]
+ 
 
     return {'template': template,
             'comments': comments}
 
 
 @register.inclusion_tag('gstudio/tags/dummy.html')
+def get_recent_oldcomments(number=5, template='gstudio/tags/recent_comments.html'):
+    """Return the most recent comments"""
+    # Using map(smart_unicode... fix bug related to issue #8554
+    nodetype_published_pks = map(smart_unicode,
+                              Nodetype.published.values_list('id', flat=True))
+    content_type = ContentType.objects.get_for_model(Nodetype)
+
+    comments = get_comment_model().objects.filter(
+        Q(flags=None) | Q(flags__flag=CommentFlag.MODERATOR_APPROVAL),
+        content_type=content_type, object_pk__in=nodetype_published_pks,
+        is_public=True).order_by('-submit_date')[:number]
+
+    return {'template': template,
+            'comments': comments}
+
+@register.inclusion_tag('gstudio/tags/dummy.html')
 def get_recent_linkbacks(number=5,
                          template='gstudio/tags/recent_linkbacks.html'):
     """Return the most recent linkbacks"""
@@ -320,15 +340,19 @@ def get_type(name):
     return get_node(name)
 
 
-class TagsNode(Node):
+class TagsNode(nd):
     def __init__(self, context_var):
         self.context_var = context_var
-
     def render(self, context):
         context[self.context_var] = tags_published()
         return ''
-
-
+#define get_CNL function
+@register.assignment_tag
+def get_CNL(no, takes_context = True):
+       
+    l = get_CNL_list(no)
+    return l
+ 
 @register.tag
 def get_tags(parser, token):
     """{% get_tags as var %}"""
diff --git a/gstudio/update_lexicon.py b/gstudio/update_lexicon.py
new file mode 100644
index 0000000..8a4a359
--- /dev/null
+++ b/gstudio/update_lexicon.py
@@ -0,0 +1,100 @@
+from gstudio.lex import *
+
+def lex(self):
+	destination = open( "/home/user/gnowsys-studio/demo/aFile.pl", "a+"  )        
+        f = destination.read()
+        ##print "f---" ,f
+        b = []
+        c = []
+        r = []
+        source_r = []
+        """
+        strpos=f.find("one")
+        ##print strpos
+        """
+        
+        #Updates lexicon file with each Objecttype as noun singular and plural
+        for each in Objecttype.objects.all():
+             source=get_lex_OT(each)
+             for e_i in source:
+                        strpos=f.find(e_i)
+                        #print strpos
+                        if strpos == -1:
+                             #print "Going to write --", e_i
+                             destination.write(str(e_i) + '\n')
+                        else:
+                             pass
+             
+        #Updates lexicon file with Gbobject and author of each Nodetype and stores them as Proper noun
+        for each in Nodetype.objects.all():
+             for a in get_lex_author(each):
+                  b.append(a)
+        
+
+        for each in Gbobject.objects.all():
+            for a in get_lex_GB(each):
+                  b.append(a)
+
+        
+        #Compares each of the entries of author & Gbobject, to make a unique list
+        for each in b:
+            if each not in c:
+                    c.append(each)
+
+        for e_i in c:
+                 strpos=f.find(e_i)
+                 #print strpos
+                 if strpos == -1:
+                          #print "Going to write --", e_i
+                          destination.write(str(e_i) + '\n')
+                 else:
+                          pass
+        
+        #Updates lexicon file with each Relationtype as an intransitive adjective or transitive verb  
+        for each in Relationtype.objects.all():
+              for e_i in get_lex_RT(each):
+                    r.append(e_i)
+        ##print " r---(will contain all rts, may contain repetition of prepositions)"
+         
+        #Compares each of the entries to ensure preposition entries are unique        
+        for each_r in r:
+            if each_r not in source_r:
+                 source_r.append(each_r) 
+                 
+        ###print "source_r, should not contain any rep"    
+                           
+        for e_ir in source_r:
+                        strpos=f.find(e_ir)
+                        #print strpos
+                        if strpos == -1:
+                             ##print "Going to write the above statement",e_i
+                             destination.write(str(e_ir) + '\n')
+                        else:
+                             pass
+
+        #Updates lexicon file with each Metatype as noun singular and plural
+        for each in Metatype.objects.all():
+              source_m=get_lex_MT(each)
+              for e_im in source_m:
+                        strpos=f.find(e_im)
+                        #print strpos
+                        if strpos == -1:
+                             ##print "Going to write the above statement",e_i
+                             destination.write(str(e_im) + '\n')
+                        else:
+                             pass
+         
+        #Updates lexicon file with each Attributetype as noun singular and plural
+        for each in Attributetype.objects.all():
+              source_a=get_lex_AT(each)
+              for e_ia in source_a:
+                        strpos=f.find(e_ia)
+                        #print strpos
+                        if strpos == -1:
+                             ##print "Going to write the above statement",e_i
+                             destination.write(str(e_ia) + '\n')
+                        else:
+                             pass
+         
+        
+        destination.close()          
diff --git a/gstudio/views/ajaxviews.py b/gstudio/views/ajaxviews.py
index c35ca83..e763020 100644
--- a/gstudio/views/ajaxviews.py
+++ b/gstudio/views/ajaxviews.py
@@ -352,7 +352,6 @@ def AjaxAddContentOrg(request):
 
 def AjaxCreateFile(request):
     iden = request.GET["id"]
-    # newtitle = request.GET["title"]
     orgcontent = request.GET["content_org"]
     myfile = open('/tmp/file.org', 'w')
     myfile.write(orgcontent)
@@ -361,21 +360,14 @@ def AjaxCreateFile(request):
     myfile.readline()
     myfile = open('/tmp/file.org', 'a')
     myfile.write("\n#+OPTIONS: timestamp:nil author:nil creator:nil  H:3 num:nil toc:nil @:t ::t |:t ^:t -:t f:t *:t <:t")
+    myfile.write("\n#+TITLE: ")
     myfile = open('/tmp/file.org', 'r')
-    
-#   os.remove("/tmp/file.org")
     return HttpResponse("test sucess")
 
-# def AjaxSetOption(request):
-#     myfile = open('/tmp/file.org', 'a')
-#     myfile.write("\n#+OPTIONS: timestamp:nil author:nil creator:nil  H:3 num:t toc:nil @:t ::t |:t ^:t -:t f:t *:t <:t")
-#     myfile = open('/tmp/file.org', 'r')
-#     return HttpResponse("set option")
-
 def AjaxCreateHtml(request):
     stdout = os.popen(PYSCRIPT_URL_GSTUDIO)
     output = stdout.read()
-    return HttpResponse(output)
+    return HttpResponse("sucess")
 
 def AjaxAddContent(request):
     iden = request.GET["id"]