From 784e62d0c38fbf0cc4b5e67e26354b0e0a261fc2 Mon Sep 17 00:00:00 2001 From: Dhiru Date: Tue, 10 Jul 2012 16:43:46 +0530 Subject: changes done in gstudio_tags.py --- gstudio/templatetags/gstudio_tags.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'gstudio') diff --git a/gstudio/templatetags/gstudio_tags.py b/gstudio/templatetags/gstudio_tags.py index 47dbbff..5c3c8a8 100644 --- a/gstudio/templatetags/gstudio_tags.py +++ b/gstudio/templatetags/gstudio_tags.py @@ -217,6 +217,17 @@ 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 + + comments = get_comment_model().objects.filter(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) @@ -229,7 +240,6 @@ def get_recent_comments(number=5, template='gstudio/tags/recent_comments.html'): return {'template': template, 'comments': comments} - @register.inclusion_tag('gstudio/tags/dummy.html') def get_recent_linkbacks(number=5, template='gstudio/tags/recent_linkbacks.html'): -- cgit v1.1 From 06f170eae6261d894b9651e549d42abdfcecf46c Mon Sep 17 00:00:00 2001 From: supriya Date: Thu, 12 Jul 2012 12:03:28 +0530 Subject: orgitdown with save functionality --- gstudio/models.py | 2 +- .../js/orgitdown/orgitdown/jquery.orgitdown.js | 29 ++++++++++++++++++++- .../gstudio/js/orgitdown/orgitdown/sets/org/set.js | 3 ++- .../js/orgitdown/orgitdown/sets/savedata.js | 12 ++++----- .../orgitdown/skins/orgitdown/images/bg-editor.png | Bin 3013 -> 0 bytes gstudio/templates/gstudio/skeleton.html | 18 +++++++------ gstudio/views/ajaxviews.py | 3 ++- 7 files changed, 48 insertions(+), 19 deletions(-) delete mode 100644 gstudio/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor.png (limited to 'gstudio') 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/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 Binary files a/gstudio/static/gstudio/js/orgitdown/orgitdown/skins/orgitdown/images/bg-editor.png and /dev/null differ diff --git a/gstudio/templates/gstudio/skeleton.html b/gstudio/templates/gstudio/skeleton.html index 7c1c698..8716969 100644 --- a/gstudio/templates/gstudio/skeleton.html +++ b/gstudio/templates/gstudio/skeleton.html @@ -51,32 +51,34 @@ display: block; position: absolute; } - .orgitdown .orgitdownButton1 a { - background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/bold.png); + 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/italic.png); + 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 .orgitdownButton4 a { +.orgitdown .orgitdownButton5 a { background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/list-bullet.png); } -.orgitdown .orgitdownButton5 a { +.orgitdown .orgitdownButton6 a { background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/list-numeric.png); } -.orgitdown .orgitdownButton6 a { +.orgitdown .orgitdownButton7 a { background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/picture.png); } -.orgitdown .orgitdownButton7 a { +.orgitdown .orgitdownButton8 a { background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/link.png); } -.orgitdown .orgitdownButton8 a { +.orgitdown .orgitdownButton9 a { background-image:url(/static/gstudio/js/orgitdown/orgitdown/sets/default/images/clean.png); } .orgitdown .preview a { diff --git a/gstudio/views/ajaxviews.py b/gstudio/views/ajaxviews.py index c35ca83..45064a1 100644 --- a/gstudio/views/ajaxviews.py +++ b/gstudio/views/ajaxviews.py @@ -361,6 +361,7 @@ 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:nil ") myfile = open('/tmp/file.org', 'r') # os.remove("/tmp/file.org") @@ -375,7 +376,7 @@ def AjaxCreateFile(request): 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"] -- cgit v1.1 From 2d412122742571b17a4d9a3bc79f20a199c223e6 Mon Sep 17 00:00:00 2001 From: anujag Date: Fri, 13 Jul 2012 13:00:54 +0530 Subject: CNL added --- gstudio/CNL.py | 825 +++++++++++++++++++++ gstudio/createhtml.py | 19 + gstudio/lex.py | 147 ++++ .../orgitdown/orgitdown/sets/org/images/save.jpeg | Bin 0 -> 416 bytes gstudio/templates/gstudio/nodetype_detail.html | 216 +++--- gstudio/templatetags/gstudio_tags.py | 28 +- gstudio/update_lexicon.py | 100 +++ gstudio/views/ajaxviews.py | 11 +- 8 files changed, 1224 insertions(+), 122 deletions(-) create mode 100644 gstudio/CNL.py create mode 100755 gstudio/createhtml.py create mode 100644 gstudio/lex.py create mode 100644 gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/images/save.jpeg create mode 100644 gstudio/update_lexicon.py (limited to 'gstudio') 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/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 Binary files /dev/null and b/gstudio/static/gstudio/js/orgitdown/orgitdown/sets/org/images/save.jpeg differ 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 @@ Name: {{ object.title }}
+ + CNL:
+ {% get_CNL object as cnlobj %} + {% for obj in cnlobj %} + {{obj}}
+ {% endfor %} - {% if object.get_rendered_nbh.plural %} - Plural Name: - {{object.get_rendered_nbh.plural}}
- {% endif %} - {% if object.get_rendered_nbh.altnames %} - Alternate names: - {{object.get_rendered_nbh.altnames}}
- {% endif %} - {% if object.get_rendered_nbh.type_of %} - Type of: - {% for typekey,typevalue in object.get_rendered_nbh.type_of.items %} - {{typekey}}; - {% endfor %}
- {% endif %} + + + + + + + + + + + + + + - - {% if object.get_rendered_nbh.member_of_metatypes %} + + - Member of Metatypes: - {% for mkey,mvalue in object.get_rendered_nbh.member_of_metatypes.items %} - {{mkey}}; - {% endfor %}
- {% endif %} + + + + + - - {% if object.get_rendered_nbh.contains_subtypes %} - Contains SubTypes: - {% for stkey,stvalue in object.get_rendered_nbh.contains_subtypes.items %} - {{stkey}}; - {% endfor %}
- {% endif %} + + + + + + + - - {% if object.get_rendered_nbh.contains_members %} + + - Contains Members: - {% for mkey,mvalue in object.get_rendered_nbh.contains_members.items %} - {{mkey}}; - {% endfor %}
- {% endif %} + + + + + - - {% if object.get_rendered_nbh.authors %} + + - Authors: + - {% endif %} + - {% for author in object.authors.all %} - - - {% if not forloop.last %}, {% endif %} - {% endfor %}
+ + + + + + - + - {% if object.get_rendered_nbh.priornodes %} + - Prior nodes: - {% for mkey,mvalue in object.get_rendered_nbh.priornodes.items %} - {{mkey}}; - {% endfor %}
- {% endif %} - - {% if object.get_rendered_nbh.posteriornodes %} + + + + + + + - Posterior nodes: - {% for mkey,mvalue in object.get_rendered_nbh.posteriornodes.items %} - {{mkey}}; - {% endfor %}
- {% endif %} - - {% if object.get_rendered_nbh.relations %} + + + + + + + - {% for relkey,relvalue in object.get_rendered_nbh.relations.items %} - {{relkey}}: - {% for relk, relv in relvalue.items %} - {{relk}}; - {% endfor %}
- {% endfor %} - {% endif %} - - {% if object.get_rendered_nbh.attributes %} + + + + + + + + + - {% for atkey,atvalue in object.get_rendered_nbh.attributes.items %} - {% if atvalue %} - {{atkey}}: - {% for atr in atvalue %} + + + + - {% for urlkey,urlvalue in object.get_edit_url_for_ats.items %} + - {% ifequal atr urlvalue %} - {{atr}}[edit] ; - {% endifequal %} - {% endfor %} - {% endfor %}
- {% endif %} - {% endfor %} - {% endif %} - - {% if object.get_rendered_nbh.leftroles %} + + + + + + + + + + - Left roles: + - {% for lrkey,lrvalue in object.get_rendered_nbh.leftroles.items %} - {{lrkey}}; - {% endfor %}
- {% endif %} - - {% if object.get_rendered_nbh.rightroles %} + + + + + + - Right roles: + - {% for rrkey,rrvalue in object.get_rendered_nbh.rightroles.items %} - {{rrkey}}; - {% endfor %}
- {% endif %} - + + + + + - {% if object.get_rendered_nbh.ats %} + - Subjecttype of: + - {% for atkey,atvalue in object.get_rendered_nbh.ats.items %} - {{atkey}}; - {% endfor %}
- {% endif %} + + + + - + {% if object.content %} Content: diff --git a/gstudio/templatetags/gstudio_tags.py b/gstudio/templatetags/gstudio_tags.py index 5c3c8a8..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,8 +219,16 @@ 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 - - comments = get_comment_model().objects.filter(is_public=True).order_by('-submit_date')[:number] + #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) + + 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} @@ -330,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 45064a1..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,18 +360,10 @@ 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:nil ") + 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() -- cgit v1.1