# Copyright (c) 2011, 2012 Free Software Foundation # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . # This project incorporates work covered by the following copyright and permission notice: # Copyright (c) 2009, Julien Fache # All rights reserved. # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # * Neither the name of the author nor the names of other # contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED # OF THE POSSIBILITY OF SUCH DAMAGE. # Copyright (c) 2011, 2012 Free Software Foundation # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . """Super models of Gstudio """ import warnings from datetime import datetime from django.db import models from django.db.models import Q from django.utils.html import strip_tags from django.utils.html import linebreaks from django.contrib.auth.models import User from django.contrib.sites.models import Site from django.db.models.signals import post_save from django.utils.importlib import import_module from django.contrib import comments from django.contrib.comments.models import CommentFlag from django.contrib.comments.moderation import moderator from django.utils.translation import ugettext_lazy as _ from django.contrib.markup.templatetags.markup import markdown from django.contrib.markup.templatetags.markup import textile from django.contrib.markup.templatetags.markup import restructuredtext import mptt from djangoratings.fields import RatingField from tagging.fields import TagField from gstudio.settings import UPLOAD_TO from gstudio.settings import MARKUP_LANGUAGE from gstudio.settings import NODETYPE_TEMPLATES from gstudio.settings import NODETYPE_BASE_MODEL from gstudio.settings import MARKDOWN_EXTENSIONS from gstudio.settings import AUTO_CLOSE_COMMENTS_AFTER from gstudio.managers import nodetypes_published from gstudio.managers import NodetypePublishedManager from gstudio.managers import NodePublishedManager from gstudio.managers import AuthorPublishedManager from gstudio.managers import DRAFT, HIDDEN, PUBLISHED from gstudio.moderator import NodetypeCommentModerator from gstudio.url_shortener import get_url_shortener from gstudio.signals import ping_directories_handler from gstudio.signals import ping_external_urls_handler import json import reversion from reversion.models import Version from django.core import serializers from reversion.models import * from reversion.helpers import * NODETYPE_CHOICES = ( ('ND', 'Nodes'), ( 'OB' ,'Objects'), ('ED', 'Edges'), ('NT', 'Node types'), ('ET', 'Edge types'), ('OT', 'Object types'), ('RT', 'Relation types'), ('MT', 'Metatypes'), ('AT', 'Attribute types'), ('RN', 'Relations'), ('AS', 'Attributes'), ('ST', 'System type'), ('SY', 'System'), ('NS', 'Node specification'), ('AS', 'Attribute specification'), ('RS', 'Relation specification'), ('IN', 'Intersection'), ('CP', 'Complement'), ('UN', 'Union'), ) DEPTYPE_CHOICES = ( ('0', 'Concept-Concept'), ('1', 'Activity-Activity'), ('2', 'Question-Question'), ('3', 'Concept-Activity'), ('4', 'Activity-Concept'), ('5', 'Question-Concept'), ('6', 'Concept-Question'), ('7', 'Question-Activity'), ('8', 'Activity-Question'), ) FIELD_TYPE_CHOICES = ( ('1', 'CharField'), ('2', 'TextField'), ('3', 'IntegerField'), ('4', 'CommaSeparatedIntegerField'), ('5', 'BigIntegerField'), ('6', 'PositiveIntegerField'), ('7', 'DecimalField'), ('8', 'FloatField'), ('9', 'BooleanField'), ('10', 'NullBooleanField'), ('11', 'DateField'), ('12', 'DateTimeField'), ('13', 'TimeField'), ('14', 'EmailField'), ('15', 'FileField'), ('16', 'FilePathField'), ('17', 'ImageField'), ('18', 'URLField'), ('19', 'IPAddressField'), ) STATUS_CHOICES = ((DRAFT, _('draft')), (HIDDEN, _('hidden')), (PUBLISHED, _('published'))) counter = 1 attr_counter = -1 class Author(User): """Proxy Model around User""" objects = models.Manager() published = AuthorPublishedManager() def nodetypes_published(self): """Return only the nodetypes published""" return nodetypes_published(self.nodetypes) @property def title(self): return self.username @models.permalink def get_absolute_url(self): """Return author's URL""" #return "/authors/%s/" %(self.username) return ('gstudio_author_detail', (self.username,)) class Meta: """Author's Meta""" proxy = True class NID(models.Model): """the set of all nodes. provides node ID (NID) to all nodes in the network, including edges. Edges are also first class citizens in the gnowledge base. """ title = models.CharField(_('title'), help_text=_('give a name to the node'), max_length=255) last_update = models.DateTimeField(_('last update'), default=datetime.now) creation_date = models.DateTimeField(_('creation date'), default=datetime.now) slug = models.SlugField(help_text=_('used for publication'), unique_for_date='creation_date', max_length=255) @property def get_revisioncount(self): """ Returns Number of Version """ i=0 ver=Version.objects.get_for_object(self) for each in ver: i=i+1 return i @property def get_version_list(self): """ Returns Version list """ ver=Version.objects.get_for_object(self) return ver @property def get_ssid(self): """ return snapshot ids (revision id). returns a list. """ slist=[] vlist=self.get_version_list for each in vlist: slist.append(each.id) return slist def version_info(self,ssid): version_object=Version.objects.get(id=ssid) return version_object.field_dict def get_version_nbh(self,ssid): """ Returns Version nbh """ ver_dict=self.version_info(ssid) ver_nbh_list=[] ver_nbh_dict={} for item in self.get_nbh.keys(): if item in ver_dict.keys(): ver_nbh_list.append(item) for each in ver_nbh_list: ver_nbh_dict[each]=ver_dict[each] return ver_nbh_dict def get_serialized_dict(self): """ return the fields in a serialized form of the current object using the __dict__ function. """ return self.__dict__ @models.permalink def get_absolute_url(self): """Return nodetype's URL""" return ('gstudio_nodetype_detail', (), { 'year': self.creation_date.strftime('%Y'), 'month': self.creation_date.strftime('%m'), 'day': self.creation_date.strftime('%d'), 'slug': self.slug}) @property def ref(self): """ Returns the object reference the id belongs to. """ try: """ ALGO: get object id, go to version model, return for the given id. """ # Retrieving only the relevant tupleset for the versioned objects vrs = Version.objects.filter(type=1 , object_id=self.id) # Returned value is a list, so splice it. vrs = vrs[0] except: return None return vrs.object @property def get_edit_url(self): return "/admin/" + self._meta.app_label + "/" + self._meta.module_name + "/" + str(self.id) def get_serialized_data(self): """ return the fields in a serialized form of the current object. get object id, go to version model, return serialized_data for the given id """ from reversion.models import Version version = Version.objects.get(id=self.id) return version.serialized_data def get_Version_graph_json(self,ssid): # # predicate_id={"plural":"a1","altnames":"a2","contains_members":"a3","contains_subtypes":"a4","prior_nodes":"a5", "posterior_nodes":"a6"} # slist=self.get_ssid ver_dict=self.version_info(ssid) g_json = {} g_json["node_metadata"]= [] predicate_id = {} counter = 1 for key in ver_dict.keys(): val = "a" + str(counter) predicate_id[key] = val counter = counter + 1 #print predicate_id attr_counter = -1 this_node = {"_id":str(ver_dict['id']),"title":ver_dict['title'],"screen_name":ver_dict['title'], "url":self.get_absolute_url()} g_json["node_metadata"].append(this_node) for key in predicate_id.keys(): if ver_dict[key]: try: g_json[str(key)]=[] g_json["node_metadata"].append({"_id":str(predicate_id[key]),"screen_name":key}) g_json[str(key)].append({"from":self.id , "to":predicate_id[key],"value":1, "level":1 }) if not isinstance(ver_dict[key],basestring): for item in ver_dict[key]: # user g_json["node_metadata"].append({"_id":str(item.id),"screen_name":item.title, "title":item.title, "url":item.get_absolute_url()}) g_json[str(key)].append({"from":predicate_id[key] , "to":item.id ,"value":1 }) else: #value={nbh["plural"]:"a4",nbh["altnames"]:"a5"} #this_node[str(key)]=nbh[key] key, nbh[key] #for item in value.keys(): g_json["node_metadata"].append({"_id":attr_counter,"screen_name":ver_dict[key]}) g_json[str(key)].append({"from":predicate_id[key] , "to":attr_counter ,"value":1, "level":2 }) attr_counter-=1 except: pass # print g_json return json.dumps(g_json) def __unicode__(self): return self.title class Meta: """NID's Meta""" class Node(NID): """ Super class """ altnames = TagField(_('alternate names'), help_text=_('alternate names if any'), blank=True, null=True) plural = models.CharField(_('plural name'), help_text=_('plural form of the node name if any'), max_length=255, blank=True, null=True) rating = RatingField(range=5, can_change_vote = True, help_text=_('your rating'), blank=True, null=True) status = models.IntegerField(choices=STATUS_CHOICES, default=PUBLISHED) start_publication = models.DateTimeField(_('start publication'), help_text=_('date start publish'), default=datetime.now) end_publication = models.DateTimeField(_('end publication'), help_text=_('date end publish'), default=datetime(2042, 3, 15)) sites = models.ManyToManyField(Site, verbose_name=_('sites publication'), related_name='nodetypes') nbhood = models.TextField(help_text="The serialized nbh of this version of the Node.") published = NodePublishedManager() def __unicode__(self): return self.title class Meta: abstract=False @reversion.create_revision() def save(self, *args, **kwargs): # self.nbhood=self.get_nbh super(Node, self).save(*args, **kwargs) # Call the "real" save() method. class Edge(NID): def __unicode__(self): return self.title class Meta: abstract=False @reversion.create_revision() # Save for edge def save(self, *args, **kwargs): super(Edge, self).save(*args, **kwargs) # Call the "real" save() method. class Metatype(Node): """ Metatype object for Nodetype """ description = models.TextField(_('description'), blank=True, null=True) parent = models.ForeignKey('self', null=True, blank=True, verbose_name=_('parent metatype'), related_name='children') def nodetypes_published(self): """ Return only the published nodetypes """ return nodetypes_published(self.member_types) @property def get_nbh(self): """ Returns the neighbourhood of the metatype """ nbh = {} nbh['title'] = self.title nbh['altnames'] = self.altnames nbh['plural'] = self.plural if self.parent: nbh['typeof'] = self.parent # generate ids and names of children/members nbh['contains_subtypes'] = self.children.get_query_set() nbh['contains_members'] = self.nodetypes.all() nbh['left_subjecttype_of'] = Relationtype.objects.filter(left_subjecttype=self.id) nbh['right_subjecttype_of'] = Relationtype.objects.filter(right_subjecttype=self.id) nbh['attributetypes'] = Attributetype.objects.filter(subjecttype=self.id) return nbh @property def get_possible_attributetypes(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the AT's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # recursive thru parent field and append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. attrtypes = [] for each in ancestor_list: # retrieve all the AT's from each ancestor attrtypes.extend(Attributetype.objects.filter(subjecttype=each.id)) return attrtypes @property def get_possible_rels(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the R's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. rels = {} rt_set = Relation.objects.all() right_subset = [] left_subset = [] for each in ancestor_list: # retrieve all the RT's from each ancestor right_subset.extend(rt_set.filter(subject1=each.id)) left_subset.extend(rt_set.filter(subject2=each.id)) rels['possible_leftroles'] = left_subset rels['possible_rightroles'] = right_subset return rels @property def get_possible_attributes(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the RT's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # recursive thru parent field and append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. attrs = [] for each in ancestor_list: # retrieve all the AT's from each ancestor attrs.extend(Attribute.objects.filter(subject=each.id)) return attrs @property def get_rendered_nbh(self): """ Returns the neighbourhood of the metatype """ nbh = {} nbh['title'] = self.title nbh['altnames'] = self.altnames nbh['plural'] = self.plural if self.parent: nbh['typeof'] = self.parent # generate ids and names of children nbh['contains_subtypes'] = self.children.get_query_set() contains_members_list = [] for each in self.nodetypes.all(): contains_members_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['contains_members'] = contains_members_list nbh['left_subjecttype_of'] = Relationtype.objects.filter(left_subjecttype=self.id) nbh['right_subjecttype_of'] = Relationtype.objects.filter(right_subjecttype=self.id) nbh['attributetypes'] = Attributetype.objects.filter(subjecttype=self.id) return nbh @property def tree_path(self): """Return metatype's tree path, by its ancestors""" if self.parent: return '%s/%s' % (self.parent.tree_path, self.slug) return self.slug def __unicode__(self): return self.title @property def composed_sentence(self): "composes the relation as a sentence in triple format." if self.parent: return '%s is a kind of %s' % (self.title, self.parent.tree_path) return '%s is a root node' % (self.slug) @models.permalink def get_absolute_url(self): """Return metatype's URL""" return ('gstudio_metatype_detail', (self.tree_path,)) class Meta: """Metatype's Meta""" ordering = ['title'] verbose_name = _('metatype') verbose_name_plural = _('metatypes') # Save for metatype @reversion.create_revision() def save(self, *args, **kwargs): super(Metatype, self).save(*args, **kwargs) # Call the "real" save() method. self.nbhood=self.get_nbh with reversion.create_revision(): super(Metatype, self).save(*args, **kwargs) # Call the "real" save() method. class Nodetype(Node): """ Model design for publishing nodetypes. Other nodetypes inherit this class. """ STATUS_CHOICES = ((DRAFT, _('draft')), (HIDDEN, _('hidden')), (PUBLISHED, _('published'))) content = models.TextField(_('content'), null=True, blank=True) content_org = models.TextField(_('content'), null=True, blank=True) parent = models.ForeignKey('self', null=True, blank=True, verbose_name=_('is a kind of'), related_name='children') prior_nodes = models.ManyToManyField('self', null=True, blank=True, verbose_name=_('its meaning depends on '), related_name='posterior_nodes') posterior_nodes = models.ManyToManyField('self', null=True, blank=True, verbose_name=_('required for the meaning of '), related_name='prior_nodes') image = models.ImageField(_('image'), upload_to=UPLOAD_TO, blank=True, help_text=_('used for illustration')) excerpt = models.TextField(_('excerpt'), blank=True, help_text=_('optional element')) tags = TagField(_('tags')) metatypes = models.ManyToManyField(Metatype, verbose_name=_('member of metatypes'), related_name='member_types', blank=True, null=True) authors = models.ManyToManyField(User, verbose_name=_('authors'), related_name='nodetypes', blank=True, null=False) featured = models.BooleanField(_('featured'), default=False) comment_enabled = models.BooleanField(_('comment enabled'), default=True) pingback_enabled = models.BooleanField(_('linkback enabled'), default=True) login_required = models.BooleanField( _('login required'), default=False, help_text=_('only authenticated users can view the nodetype')) password = models.CharField( _('password'), max_length=50, blank=True, help_text=_('protect the nodetype with a password')) template = models.CharField( _('template'), max_length=250, default='gstudio/nodetype_detail.html', choices=[('gstudio/nodetype_detail.html', _('Default template'))] + \ NODETYPE_TEMPLATES, help_text=_('template used to display the nodetype')) rurl=models.URLField(_('rurl'),verify_exists=True,null=True, blank=True) objects = models.Manager() published = NodetypePublishedManager() def get_possible_reltypes(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the RT's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. reltypes = {} rt_set = Relationtype.objects.all() right_subset = [] left_subset = [] for each in ancestor_list: # retrieve all the RT's from each ancestor right_subset.extend(rt_set.filter(subjecttypeLeft=each.id)) left_subset.extend(rt_set.filter(subjecttypeRight=each.id)) reltypes['possible_leftroles'] = left_subset reltypes['possible_rightroles'] = right_subset return reltypes @property def get_possible_attributetypes(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the AT's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # recursive thru parent field and append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. attrtypes = [] for each in ancestor_list: # retrieve all the AT's from each ancestor attrtypes.extend(Attributetype.objects.filter(subjecttype=each.id)) return attrtypes @property def get_possible_rels(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the R's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. rels = {} rt_set = Relation.objects.all() right_subset = [] left_subset = [] for each in ancestor_list: # retrieve all the RT's from each ancestor right_subset.extend(rt_set.filter(subject1=each.id)) left_subset.extend(rt_set.filter(subject2=each.id)) rels['possible_leftroles'] = left_subset rels['possible_rightroles'] = right_subset return rels def get_graph_json(self): # predicate_id={"plural":"a1","altnames":"a2","contains_members":"a3","contains_subtypes":"a4","prior_nodes":"a5", "posterior_nodes":"a6"} g_json = {} g_json["node_metadata"]= [] g_json["relations"]=[] g_json["relset"]=[] global counter global attr_counter nbh = self.get_nbh predicate_id = {} for key in nbh.keys(): val = str(counter) + "a" predicate_id[key] = val counter = counter + 1 #print predicate_id this_node = {"_id":str(self.id),"title":self.title,"screen_name":self.title, "url":self.get_absolute_url(),"expanded":"true"} g_json["node_metadata"].append(this_node) g_json["relset"].append(self.id) for key in predicate_id.keys(): if nbh[key]: try: #g_json[str(key)]=[] #g_json["relations"].append(key) g_json["node_metadata"].append({"_id":str(predicate_id[key]),"screen_name":key}) #g_json[str(key)].append({"from":self.id , "to":predicate_id[key],"value":1, "level":1 }) g_json["relations"].append({"from":self.id ,"type":str(key),"value":1,"to":predicate_id[key] }) if not isinstance(nbh[key],basestring): for item in nbh[key]: if item.reftype!="Relation": # create nodes g_json["node_metadata"].append({"_id":str(item.id),"screen_name":item.title,"title":self.title, "url":item.get_absolute_url(),"expanded":"false"}) g_json["relset"].append(item.id) # g_json[str(key)].append({"from":predicate_id[key] , "to":item.id ,"value":1 }) #create links g_json["relations"].append({"from":predicate_id[key] ,"type":str(key), "value":1,"to":item.id }) else: if item.left_subject.id==self.id: item1=item.right_subject elif item.right_subject.id==self.id: item1=item.left_subject g_json["node_metadata"].append({"_id":str(item1.id),"screen_name":item1.title,"title":self.title, "url":item1.get_absolute_url(),"expanded":"false"}) # g_json[str(key)].append({"from":predicate_id[key] , "to":item.id ,"value":1 }) #create links g_json["relations"].append({"from":predicate_id[key] ,"type":str(key), "value":1,"to":item1.id }) else: #value={nbh["plural"]:"a4",nbh["altnames"]:"a5"} #this_node[str(key)]=nbh[key] key, nbh[key] #for item in value.keys(): g_json["node_metadata"].append({"_id":(str(attr_counter)+"a"),"screen_name":nbh[key]}) #g_json[str(key)].append({"from":predicate_id[key] , "to":attr_counter ,"value":1, "level":2 }) g_json["relations"].append({"from":predicate_id[key] ,"type":str(key) ,"value":1,"to":(str(attr_counter)+"a")}) attr_counter-=1 except: pass #print g_json return json.dumps(g_json) @property def get_possible_attributes(self): """ Gets the relations possible for this metatype 1. Recursively create a set of all the ancestors i.e. parent/subtypes of the MT. 2. Get all the RT's linked to each ancestor """ #Step 1. ancestor_list = [] this_parent = self.parent # recursive thru parent field and append while this_parent: ancestor_list.append(this_parent) this_parent = this_parent.parent #Step 2. attrs = [] for each in ancestor_list: # retrieve all the AT's from each ancestor attrs.extend(Attribute.objects.filter(subject=each.id)) return attrs @property def tree_path(self): """Return nodetype's tree path, by its ancestors""" if self.parent: return '%s/%s' % (self.parent.tree_path, self.slug) return self.slug @property def tree_path_sentence(self): """ Return the parent of the nodetype in a triple form """ if self.parent: return '%s is a kind of %s' % (self.title, self.parent.tree_path) return '%s is a root node' % (self.title) @property def html_content(self): """Return the content correctly formatted""" if MARKUP_LANGUAGE == 'markdown': return markdown(self.content, MARKDOWN_EXTENSIONS) elif MARKUP_LANGUAGE == 'textile': return textile(self.content) elif MARKUP_LANGUAGE == 'restructuredtext': return restructuredtext(self.content) elif not '

' in self.content: return linebreaks(self.content) return self.content @property def get_relations(self): """ Returns all the relations of the nodetype """ relations={} left_relations=Relation.objects.filter(left_subject=self.id) if left_relations: for each in left_relations: relation=each.relationtype.title predicate=each.right_subject relations[relation]=predicate right_relations=Relation.objects.filter(right_subject=self.id) if right_relations: for each in right_relations: relation=each.relationtype.inverse predicate=each.left_subject relations[relation]=predicate return relations @property def get_relations1(self): """ Returns all the relations of the nodetype """ relations={} reltype={} left_relations=Relation.objects.filter(left_subject=self.id) if left_relations: for each in left_relations: relation=each.relationtype.title predicate=each.right_subject predicate_values=[] if reltype: fl=0 for key,value in reltype.items(): if type(value) <> list: t=[] t.append(value) predicate_values=t else: predicate_values=value if each.relationtype.title==key: fl=1 predicate_values.append(predicate) reltype[key]=predicate_values if fl==0: predicate_values=predicate reltype[relation]=predicate_values else: predicate_values.append(predicate) reltype[relation]=predicate_values relations['lrelations']=reltype right_relations=Relation.objects.filter(right_subject=self.id) reltype={} if right_relations: for each in right_relations: relation=each.relationtype.inverse predicate=each.left_subject predicate_values=[] if reltype: fl=0 for key,value in reltype.items(): if type(value) <> list: t=[] t.append(value) prdicate_values=t else: predicate_values=value if each.relationtype.inverse==key: fl=1 predicate_values.append(predicate) reltype[key]=predicate_values if fl==0: predicate_values=predicate reltype[relation]=predicate_values else: predicate_values.append(predicate) reltype[relation]=predicate_values relations['rrelations']=reltype return relations @property def get_attributes(self): attributes_dict = {} all_attributes=self.subject_of.all() for attributes in all_attributes: val=[] atr_key=attributes.attributetype.title val.append(attributes.svalue) if attributes_dict: fl=0 itms=attributes_dict for key,value in itms.items(): if atr_key in key: fl=1 if type(value) <> list: t=[] t.append(value) val.extend(t) else: val.extend(value) attributes_dict[atr_key]=val return attributes_dict @property def get_rendered_nbh(self): """ Returns the neighbourhood of the nodetype """ nbh = {} nbh['title'] = self.title nbh['count_title'] = len(nbh['title']) nbh['altnames'] = self.altnames nbh['count_altnames'] = len(nbh['altnames']) nbh['plural'] = self.plural nbh['count_plural'] = len(nbh['plural']) #get all MTs member_of_dict = {} for each in self.metatypes.all(): member_of_dict[each.title]= each.get_absolute_url() nbh['member_of_metatypes']=member_of_dict nbh['count_member_of_metatypes'] = len(nbh['member_of_metatypes']) typeof={} parent=self.parent_id if parent: typeof[parent] = parent.get_absolute_url() nbh['type_of']=typeof nbh['count_type_of'] = len(nbh['type_of']) #get all subtypes subtypes={} for each in Nodetype.objects.filter(parent=self.id): subtypes[each.title] =each.get_absolute_url() nbh['contains_subtypes']=subtypes nbh['count_contains_subtypes'] = len(nbh['contains_subtypes']) # get all the objects inheriting this OT contains_members_dict = {} for each in self.member_objects.all(): contains_members_dict[each.title]= each.get_absolute_url() nbh['contains_members'] = contains_members_dict nbh['count_contains_members'] = len(nbh['contains_members']) #get prior nodes priornodes_dict = {} for each in self.prior_nodes.all(): priornodes_dict[each.title]= each.get_absolute_url() nbh['priornodes'] = priornodes_dict nbh['count_priornodes'] = len(nbh['priornodes']) #get posterior nodes posteriornodes_dict = {} for each in self.posterior_nodes.all(): posteriornodes_dict[each.title]= each.get_absolute_url() nbh['posteriornodes'] = posteriornodes_dict nbh['count_posteriornodes'] = len(nbh['posteriornodes']) #get authors author_dict = {} for each in self.authors.all(): author_dict['User'] = each.get_absolute_url() nbh['authors'] = author_dict #get siblings siblings={} for each in self.get_siblings(): siblings[each.title]=each.get_absolute_url() nbh['siblings']=siblings nbh['count_siblings'] = len(nbh['siblings']) #get Relations relns={} rellft={} relrgt={} if self.get_relations1: NTrelns=self.get_relations1 for key,value in NTrelns.items(): if key=="rrelations": relrgt={} for rgtkey,rgtvalue in value.items(): relnvalue={} if isinstance(rgtvalue,list): for items in rgtvalue: relnvalue[items]=items.get_absolute_url() else: relnvalue[rgtvalue]=rgtvalue.get_absolute_url() relrgt[rgtkey]=relnvalue else: rellft={} relns['left']=rellft for lftkey,lftvalue in value.items(): relnvalue={} if isinstance(lftvalue,list): for items in lftvalue: relnvalue[items]=items.get_absolute_url() else: relnvalue[lftvalue]=lftvalue.get_absolute_url() rellft[lftkey]=relnvalue nbh['relations']=relrgt nbh['relations'].update(rellft) nbh['count_relations'] = len(nbh['relations']) #get Attributes attributes =self.get_attributes nbh['attributes']=attributes nbh['count_attributes'] = len(nbh['attributes']) #get ATs attributetypes={} for each in self.subjecttype_of.all(): attributetypes[each.title]=each.get_absolute_url() nbh['ats']=attributetypes #get RTs as leftroles and rightroles leftroles = {} for each in self.left_subjecttype_of.all(): leftroles[each.title]=each.get_absolute_url() nbh['leftroles']=leftroles nbh['count_leftroles'] = len(nbh['leftroles']) rightroles = {} for each in self.right_subjecttype_of.all(): rightroles[each.title]=each.get_absolute_url() nbh['rightroles']=rightroles nbh['count_rightroles'] = len(nbh['rightroles']) return nbh @property def previous_nodetype(self): """Return the previous nodetype""" nodetypes = Nodetype.published.filter( creation_date__lt=self.creation_date)[:1] if nodetypes: return nodetypes[0] @property def next_nodetype(self): """Return the next nodetype""" nodetypes = Nodetype.published.filter( creation_date__gt=self.creation_date).order_by('creation_date')[:1] if nodetypes: return nodetypes[0] @property def word_count(self): """Count the words of a nodetype""" return len(strip_tags(self.html_content).split()) @property def is_actual(self): """Check if a nodetype is within publication period""" now = datetime.now() return now >= self.start_publication and now < self.end_publication @property def is_visible(self): """Check if a nodetype is visible on site""" return self.is_actual and self.status == PUBLISHED @property def related_published(self): """Return only related nodetypes published""" return nodetypes_published(self.related) @property def discussions(self): """Return published discussions""" return comments.get_model().objects.for_model( self).filter(is_public=True) @property def comments(self): """Return published comments""" return self.discussions.filter(Q(flags=None) | Q( flags__flag=CommentFlag.MODERATOR_APPROVAL)) @property def pingbacks(self): """Return published pingbacks""" return self.discussions.filter(flags__flag='pingback') @property def trackbacks(self): """Return published trackbacks""" return self.discussions.filter(flags__flag='trackback') @property def comments_are_open(self): """Check if comments are open""" if AUTO_CLOSE_COMMENTS_AFTER and self.comment_enabled: return (datetime.now() - self.start_publication).days < \ AUTO_CLOSE_COMMENTS_AFTER return self.comment_enabled @property def short_url(self): """Return the nodetype's short url""" return get_url_shortener()(self) def __unicode__(self): return self.title @property def memberof_sentence(self): """Return the metatype of which the nodetype is a member of""" if self.metatypes.count: for each in self.metatypes.all(): return '%s is a member of metatype %s' % (self.title, each) return '%s is not a fully defined name, consider making it a member of a suitable metatype' % (self.title) @property def subtypeof_sentence(self): "composes the relation as a sentence in triple format." if self.parent: return '%s is a subtype of %s' % (self.title, self.parent.tree_path) return '%s is a root node' % (self.title) composed_sentence = property(subtypeof_sentence) def subtypeof(self): "retuns the parent nodetype." if self.parent: return '%s' % (self.parent.tree_path) return None @models.permalink def get_absolute_url(self): """Return nodetype's URL""" return ('gstudio_nodetype_detail', (), { 'year': self.creation_date.strftime('%Y'), 'month': self.creation_date.strftime('%m'), 'day': self.creation_date.strftime('%d'), 'slug': self.slug}) def get_version_url(self): """Return nodetype's URL""" return "/nodetypes/display/viewhistory/" def get_serialized_data(self): """ return the fields in a serialized form of the current object. get object id, go to version model, return serialized_data for the given id """ from reversion.models import Version version = Version.objects.get(id=self.node_ptr_id) return version.serialized_data class Meta: """Nodetype's Meta""" ordering = ['-creation_date'] verbose_name = _('node type') verbose_name_plural = _('node types') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) # Save for nodetype @reversion.create_revision() def save(self, *args, **kwargs): super(Nodetype, self).save(*args, **kwargs) # Call the "real" save() method. class Objecttype(Nodetype): ''' Object class ''' def __unicode__(self): return self.title @property def get_attributetypes(self): return self.subjecttype_of.all() @property def get_relationtypes(self): left_relset = self.left_subjecttype_of.all() right_relset = self.right_subjecttype_of.all() reltypes = {} reltypes['left_subjecttype_of']=left_relset reltypes['right_subjecttype_of']=right_relset return reltypes @property def get_left_subjecttypes(self): """ for which relation types does this object become a domain of any relation type """ reltypes = [] left_relset = self.left_subjecttype_of.all() for relationtype in left_relset: reltypes.append(relationtype) return reltypes @property def get_rightroles(self): """ for which relation types does this object become a domain of any relation type """ reltypes = [] right_relset = self.right_subjecttype_of.all() for relationtype in right_relset: reltypes.append(relationtype) return reltypes @property def get_subjecttypes(self): """ for which relation types does this object become a domain of any relation type """ subjecttypes = [] attrset = self.subjecttype_of.all() for subjecttype in attrset: subjecttypes.append(subjecttype) return subjecttypes @property def member_of_metatypes(self): """ returns if the objecttype is a member of the membership in a metatype class """ types = [] if self.metatypes.all(): for metatype in self.metatypes.all(): types.append(metatype.title) return types @property def get_members(self): """ get members of the object type """ members = [] if self.member_objects.all(): for gbobject in self.member_objects.all(): members.append(gbobject) return members @property def get_nbh(self): """ Returns the neighbourhood of the nodetype """ nbh = {} nbh['title'] = self.title nbh['altnames'] = self.altnames nbh['plural'] = self.plural nbh['member_of_metatype'] = self.metatypes.all() # get all the ATs for the objecttype nbh['subjecttype_of']= self.subjecttype_of.all() # get all the RTs for the objecttype nbh.update(self.get_relationtypes) if self.parent: nbh['type_of'] = [self.parent] nbh['contains_subtypes'] = Nodetype.objects.filter(parent=self.id) # get all the objects inheriting this OT nbh['contains_members'] = self.member_objects.all() nbh['prior_nodes'] = self.prior_nodes.all() nbh['posterior_nodes'] = self.posterior_nodes.all() #nbh['authors'] = self.authors.all() return nbh @property def get_rendered_nbh(self): """ Returns the neighbourhood of the nodetype with the hyperlinks of nodes rendered """ nbh = {} nbh['title'] = self.title nbh['altnames'] = self.altnames nbh['plural'] = self.plural member_of_metatypes_list = [] for each in self.metatypes.all(): member_of_metatypes_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['member_of_metatypes'] = member_of_metatypes_list attributetypes_list = [] for each in self.get_attributetypes: attributetypes_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['attributetypes'] = attributetypes_list # get all the RTs for the objecttype reltypes_list = [] for each in self.get_relationtypes: reltypes_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['relationtypes'] = reltypes_list nbh['type_of'] = self.parent nbh['contains_subtypes'] = Nodetype.objects.filter(parent=self.id) # get all the objects inheriting this OT contains_members_list = [] for each in self.gbobjects.all(): contains_members_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['contains_members'] = contains_members_list prior_nodes_list = [] for each in self.prior_nodes.all(): prior_nodes_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['prior_nodes'] = prior_nodes_list posterior_nodes_list = [] for each in self.posterior_nodes.all(): posterior_nodes_list.append('%s' % (each.get_absolute_url(), each.title)) nbh['posterior_nodes'] = posterior_nodes_list author_list = [] for each in self.authors.all(): author_list.append('' % (each.get_absolute_url())) nbh['authors'] = author_list return nbh class Meta: """ object type's meta class """ verbose_name = _('object type') verbose_name_plural = _('object types') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) # Save for Objecttype @reversion.create_revision() def save(self, *args, **kwargs): super(Objecttype, self).save(*args, **kwargs) # Call the "real" save() method. self.nbhood=self.get_nbh with reversion.create_revision(): super(Objecttype, self).save(*args, **kwargs) # Call the "real" save() method. class Relationtype(Nodetype): ''' Properties with left and right subjects (Binary relations) are defined in this class. ''' inverse = models.CharField(_('inverse name'), help_text=_('when subjecttypes are interchanged, what should be the name of the relation type? This is mandatory field. If the relation is symmetric, same name will do.'), max_length=255,db_index=True ) left_subjecttype = models.ForeignKey(NID,related_name="left_subjecttype_of", verbose_name='left role') left_applicable_nodetypes = models.CharField(max_length=2,choices=NODETYPE_CHOICES,default='OT', verbose_name='Applicable node types for left role') left_cardinality = models.IntegerField(null=True, blank=True, verbose_name='cardinality for the left role') right_subjecttype = models.ForeignKey(NID,related_name="right_subjecttype_of", verbose_name='right role') right_applicable_nodetypes = models.CharField(max_length=2,choices=NODETYPE_CHOICES,default='OT', verbose_name='Applicable node types for right role') right_cardinality = models.IntegerField(null=True, blank=True, verbose_name='cardinality for the right role') is_symmetrical = models.NullBooleanField(verbose_name='Is symmetrical?') is_reflexive = models.NullBooleanField(verbose_name='Is reflexive?') is_transitive = models.NullBooleanField(verbose_name='Is transitive?') def get_serialized_data(self): """ return the fields in a serialized form of the current object. get object id, go to version model, return serialized_data for the given id """ from reversion.models import Version version = Version.objects.get(id=self.node_ptr_id) return version.serialized_data def __unicode__(self): return self.title class Meta: """ relation type's meta class """ verbose_name = _('relation type') verbose_name_plural = _('relation types') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) # Save for Relationtype @reversion.create_revision() def save(self, *args, **kwargs): super(Relationtype, self).save(*args, **kwargs) # Call the "real" save() method. class Attributetype(Nodetype): ''' To define attributes of objects. First three fields are mandatory. The rest of the fields may be required depending on what type of field is selected for datatype. ''' subjecttype = models.ForeignKey(NID, related_name="subjecttype_of", verbose_name='subject type name') applicable_nodetypes = models.CharField(max_length=2,choices=NODETYPE_CHOICES,default='OT', verbose_name='applicable nodetypes') dataType = models.CharField(max_length=2, choices=FIELD_TYPE_CHOICES,default='01', verbose_name='data type of value') verbose_name = models.CharField(max_length=500, null=True, blank=True, verbose_name='verbosename', help_text='verbose name') null = models.NullBooleanField(verbose_name='Null', help_text='can the value be null?') blank = models.NullBooleanField(verbose_name='Blank', help_text='can the form be left blank?') help_text = models.CharField(max_length=500, null=True, blank=True, verbose_name='Help text', help_text='help text for the field') max_digits = models.IntegerField(max_length=5, null=True, blank=True, verbose_name='Max digit', help_text='If you have selected Decimal Field for datatype, you have to specify the number of digits.') decimal_places = models.IntegerField(max_length=2, null=True, blank=True, verbose_name='Decimal places', help_text='If you have selected Decimal Field for datatype, you have to specify the decimal places.') auto_now = models.NullBooleanField(verbose_name='Auto now', null=True, blank=True, help_text='Use this if DateTime & Time Field was chosen above for datatype') auto_now_add = models.NullBooleanField(verbose_name='Auto now add', null=True, blank=True, help_text='Use this if DateTime & Time Field was chosen above for datatype') upload_to = models.CharField(max_length=500,verbose_name='Upload to', null=True, blank=True, help_text='Required for FileField and ImageField') path=models.CharField(max_length=500,verbose_name='Path', null=True, blank=True, help_text='Required for FilePathField') verify_exists=models.NullBooleanField(verbose_name='Verify exits', null=True, blank=True, help_text='Required for AttributeURLField') min_length=models.IntegerField(max_length=10,null=True, blank=True, verbose_name='min length', help_text='minimum length') required=models.NullBooleanField(verbose_name='required', null=True, blank=True, help_text='Use this for setting mandatory and optional fields') label=models.CharField(max_length=500, null=True,blank=True,verbose_name='label',help_text='specify the "human-friendly" label') unique=models.NullBooleanField(verbose_name='unique', null=True, blank=True, help_text='If True, this field must be unique throughout the table') validators=models.ManyToManyField('self', verbose_name='validators',blank=True, null=True,help_text='A list of validators to run for this field') default=models.CharField(max_length=500, null=True, blank=True, verbose_name='default', help_text='The default value for the field') editable=models.NullBooleanField(verbose_name='required', null=True, blank=True, help_text='If False, the field will not be editable') def __unicode__(self): return self.title class Meta: """ attribute type's meta class """ verbose_name = _('attribute type') verbose_name_plural = _('attribute types') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) # Save for Attributetype @reversion.create_revision() def save(self, *args, **kwargs): super(Attributetype, self).save(*args, **kwargs) # Call the "real" save() method. class Relation(Edge): ''' Relations, instances of relationtypes ''' left_subject_scope = models.CharField(max_length=50, verbose_name='subject scope or qualification', null=True, blank=True) left_subject = models.ForeignKey(NID, related_name="left_subject_of", verbose_name='subject name') relationtype_scope = models.CharField(max_length=50, verbose_name='relation scope or qualification', null=True, blank=True) relationtype = models.ForeignKey(Relationtype, verbose_name='relation name') right_subject_scope = models.CharField(max_length=50, verbose_name='object scope or qualification', null=True, blank=True) right_subject = models.ForeignKey(NID, related_name="right_subject_of", verbose_name='object name') def ApplicableNodeTypes_filter(self,choice): nodeslist = [] if choice == 'ED': nodeslist = Edge.objects.all() if choice == 'OB': nodeslist = Objects.objects.all() if choice == 'ND': nodeslist = Node.objects.all() if choice == 'NT': nodeslist = Nodetype.objects.all() if choice == 'OT': nodeslist = Objecttype.objects.all() if choice == 'RT': nodeslist = Relationtype.objects.all() if choice == 'MT': nodeslist = Metatype.objects.all() if choice == 'AT': nodeslist = Attributetype.objects.all() if choice == 'RN': nodeslist = Relation.objects.all() if choice == 'AS': nodeslist = Attribute.objects.all() if choice == 'ST': nodeslist = Systemtype.objects.all() if choice == 'SY': nodeslist = System.objects.all() return nodeslist class Meta: unique_together = (('left_subject_scope','left_subject','relationtype_scope', 'relationtype', 'right_subject_scope','right_subject'),) verbose_name = _('relation') verbose_name_plural = _('relations') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) def __unicode__(self): return self.composed_sentence @property def composed_sentence(self): "composes the relation as a sentence in a triple format." return '%s %s %s %s %s %s' % (self.left_subject_scope, self.left_subject, self.relationtype_scope, self.relationtype, self.right_subject_scope, self.right_subject) @property def inversed_sentence(self): "composes the inverse relation as a sentence in a triple format." return '%s %s %s %s %s' % (self.objectScope, self.right_subject, self.relationtype.inverse, self.left_subject_scope, self.left_subject ) @property def key_value(self): return dict({str(self.relationtype):str(self.right_subject)}) @property def inverse_key_value(self): return dict({str(self.relationtype.inverse):str(self.left_subject)}) @property def relation_sentence(self): """Return the relations of the objecttypes""" if self.relationtype: # for relation in self.relationtype(): return '%s %s %s' % (self.left_subject,self.relationtype,self.right_subject ) @property def partial_composition(self): ''' function that composes the right_subject and relation name, as in "x as a friend", "y as a sibling" ''' return '%s as a %s' % (self.right_subject, self.relationtype) # Save for Relation @reversion.create_revision() def save(self, *args, **kwargs): super(Relation, self).save(*args, **kwargs) # Call the "real" save() method. class Attribute(Edge): ''' Attribute value store for default datatype varchar. Subject can be any of the nodetypes. ''' subject_scope = models.CharField(max_length=50, verbose_name='subject scope or qualification', null=True, blank=True) subject = models.ForeignKey(NID, related_name="subject_of", verbose_name='subject name') attributetype_scope = models.CharField(max_length=50, verbose_name='property scope or qualification', null=True, blank=True) attributetype = models.ForeignKey(Attributetype, verbose_name='property name') value_scope = models.CharField(max_length=50, verbose_name='value scope or qualification', null=True, blank=True) svalue = models.CharField(max_length=100, verbose_name='serialized value') class Meta: unique_together = (('subject_scope', 'subject', 'attributetype_scope', 'attributetype', 'value_scope', 'svalue'),) verbose_name = _('attribute') verbose_name_plural = _('attributes') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) def subject_filter(self,attr): """ returns applicaable selection of nodes for selecting as subject """ subjecttype = attr.subjecttype for each in Objecttype.objects.all(): if attr.subjecttype.id == each.id: return each.get_members def __unicode__(self): return self.composed_attribution @property def edge_node_dict(self): ''' composes the attribution as a name:value pair sentence without the subject. ''' return dict({str(self.attributetype_scope) + str(self.attributetype): str(self.value_scope)+ str(self.svalue)}) @property def composed_sentence(self): ''' composes the attribution as a sentence in a triple format. ''' return '%s %s has %s %s %s %s' % (self.subject_scope, self.subject, self.attributetype_scope, self.attributetype, self.value_scope, self.svalue) @property def composed_attribution(self): ''' composes a name to the attribute ''' return 'the %s of %s is %s' % (self.attributetype, self.subject, self.svalue) @property def partial_composition(self): ''' function that composes the value and attribute name, as in "red as color", "4 as length" ''' return '%s as %s' % (self.svalue, self.attributetype) def subject_filter(self,attr): """ returns applicable selection of nodes for selecting objects """ for each in Objecttype.objects.all(): if attr.subjecttype.id == each.id: return each.get_members # Save for Attribute @reversion.create_revision() def save(self, *args, **kwargs): super(Attribute, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeCharField(Attribute): value = models.CharField(max_length=100, verbose_name='string') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeCharField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeTextField(Attribute): value = models.TextField(verbose_name='text') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeTextField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeIntegerField(Attribute): value = models.IntegerField(max_length=100, verbose_name='Integer') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeIntegerField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeCommaSeparatedIntegerField(Attribute): value = models.CommaSeparatedIntegerField(max_length=100, verbose_name='integers separated by comma') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeCommaSeparatedIntegerField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeBigIntegerField(Attribute): value = models.BigIntegerField(max_length=100, verbose_name='big integer') def __unicode__(self): return self.title class AttributePositiveIntegerField(Attribute): value = models.PositiveIntegerField(max_length=100, verbose_name='positive integer') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributePositiveIntegerField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeDecimalField(Attribute): value = models.DecimalField(max_digits=3, decimal_places=2, verbose_name='decimal') def __unicode__(self): return self.title def save(self, *args, **kwargs): super(AttributeDecimalField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeFloatField(Attribute): value = models.FloatField(max_length=100, verbose_name='number as float') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeFloatField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeBooleanField(Attribute): value = models.BooleanField(verbose_name='boolean') def __unicode__(self): return self.title def save(self, *args, **kwargs): super(AttributeBooleanField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeNullBooleanField(Attribute): value = models.NullBooleanField(verbose_name='true false or unknown') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeNullBooleanField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeDateField(Attribute): value = models.DateField(max_length=100, verbose_name='date') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeDateField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeDateTimeField(Attribute): value = models.DateTimeField(max_length=100, verbose_name='date time') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeDateTimeField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeTimeField(Attribute): value = models.TimeField(max_length=100, verbose_name='time') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeTimeField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeEmailField(Attribute): value = models.CharField(max_length=100,verbose_name='value') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeEmailField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeFileField(Attribute): value = models.FileField(upload_to='/media', verbose_name='file') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeFileField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeFilePathField(Attribute): value = models.FilePathField(verbose_name='path of file') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeFilePathField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeImageField(Attribute): value = models.ImageField(upload_to='/media', verbose_name='image') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeImageField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeURLField(Attribute): value = models.URLField(max_length=100, verbose_name='url') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeURLField, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeIPAddressField(Attribute): value = models.IPAddressField(max_length=100, verbose_name='ip address') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeIPAddressField, self).save(*args, **kwargs) # Call the "real" save() method. class Processtype(Nodetype): """ A kind of nodetype for defining processes or events or temporal objects involving change. """ changing_attributetype_set = models.ManyToManyField(Attributetype, null=True, blank=True, verbose_name=_('attribute set involved in the process'), related_name=' changing_attributetype_set_of') changing_relationtype_set = models.ManyToManyField(Relationtype, null=True, blank=True, verbose_name=_('relation set involved in the process'), related_name='changing_relationtype_set_of') def __unicode__(self): return self.title class Meta: verbose_name = _('process type') verbose_name_plural = _('process types') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) @reversion.create_revision() def save(self, *args, **kwargs): super(Processtype, self).save(*args, **kwargs) # Call the "real" save() method. class Systemtype(Nodetype): """ class to organize Systems """ nodetype_set = models.ManyToManyField(Nodetype, related_name="nodetype_set_of", verbose_name='Possible edges in the system', blank=True, null=False) relationtype_set = models.ManyToManyField(Relationtype, related_name="relationtype_set_of", verbose_name='Possible nodetypes in the system', blank=True, null=False) attributetype_set = models.ManyToManyField(Attributetype, related_name="attributetype_set_of", verbose_name='systems to be nested in the system', blank=True, null=False) metatype_set = models.ManyToManyField(Metatype, related_name="metatype_set_of", verbose_name='Possible edges in the system', blank=True, null=False) processtype_set = models.ManyToManyField(Processtype, related_name="processtype_set_of", verbose_name='Possible edges in the system', blank=True, null=False) def __unicode__(self): return self.title class Meta: verbose_name = _('system type') verbose_name_plural = _('system types') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) @reversion.create_revision() def save(self, *args, **kwargs): super(Systemtype, self).save(*args, **kwargs) # Call the "real" save() method. class AttributeSpecification(Node): """ specifying an attribute by a subject to say for example: population of India, color of a flower etc. These do not yeild a proposition but a description, which can be used as a subject in another sentence. """ attributetype = models.ForeignKey(Attributetype, verbose_name='property name') subjects = models.ManyToManyField(NID, related_name="subjects_attrspec_of", verbose_name='subjects') @property def composed_subject(self): ''' composes a name to the attribute ''' subjects = u'' for each in self.subjects.all(): subjects = subjects + each.title + ' ' return 'the %s of %s' % (self.attributetype, subjects) def __unicode__(self): return self.composed_subject class Meta: verbose_name = _('attribute specification') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) @reversion.create_revision() def save(self, *args, **kwargs): super(AttributeSpecification, self).save(*args, **kwargs) # Call the "real" save() method. class RelationSpecification(Node): """ specifying a relation with a subject """ relationtype = models.ForeignKey(Relationtype, verbose_name='relation name') subjects = models.ManyToManyField(NID, related_name="subjects_in_relspec", verbose_name='subjects') @property def composed_subject(self): ''' composing an expression with relation name and subject ''' subjects = u'' for each in self.subjects.all(): subjects = subjects + each.title + ' ' return 'the %s of %s' % (self.relationtype, subjects) def __unicode__(self): return self.composed_subject class Meta: verbose_name = _('relation specification') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) @reversion.create_revision() def save(self, *args, **kwargs): super(RelationSpecification, self).save(*args, **kwargs) # Call the "real" save() method. class NodeSpecification(Node): """ A node specified (described) by its relations or attributes or both. """ subject = models.ForeignKey(Node, related_name="subject_nodespec", verbose_name='subject name') relations = models.ManyToManyField(Relation, related_name="relations_in_nodespec", verbose_name='relations used to specify the domain') attributes = models.ManyToManyField(Attribute, related_name="attributes_in_nodespec", verbose_name='attributes used to specify the domain') @property def composed_subject(self): ''' composing an expression subject and relations ''' relations = u'' for each in self.relations.all(): relations = relations + each.partial_composition + ', ' attributes = u'' for each in self.attributes.all(): attributes = attributes + each.partial_composition + ', ' return 'the %s with %s, %s' % (self.subject, self.relations, self.attributes) def __unicode__(self): return self.composed_subject class Meta: verbose_name = _('Node specification') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) @reversion.create_revision() def save(self, *args, **kwargs): super(NodeSpecification, self).save(*args, **kwargs) # Call the "real" save() method. class Expression(Node): """ Expression constructor """ left_term = models.ForeignKey(NID, related_name="left_term_of", verbose_name='left term name') relationtype = models.ForeignKey(Relationtype, verbose_name='relation name') right_term = models.ForeignKey(NID, related_name="right_term_of", verbose_name='right term name') def __unicode__(self): return self.composed_sentence @property def composed_sentence(self): "composes the relation as a sentence in a triple format." return '%s %s %s' % (self.left_term, self.relationtype, self.right_term) class Meta: unique_together = (('left_term','relationtype','right_term'),) verbose_name = _('expression') verbose_name_plural = _('expressionss') permissions = (('can_view_all', 'Can view all'), ('can_change_author', 'Can change author'), ) @reversion.create_revision() def save(self, *args, **kwargs): super(Expression, self).save(*args, **kwargs) # Call the "real" save() method. class Union(Node): """ union of two classes """ nodetypes = models.ManyToManyField(Nodetype, related_name = 'union_of', verbose_name='node types for union') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(Union, self).save(*args, **kwargs) # Call the "real" save() method. class Complement(Node): """ complement of a class """ nodetypes = models.ManyToManyField(Nodetype, related_name = 'complement_of', verbose_name='complementary nodes') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(Complement, self).save(*args, **kwargs) # Call the "real" save() method. class Intersection(Node): """ Intersection of classes """ nodetypes = models.ManyToManyField(Nodetype, related_name = 'intersection_of', verbose_name='intersection of classes') def __unicode__(self): return self.title @reversion.create_revision() def save(self, *args, **kwargs): super(Intersection, self).save(*args, **kwargs) # Call the "real" save() method. reversion.register(NID) if not reversion.is_registered(Systemtype): reversion.register(Systemtype) if not reversion.is_registered(Objecttype): reversion.register(Objecttype , follow=["nodetype_ptr"]) if not reversion.is_registered(Node): reversion.register(Node , follow=["nid_ptr"]) if not reversion.is_registered(Edge): reversion.register(Edge , follow=["nid_ptr"]) if not reversion.is_registered(Processtype): reversion.register(Processtype, follow=["changing_attributetype_set", "changing_relationtype_set"]) if not reversion.is_registered(Nodetype): reversion.register(Nodetype, follow=["node_ptr","parent", "metatypes","prior_nodes", "posterior_nodes"]) if not reversion.is_registered(Metatype): reversion.register(Metatype, follow=["node_ptr","parent"]) if not reversion.is_registered(Relationtype): reversion.register(Relationtype, follow=["left_subjecttype", "right_subjecttype"]) if not reversion.is_registered(Attributetype): reversion.register(Attributetype, follow=["subjecttype"]) if not reversion.is_registered(Attribute): reversion.register(Attribute, follow=["subject", "attributetype"]) if not reversion.is_registered(Relation): reversion.register(Relation, follow=["left_subject", "right_subject", "relationtype"]) moderator.register(Nodetype, NodetypeCommentModerator) mptt.register(Metatype, order_insertion_by=['title']) mptt.register(Nodetype, order_insertion_by=['title']) mptt.register(Objecttype, order_insertion_by=['title']) mptt.register(Relationtype, order_insertion_by=['title']) mptt.register(Attributetype, order_insertion_by=['title']) mptt.register(Systemtype, order_insertion_by=['title']) mptt.register(Processtype, order_insertion_by=['title']) post_save.connect(ping_directories_handler, sender=Nodetype, dispatch_uid='gstudio.nodetype.post_save.ping_directories') post_save.connect(ping_external_urls_handler, sender=Nodetype, dispatch_uid='gstudio.nodetype.post_save.ping_external_urls') class Peer(User): """Subclass for non-human users""" def __unicode__(self): return self.ip ip = models.IPAddressField("Peer's IP address") pkey = models.CharField(("Peer's public-key"), max_length=255)