class MaintenanceItem(statusMixin, models.Model):
title = models.CharField(max_length=150)
short_description = models.CharField(_("Short Description"), max_length=150, blank=True)
description = RichTextField(_("Description"))
slug = fields.AutoSlugField(populate_from="title")
created = fields.CreationDateTimeField()
modified = fields.ModificationDateTimeField()
position = models.PositiveIntegerField(default=0)
def __str__(self):
return self.title
class Meta:
ordering = ("position",)
verbose_name = _("Maintenance Item")
verbose_name_plural = _("Maintenance Items")
@property
def url(self):
if self.slug == "":
self._meta.get_field("slug").create_slug(self, True)
self.save()
return reverse_lazy("gardens:MaintenanceItemDetailView", kwargs={"slug": self.slug})
@property
def list_description(self):
if self.short_description != "":
return f"<p>{self.short_description}</p>"
else:
return self.description
class Compra(models.Model):
objects = CompraManager()
orden_compra = models.IntegerField(_('Orden de Compra'),
null=True,
blank=True)
fecha = models.DateField(_('Fecha'), null=True, blank=True)
importe = models.DecimalField(_('Importe'),
decimal_places=2,
max_digits=19)
suministro = models.CharField(_('Suministro'),
max_length=32,
null=True,
blank=True)
proveedor = models.ForeignKey(Proveedor)
destino = models.ForeignKey(Reparticion)
created_at = fields.CreationDateTimeField()
def _oc_numero(self):
return "%s/%s" % (self.orden_compra, self.fecha.strftime("%Y"))
oc_numero = property(_oc_numero)
def __unicode__(self):
return "%s compra a %s por $%s" % (self.destino, self.proveedor,
self.importe)
@models.permalink
def get_absolute_url(self):
return ('orden_de_compra', (), {
'numero': self.orden_compra,
'anio': self.fecha.year
})
class Garden(statusMixin, models.Model):
title = models.CharField(max_length=150)
sub_title = models.CharField(max_length=250, blank=True)
work_type = models.ManyToManyField(WorkType, blank=True)
short_description = models.CharField(_("Short Description"), max_length=150, blank=True)
description = RichTextField(_("Body"))
slug = fields.AutoSlugField(populate_from="title")
created = fields.CreationDateTimeField()
modified = fields.ModificationDateTimeField()
position = models.PositiveIntegerField(default=0)
def __str__(self):
return self.title
class Meta:
ordering = ("position",)
verbose_name = _("Garden")
verbose_name_plural = _("Gardens")
@property
def url(self):
return reverse_lazy("gardens:GardenDetail", kwargs={"slug": self.slug})
@property
def gardenphoto_hero_set(self):
return self.gardenphoto_set.filter(is_hero=True)
class Proveedor(models.Model):
objects = ProveedorManager()
nombre = models.TextField(_('Nombre'),
max_length=256,
null=False,
blank=True)
nombre_fantasia = models.TextField(_('Nombre fantasia'),
null=True,
blank=True)
cuit = models.CharField(_('CUIT'), max_length=32, null=True, blank=True)
domicilio = models.CharField(_('Domicilio'),
max_length=128,
null=True,
blank=True)
localidad = models.CharField(_('Localidad'),
max_length=128,
null=True,
blank=True)
slug = fields.AutoSlugField(populate_from='nombre', overwrite=True)
created_at = fields.CreationDateTimeField()
def __unicode__(self):
rv = self.nombre
return rv
@models.permalink
def get_absolute_url(self):
return ('mdqweb.core.views.proveedor', (), {
'proveedor_slug': self.slug
})
class BaseMembre(models.Model):
user = models.OneToOneField(User, blank=True, null=True, unique=True,verbose_name=_(u'Utilisateur'))
#uri = models.URLField(blank=True, unique=True, verify_exists=False,verbose_name=_(u'URI principale'))
#sameas = models.ManyToManyField(SameAs,blank=True, null=True,verbose_name=_(u'Autres URI'))
nom = models.CharField(_(u'Nom'),max_length=100)
prenom = models.CharField(_(u'Prénom'),max_length=100,null=True,blank=True)
adresse = models.TextField(_(u'Adresse'),null=True,blank=True)
ville = models.CharField(_(u'Ville'),null=True,blank=True, max_length=100)
code_postal = models.CharField(_(u'Code postal'),null=True,blank=True, max_length=5)
telephone_fixe = models.CharField(_(u'Téléphone fixe'),null=True,blank=True, max_length=14)
telephone_portable = models.CharField(_(u'Téléphone mobile'),null=True,blank=True, max_length=14)
email = models.EmailField(_(u'Email personnel'),blank=True)
created = exfields.CreationDateTimeField(_(u'Création'),null=True)
modified = exfields.ModificationDateTimeField(_(u'Modification'),null=True)
class Meta:
abstract = True
def __unicode__(self):
return self.prenom+u' '+self.nom
@models.permalink
def get_absolute_url(self):
return ('profiles_profile_detail', (), { 'username': self.user.username })
def engagements(self):
eng = []
for e in self.engagement_set.all():
eng.append({'initiative':e.initiative,'role':e.role})
return eng
'''
class Term(models.Model):
literal = models.CharField(_(u'Forme literale'), max_length=255)
slug = exfields.AutoSlugField(populate_from=('literal'))
language = models.CharField(_(u'Langue'),
max_length=10,
choices=LANG_LABELS,
default='@fr')
created = exfields.CreationDateTimeField(_(u'date de création'))
modified = exfields.ModificationDateTimeField(_(u'Mdate de modification'))
author = models.CharField(_(u'Auteur'),
blank=True,
max_length=250,
editable=False)
concept = models.ManyToManyField(Concept, through='Label')
occurences = models.IntegerField(blank=True, null=True)
def get_absolute_url(self):
return reverse('tag_detail', args=[self.slug])
def __unicode__(self):
return unicode(self.literal)
# def save(self):
# self.author = comment on récupère le current user
#createConcept from Term -> pas automatique , demande une revue
class Meta:
verbose_name = _(u'Terme')
def save(self, *args, **kwargs):
self.count = self.initiative_set.all().count()
super(Term, self).save(*args, **kwargs)
class BaseInitiative(models.Model):
title = models.CharField(_('Titre'), max_length=250)
acronym = models.CharField(_('Sigle'),
blank=True,
null=True,
max_length=250)
description = models.TextField(_(u'Description'), blank=True, null=True)
uri = models.CharField(_(u'URI principale'),
blank=True,
null=True,
max_length=250,
editable=False)
tags = models.ManyToManyField(Term)
#sites = models.ManyToManyField('coop_local.Site',related_name='old_rel')
members = models.ManyToManyField('coop_local.Membre',
through='coop_local.Engagement',
verbose_name=_(u'Membres'))
telephone_fixe = models.CharField(_(u'Téléphone fixe'),
blank=True,
null=True,
max_length=14)
email = models.EmailField(_(u'Email général'), blank=True, null=True)
web = models.URLField(_(u'Site web'),
blank=True,
null=True,
verify_exists=True)
rss = models.URLField(_(u'Flux RSS'),
blank=True,
null=True,
verify_exists=True)
slug = exfields.AutoSlugField(populate_from='title', blank=True,
null=True) #TODO enlever null ensuite
created = exfields.CreationDateTimeField(_(u'Création'), null=True)
modified = exfields.ModificationDateTimeField(_(u'Modification'),
null=True)
active = models.BooleanField(default=True)
class Meta:
abstract = True
def __unicode__(self):
if (self.acronym != None and len(self.title) > 40):
return unicode(self.acronym)
else:
return unicode(self.title)
#@models.permalink
def get_absolute_url(self):
return reverse('initiative_detail', args=[self.slug])
# return ('/initiative/'+self.slug+'.html')
def get_tags(self):
return self.tags.all()
def local_uri(self):
return ('http://dev.credis.org:8000/initiative/' + self.slug + '/')
class BaseTransaction(models.Model):
origin = models.ForeignKey('coop_local.Exchange',related_name='origin')
destination = models.ForeignKey('coop_local.Exchange',related_name='destination')
title = models.CharField(_('Titre'),blank=True,max_length=250)
description = models.TextField(_(u'Description'),blank=True)
created = exfields.CreationDateTimeField(_(u'Création'),null=True)
modified = exfields.ModificationDateTimeField(_(u'Modification'),null=True)
uuid = exfields.UUIDField() #nécessaire pour URI de l'engagement
class Meta:
abstract = True
class BaseEngagement(models.Model):
membre = models.ForeignKey('coop_local.Membre')
initiative = models.ForeignKey('coop_local.Initiative')
role = models.ForeignKey('coop_local.Role')
created = exfields.CreationDateTimeField(_(u'Création'), null=True)
modified = exfields.ModificationDateTimeField(_(u'Modification'),
null=True)
#membre_uri = models.CharField(_(u'Profil FOAF'),blank=True, max_length=250, editable=False)
uuid = exfields.UUIDField() #nécessaire pour URI de l'engagement
class Meta:
abstract = True
'''
class TimeStampedModelBase(models.Model):
""" TimeStampedModel
An abstract base class model that provides self-managed "created" and
"modified" fields.
"""
created = fields.CreationDateTimeField(verbose_name=_('Created'))
modified = fields.ModificationDateTimeField(verbose_name=_('Modified'))
class Meta:
abstract = True
# TO support python3.4
def __str__(self):
return self.__unicode__()
class AuditModel(models.Model):
date_created = fields.CreationDateTimeField(editable=True)
created_by = models.ForeignKey(User,
null=True,
blank=True,
related_name="+")
date_updated = fields.ModificationDateTimeField(editable=True)
updated_by = models.ForeignKey(User,
null=True,
blank=True,
related_name="+")
class Meta:
abstract = True
class BaseSite(models.Model):
title = models.CharField(_('Titre'), null=True, blank=True, max_length=250)
description = models.TextField(_(u'Description'), null=True, blank=True)
site_principal = models.BooleanField(default=True)
uri = models.CharField(_(u'URI principale'),
null=True,
blank=True,
max_length=250,
editable=False)
location = models.ForeignKey(Location, related_name='sites')
initiative = models.ForeignKey('coop_local.Initiative',
null=True,
blank=True,
related_name='sites')
adr1 = models.CharField(null=True, blank=True, max_length=100)
adr2 = models.CharField(null=True, blank=True, max_length=100)
zipcode = models.CharField(null=True, blank=True, max_length=5)
city = models.CharField(null=True, blank=True, max_length=100)
latlong = models.CharField(null=True, blank=True, max_length=100)
lat = models.CharField(null=True, blank=True, max_length=100)
long = models.CharField(null=True, blank=True, max_length=100)
created = exfields.CreationDateTimeField(_(u'Création'), null=True)
modified = exfields.ModificationDateTimeField(_(u'Modification'),
null=True)
#membre_uri = models.CharField(_(u'Profil FOAF'),blank=True, max_length=250, editable=False)
uuid = exfields.UUIDField(null=True) #nécessaire pour URI de l'engagement
class Meta:
abstract = True
def __unicode__(self):
if self.title != None:
return self.title + u', ' + self.city
else:
return self.adr1 + u', ' + self.city
def get_absolute_url(self):
return reverse('place_detail', args=[self.uuid])
def links(self):
links = {
'inits': self.initiative_set.all().count() - 1,
'events': self.event_set.all().count() - 1
}
return links
class BaseExchange(models.Model):
title = models.CharField(_('Titre'),blank=True,max_length=250)
description = models.TextField(_(u'Description'),blank=True)
org = models.ForeignKey('coop_local.Initiative',blank=True,null=True)
member = models.ForeignKey('coop_local.Membre')
etype = models.PositiveSmallIntegerField( _(u'Type d’annonce'),
choices=EXCHANGE.CHOICES,
default=EXCHANGE.OFFER)
uri = models.CharField(_(u'URI principale'),blank=True, max_length=250, editable=False)
expiration = models.DateField(default=datetime.datetime.today,blank=True,null=True)
slug = exfields.AutoSlugField(populate_from='title')
created = exfields.CreationDateTimeField(_(u'Création'),null=True)
modified = exfields.ModificationDateTimeField(_(u'Modification'),null=True)
#membre_uri = models.CharField(_(u'Profil FOAF'),blank=True, max_length=250, editable=False)
class Meta:
abstract = True
class Reparticion(models.Model):
objects = ReparticionManager()
nombre = models.CharField(_('Nombre'), max_length=128, null=False, blank=False, unique=True)
slug = fields.AutoSlugField(populate_from='nombre', overwrite=True)
created_at = fields.CreationDateTimeField()
def __unicode__(self):
return self.nombre
@models.permalink
def get_absolute_url(self):
return ('moronweb.core.views.reparticion', (),
{'reparticion_slug': self.slug})
class ContactSubmission(models.Model):
name = models.CharField(_("Name"), max_length=200)
phone = models.CharField(_("Phone"),
max_length=100,
blank=True,
default="")
email = models.EmailField(_("Email"))
enquiry = models.TextField(_("Enquiry"))
consent = models.BooleanField(
_("I am over 18 and I give consent for data I enter into this form to be use to respond to my enquiry."
))
created = fields.CreationDateTimeField()
def __str__(self):
return self.name
class GeoPoly(geomodels.Model):
name = models.CharField(max_length=200, null=True, blank=True)
location = models.OneToOneField(Location, null=True, related_name='poly')
uuid = ext_fields.UUIDField(version=4, null=True)
global_id_text = models.CharField(max_length=200, null=True, blank=True)
code = models.CharField(max_length=100, null=True, blank=True)
parent_code = models.CharField(max_length=100, null=True, blank=True)
source = models.CharField(max_length=100, null=True, blank=True)
created_at = ext_fields.CreationDateTimeField()
last_modified = ext_fields.ModificationDateTimeField()
last_modified_gis = models.DateField(null=True)
geom = geomodels.MultiPolygonField(srid=4326)
objects = geomodels.GeoManager()
class Meta:
verbose_name = "Geo Location Polygon"
class Label(models.Model):
'''
Defines a SKOS-XL Label Class, and also a Tag in django-taggit
'''
# FIELDS name and slug are defined in TagBase - they are forced to be unique
# so if a concept is to be made available as a tag then it must conform to this constraint - generating a label without a Concept implies its is a tag generation - and name will be forced to be unique.
concept = models.ForeignKey(Concept,blank=True,null=True,verbose_name=_(u'main concept'),related_name='labels')
label_type = models.PositiveSmallIntegerField(_(u'label type'), choices=tuple(LABEL_TYPES.CHOICES), default= LABEL_TYPES.prefLabel)
label_text = models.CharField(_(u'label text'),max_length=100, null=False)
language = models.CharField(_(u'language'),max_length=10, choices=LANG_LABELS, default='fr')
#metadata
user = models.ForeignKey(settings.AUTH_USER_MODEL,blank=True,null=True,verbose_name=_(u'django user'),editable=False)
uri = models.CharField(_(u'author URI'),blank=True,max_length=250,editable=True)
author_uri = models.CharField(u'main URI',blank=True,max_length=250,editable=True)
created = exfields.CreationDateTimeField(_(u'created'))
modified = exfields.ModificationDateTimeField(_(u'modified'))
def get_absolute_url(self):
return reverse('tag_detail', args=[self.slug])
def __unicode__(self):
return unicode(self.label_text)
def create_concept_from_label(self):
if not self.concept:
# self.label_text = self.name
c = Concept(pref_label=self.__unicode__(),
changenote=unicode(ugettext_lazy(u'Created from tag "')+self.__unicode__()+u'"'))
c.save(skip_name_lookup=True)# because we just set it
self.concept = c
self.save()
def save(self, *args, **kwargs):
# if not self.name :
# self.name = self.label_text
if self.label_type == LABEL_TYPES.prefLabel:
if Label.objects.filter(concept=self.concept,
label_type=LABEL_TYPES.prefLabel,
language=self.language
).exists():
raise ValidationError(_(u'There can be only one preferred label by language'))
if not self.concept.pref_label or self.concept.pref_label == '<no label>' :
self.concept.pref_label = self.label_text
self.concept.save()
super(Label, self).save()
class Concept(models.Model):
definition = models.TextField(blank=True)
changenote = models.TextField(blank=True)
created = exfields.CreationDateTimeField(_(u'date de création'))
modified = exfields.ModificationDateTimeField(_(u'date de modification'))
author = models.CharField(_(u'Auteur'),
blank=True,
max_length=250,
editable=False)
sem_relations = models.ManyToManyField("self",
symmetrical=False,
through='SemRelation')
def __unicode__(self):
preflabel = Label.objects.filter(concept=self,
type=LABEL_TYPES.PREF,
term__language='@fr')[0].term.literal
# ??? y'a pas une relation inverse ??
return unicode(preflabel)
class HomePagePod(statusMixin, models.Model):
title = models.CharField(max_length=150)
description = models.CharField(max_length=350)
image = models.ImageField(upload_to="uploads/homepagepods",
blank=True,
default="")
link = models.ForeignKey(node, on_delete=models.CASCADE)
created = fields.CreationDateTimeField()
modified = fields.ModificationDateTimeField()
position = models.PositiveIntegerField(default=0)
def __str__(self):
return self.title
class Meta:
ordering = ("position", )
verbose_name = _("Home Page Pod")
verbose_name_plural = _("Home Page Pods")
def url(self):
return self.link.url
class Location(MPTTModel):
parent = TreeForeignKey('self', null=True, related_name='children')
uuid = ext_fields.UUIDField(version=4, primary_key=True)
name = models.CharField(max_length=100, default="Unknown")
alt_names = models.CharField(max_length=200, null=True, blank=True)
location_type = models.ForeignKey(LocationType)
created_at = ext_fields.CreationDateTimeField()
last_modified = ext_fields.ModificationDateTimeField()
@property
def gis(self):
try:
return self.poly
except GeoPoly.DoesNotExist:
try:
return self.point
except GeoPoint.DoesNotExist:
return None
def __str__(self):
return "%s" % self.name
class Meta:
verbose_name = "Location"
class ShippingInfo(models.Model):
status: ShippingStatus = models.CharField(null=False,
max_length=32,
choices=ShippingStatus.choices())
date: datetime = extensions_field.CreationDateTimeField()
class Scheme(models.Model):
objects = SchemeManager()
pref_label = models.CharField(_(u'label'), blank=True,
max_length=255) #should just be called label
slug = exfields.AutoSlugField(populate_from=('pref_label'))
# URI doesnt need to be a registered Namespace unless you want to use prefix:term expansion for it
uri = models.CharField(blank=True,
max_length=250,
verbose_name=_(u'main URI'),
editable=True)
created = exfields.CreationDateTimeField(_(u'created'), null=True)
modified = exfields.ModificationDateTimeField(_(u'modified'), null=True)
definition = models.TextField(_(u'definition'), blank=True)
meta = models.TextField(_(u'additional metadata'),
help_text=_(u'(<predicate> <object> ; list) '),
blank=True)
def __unicode__(self):
return self.pref_label
def natural_key(self):
return (self.uri)
def get_absolute_url(self):
return reverse('scheme_detail', args=[self.slug])
def tree(self):
tree = (self, []) # result is a tuple(scheme,[child concepts])
for concept in Concept.objects.filter(scheme=self, top_concept=True):
tree[1].append((concept, concept.get_narrower_concepts()))
#with nested tuple(concept, [child concepts])
return tree
def test_tree(self):
i = self.tree()
print(i[0])
for j in i[1]:
print(u'--' + unicode(j[0]))
for k in j[1]:
print(u'----' + unicode(k[0]))
for l in k[1]:
print(u'------' + unicode(l[0]))
for m in l[1]:
print(u'--------' + unicode(m[0]))
for idx, val in enumerate(ints):
print(idx, val)
# needs fixing - has limited depth of traversal - probably want an option to paginate and limit.
def json_tree(self, admin_url=False):
i = self.tree()
prefix = '/admin' if admin_url else ''
ja_tree = {'name': i[0].pref_label, 'children': []}
for jdx, j in enumerate(
i[1]): #j[0] is a concept, j[1] a list of child concepts
ja_tree['children'].append({
'name':
j[0].pref_label,
'url':
prefix + '/skosxl/concept/' + str(j[0].id) + '/',
'children': []
})
for kdx, k in enumerate(j[1]):
ja_tree['children'][jdx]['children'].append({
'name':
k[0].pref_label,
'url':
prefix + '/skosxl/concept/' + str(k[0].id) + '/',
'children': []
})
for ldx, l in enumerate(k[1]):
ja_tree['children'][jdx]['children'][kdx][
'children'].append({
'name':
l[0].pref_label,
'url':
prefix + '/skosxl/concept/' + str(l[0].id) + '/',
'children': []
})
for mdx, m in enumerate(l[1]):
ja_tree['children'][jdx]['children'][kdx]['children'][
ldx]['children'].append({
'name':
m[0].pref_label,
'url':
prefix + '/skosxl/concept/' + str(m[0].id) +
'/',
#'children':[] #stop
})
return json.dumps(ja_tree)
class Concept(models.Model):
objects = ConceptManager()
# this will be the
term = models.CharField(_(u'term'), blank=True, null=True, max_length=255)
# not sure we will need this - SKOS names should enforce slug compatibility.
slug = exfields.AutoSlugField(populate_from=('term'))
pref_label = models.CharField(_(u'preferred label'),
blank=True,
null=True,
max_length=255)
definition = models.TextField(_(u'definition'), blank=True)
# notation = models.CharField(blank=True, null=True, max_length=100)
scheme = models.ForeignKey(Scheme, blank=True, null=True)
changenote = models.TextField(_(u'change note'), blank=True)
created = exfields.CreationDateTimeField(_(u'created'))
modified = exfields.ModificationDateTimeField(_(u'modified'))
status = models.PositiveSmallIntegerField(_(u'review status'),
choices=REVIEW_STATUS,
default=REVIEW_STATUS.active)
user = models.ForeignKey(settings.AUTH_USER_MODEL,
blank=True,
null=True,
verbose_name=_(u'django user'),
editable=False)
uri = models.CharField(blank=True,
max_length=250,
verbose_name=_(u'main URI'),
editable=False)
author_uri = models.CharField(blank=True,
max_length=250,
verbose_name=_(u'main URI'),
editable=False)
top_concept = models.BooleanField(default=False,
verbose_name=_(u'is top concept'))
sem_relatons = models.ManyToManyField(
"self",
symmetrical=False,
through='SemRelation',
verbose_name=(_(u'semantic relations')))
def __unicode__(self):
return "/".join(self.natural_key())
def natural_key(self):
return (
self.scheme.natural_key(),
self.term,
)
natural_key.dependencies = ['scheme']
def get_absolute_url(self):
return reverse('concept_detail', args=[self.id])
def save(self, skip_name_lookup=False, *args, **kwargs):
if self.scheme is None:
self.scheme = Scheme.objects.get(slug=DEFAULT_SCHEME_SLUG)
if not skip_name_lookup: #updating the pref_label
try:
lookup_label = self.labels.get(
language=DEFAULT_LANG, label_type=LABEL_TYPES.prefLabel)
label = lookup_label.label_text
except Label.DoesNotExist:
label = '< no label >'
self.pref_label = label
#self.save(skip_name_lookup=True)
super(Concept, self).save(*args, **kwargs)
def get_narrower_concepts(self):
childs = []
if SemRelation.objects.filter(origin_concept=self,
rel_type=1).exists():
for narrower in SemRelation.objects.filter(origin_concept=self,
rel_type=1):
childs.append(
(narrower.target_concept,
narrower.target_concept.get_narrower_concepts()))
return childs
def get_related_term(self, ns):
"""
dumb - just finds first related term - assumes a 1:1 skos:closeMatch semantics
"""
mr = MapRelation.objects.filter(origin_concept=self,
uri__startswith=ns)
if mr:
return (mr[0].uri[mr[0].uri.rfind('/') + 1:])
return None
class Meta:
unique_together = (('scheme', 'term'), )
class node(PolymorphicMPTTModel, statusMixin):
ICONS = [
("twitter-square", "Twitter"),
("facebook-square", "Facebook"),
("instagram", "Instagram"),
("linkedin-square", "LinkedIn"),
]
parent = PolymorphicTreeForeignKey(
"self",
blank=True,
null=True,
related_name="children",
verbose_name=_("parent"),
on_delete=models.SET_NULL,
)
title = models.CharField(_("Title"), max_length=200)
nav_title = models.CharField(_("Navigation Title"),
max_length=200,
blank=True,
default="")
nav_icon = models.CharField(_("Navigation Icon"),
choices=ICONS,
max_length=200,
blank=True,
default="")
nav_icon_only = models.BooleanField(_("Icon Only"), default=False)
slug = fields.AutoSlugField(populate_from="title")
title_tag = models.CharField(_("Title Tag"),
max_length=200,
blank=True,
default="")
meta_description = models.TextField(blank=True, default="")
active_url_helper = models.CharField(max_length=255,
blank=True,
default="")
is_home_page = models.BooleanField(default=False)
created = fields.CreationDateTimeField()
modified = fields.ModificationDateTimeField()
class Meta(PolymorphicMPTTModel.Meta):
verbose_name = _("Site node")
verbose_name_plural = _("Site nodes")
def __str__(self):
return self.title
@property
def url(self):
if self.is_home_page:
return "/"
try:
url = reverse(f"pages:{self.__class__.__name__.lower()}",
kwargs={"slug": self.slug})
except BaseException:
url = reverse("pages:page", kwargs={"slug": self.slug})
return url
def nav_class(self):
classes = [self.__class__.__name__]
if self.nav_icon:
classes.append(f"icon-{str(self.nav_icon)}")
if self.nav_icon_only:
classes.append("icon-only")
return " ".join(classes)
@property
def nav_title_actual(self):
return self.nav_title or self.title
def save(self, *args, **kwargs):
if self.is_home_page:
try:
temp = node.objects.get(is_home_page=True)
if self != temp:
temp.is_home_page = False
temp.save()
except node.DoesNotExist:
pass
super().save(*args, **kwargs)
@staticmethod
def get_nav_tree():
pass
class Timestampable(models.Model):
class Meta:
abstract = True
created = fields.CreationDateTimeField()
modified = fields.ModificationDateTimeField()
class Concept(models.Model):
objects = ConceptManager()
# this will be the
term = models.CharField(
_(u'term'),
help_text=
_(u'Required - must be valid SKOS term - ie. a URL-friendly QNAME - TODO include validation for this.'
),
blank=True,
null=True,
max_length=255)
# not sure we will need this - SKOS names should enforce slug compatibility.
slug = exfields.AutoSlugField(populate_from=('term'))
pref_label = models.CharField(
_(u'preferred label'),
blank=True,
null=True,
help_text=
_(u'Will be automatically set to the preferred label in the default language - which will be automatically created using this field only if not present'
),
max_length=255)
definition = models.TextField(_(u'definition'), blank=True)
# notation = models.CharField(blank=True, null=True, max_length=100)
scheme = models.ForeignKey(
Scheme,
blank=True,
null=True,
help_text=_(
u'Note - currently only membership of a single scheme supported'))
changenote = models.TextField(_(u'change note'), blank=True)
created = exfields.CreationDateTimeField(_(u'created'))
modified = exfields.ModificationDateTimeField(_(u'modified'))
status = models.PositiveSmallIntegerField(_(u'review status'),
choices=REVIEW_STATUS,
default=REVIEW_STATUS.active)
user = models.ForeignKey(settings.AUTH_USER_MODEL,
blank=True,
null=True,
verbose_name=_(u'django user'),
editable=False)
uri = models.CharField(
blank=True,
max_length=250,
verbose_name=_(u'main URI'),
editable=True,
help_text=_(
u'Leave blank to inherit namespace from containing scheme'))
author_uri = models.CharField(blank=True,
max_length=250,
verbose_name=_(u'main URI'),
editable=False)
top_concept = models.BooleanField(default=False,
verbose_name=_(u'is top concept'))
sem_relations = models.ManyToManyField(
"self",
symmetrical=False,
through='SemRelation',
verbose_name=(_(u'Semantic relations')),
help_text=
_(u'SKOS semantic relations are links between SKOS concepts, where the link is inherent in the meaning of the linked concepts.'
))
# map_relations = models.OneToManyField( "self",symmetrical=False,
# through='MapRelation',
# verbose_name=(_(u'semantic relations'))
# ,
# help_text=_(u'These properties are used to state mapping (alignment) links between SKOS concepts in different concept schemes'))
def __unicode__(self):
return "".join((self.pref_label, " (", self.uri, ")"))
def natural_key(self):
return (self.uri)
# natural_key.dependencies = ['scheme']
def get_absolute_url(self):
"""
URL of the representation document generated by Django - note this is not the same as the uri based on a term within a scheme
"""
return reverse('concept_detail', args=[self.id])
def save(self, skip_name_lookup=False, *args, **kwargs):
# import pdb; pdb.set_trace()
if self.scheme is None:
self.scheme = Scheme.objects.get(slug=DEFAULT_SCHEME_SLUG)
if not self.term:
if not self.uri:
raise ValidationError("Term or URI must be present")
try:
term = self.uri[self.uri.rindex('#') + 1:]
except:
term = self.uri[self.uri.rindex('/') + 1:]
self.term = term
if not skip_name_lookup: #updating the pref_label
try:
lookup_label = self.labels.get(
language=DEFAULT_LANG, label_type=LABEL_TYPES.prefLabel)
label = lookup_label.label_text
except Label.DoesNotExist:
if not self.pref_label or self.pref_label == PLACEHOLDER:
label = PLACEHOLDER
else:
label = self.pref_label
self.pref_label = label
#self.save(skip_name_lookup=True)
if not self.uri:
if self.scheme.uri[:-1] in ('#', '/'):
sep = self.scheme.uri[:-1]
else:
sep = '/'
print "sep", sep, "suri", self.scheme.uri
self.uri = sep.join((self.scheme.uri, self.term))
super(Concept, self).save(*args, **kwargs)
#now its safe to add new label to the concept for the prefLabel
if self.pref_label and not self.pref_label == PLACEHOLDER:
try:
lookup_label = self.labels.get(
language=DEFAULT_LANG, label_type=LABEL_TYPES.prefLabel)
except Label.DoesNotExist:
Label.objects.create(concept=self,
language=DEFAULT_LANG,
label_type=LABEL_TYPES.prefLabel,
label_text=self.pref_label)
def get_narrower_concepts(self):
childs = []
if SemRelation.objects.filter(origin_concept=self,
rel_type=1).exists():
for narrower in SemRelation.objects.filter(origin_concept=self,
rel_type=1):
childs.append(
(narrower.target_concept,
narrower.target_concept.get_narrower_concepts()))
return childs
def get_related_term(self, ns):
"""
dumb - just finds first related term - assumes a 1:1 skos:closeMatch semantics
"""
mr = MapRelation.objects.filter(origin_concept=self,
uri__startswith=ns)
if mr:
return (mr[0].uri[mr[0].uri.rfind('/') + 1:])
return None
class Meta:
unique_together = (('scheme', 'term'), )
class Paste(models.Model):
class Meta:
verbose_name = "Paste"
verbose_name_plural = "Pastes"
ordering = ['-created']
TEN_MINUTES = 10 * 60
HALF_OF_AN_HOUR = 3 * TEN_MINUTES
DAY = 48 * HALF_OF_AN_HOUR
WEEK = 7 * DAY
INFINITE = 0
EVERYONE_WITH_LINK = 'link'
ONLY_SPECIFIED_USERS = 'users'
EXPIRATIONS = ((INFINITE, 'Infinite'), (TEN_MINUTES, '10 minutes'),
(HALF_OF_AN_HOUR,
'30 minutes'), (DAY, '24 hours'), (WEEK, 'a week'))
VISIBILITY = (
(EVERYONE_WITH_LINK, 'Everybody with a link'),
(ONLY_SPECIFIED_USERS, 'Only specified users'),
)
objects = PassThroughManager.for_queryset_class(PasteQuerySet)()
title = models.CharField(max_length=64,
blank=True,
null=True,
default="Unnamed")
content = models.TextField()
hash = models.SlugField()
author = models.ForeignKey(User)
syntax = models.ForeignKey(Syntax)
users = models.ManyToManyField(User,
related_name='users',
blank=True,
null=True)
visibility = models.CharField(choices=VISIBILITY,
default=EVERYONE_WITH_LINK,
max_length=12)
expires_in = models.PositiveIntegerField(choices=EXPIRATIONS,
default=INFINITE)
created = fields.CreationDateTimeField()
modified = fields.ModificationDateTimeField()
def __unicode__(self):
return self.title
def expires(self):
return self.created + datetime.timedelta(seconds=self.expires_in)
def expired(self):
return timezone.now() > self.expires()
def visible_to(self, visibility):
return self.visibility == visibility
def is_allowed(self, user):
if user == self.author:
return True
return user in self.users
def save(self, *args, **kwargs):
"""
Overridden save method.
If the model is yet to be saved, theres the title's hash generated.
"""
if not self.id:
self.hash = create_paste_hash(Paste, self.title)
super(Paste, self).save(*args, **kwargs)
class Location(MPTTModel):
"""Core Location model
HP - Health Post (POSTO DE SAÚDE POS)
OTHER - Other Clinic/TB treatment center (DISPENSÁRIO ANTI TUBERCULOSE
OUTRO)
CH - Central Hospital - Pediatric, Mental, Provincial Hospital (HOSPITAL
CENTRAL HP)
HOS - Hospital
MH - Mental Hospital (Special Hospital HN/HC)
MC - Maternity Center (CENTRO MATERNO INFANTIL CMI)
HC - Health Center (CENTRO DE SAÚDE CEN)
WH - Warehouse
"""
FACTYPES = (
('HP', _('Health Post')),
('MH', _('Mental Hospital')),
('MC', _('Maternity Center')),
('HC', _('Health Center')),
('CH', _('Central Hospital')),
('HOS', _('Hospital')),
('WH', _('Warehouse')),
('OTHER', _('Other')),
)
parent = TreeForeignKey('self',
null=True,
blank=True,
related_name='children')
name = models.CharField(max_length=100, default=_('Unknown Name'))
alt_names = models.CharField(
max_length=150,
blank=True,
null=True,
help_text=_('List of Alternate Place Names separated by (|)'))
hcid = models.CharField(max_length=16,
db_index=True,
null=True,
unique=True,
blank=True,
help_text='Unique ID: AABBCC##')
srcid = models.CharField(
max_length=75,
db_index=True,
blank=True,
null=True,
help_text=_('Code provided from source agency. HASC for GADM shapes.'))
loc_type = models.ForeignKey(LocationType)
fac_type = models.CharField(max_length=5,
choices=FACTYPES,
null=True,
blank=True)
slug = ext_fields.AutoSlugField(populate_from='hcid',
unique=True,
max_length=16)
uuid = ext_fields.UUIDField()
created_at = ext_fields.CreationDateTimeField()
updated_at = ext_fields.ModificationDateTimeField()
class MPTTMeta:
order_insertion_by = ['hcid']
@classmethod
def root(cls):
obj = None
root_loc_type = LocationType.root()
try:
obj = cls.objects.get(loc_type=root_loc_type)
except cls.DoesNotExist:
pass
return obj
@classmethod
def get_by_code(cls, code):
obj = None
try:
obj = cls.objects.get(hcid__iexact=code)
except cls.DoesNotExist:
return obj
return obj
@classmethod
def get_sites(cls, queryset=None):
if queryset is None:
queryset = cls.objects.all()
site_type = LocationType.get_site_type()
if site_type is None:
_logger.warning('No code for the site location type defined.')
return []
else:
return queryset.filter(loc_type=site_type)
def get_site_descendants(self):
sites = Location.get_sites(self.get_descendants(True))
return sites
def active_site_count(self, program, year):
sites = self.get_site_descendants()
if year is None or year == date.today().year:
return LocationProgramState.objects.filter(
program=program,
site__in=sites,
current_state__startswith='ACTIVE').count()
else:
return ProgramReport.objects.filter(
program=program, report_date__year=year,
site__in=sites).order_by('site').distinct('site').count()
def inactive_site_count(self, program, year):
sites = self.get_site_descendants()
if year is None or year == date.today().year:
return LocationProgramState.objects.filter(
program=program,
site__in=sites,
current_state__startswith='INACTIVE').count()
else:
return self.reporting_site_count(
program, year) - self.active_site_count(program, year)
def reporting_site_count(self, program, year):
sites = self.get_site_descendants()
if year is None or year == 0 or year == date.today().year:
return LocationProgramState.objects.filter(
program=program,
site__in=sites).exclude(current_state='OUT').count()
else:
return ProgramReport.objects.filter(
program=program,
report_date__lte='{:04d}-12-31'.format(year),
site__in=sites).order_by('site').distinct('site').count()
@classmethod
def get_location_choices(cls, type_code_exclude_list=None):
qs = cls.objects.select_related('loc_type')
if type_code_exclude_list:
qs = qs.exclude(loc_type__code__in=type_code_exclude_list)
displayed_locations = qs.values('pk', 'name', 'loc_type__name')
filter_locations = {}
for loc_data in displayed_locations:
filter_locations.setdefault(loc_data['loc_type__name'], []).append(
(loc_data['pk'], loc_data['name']))
return [['', '']] + [[loc_type, filter_locations[loc_type]]
for loc_type in filter_locations.keys()]
def __str__(self):
return smart_text(self.name)
def __unicode__(self):
return self.__str__
@property
def location_breadcrumb(self):
return ' > '.join(
str(loc.name) for loc in self.get_ancestors(include_self=True))
def location_path(self, include_self=False):
path = list(
self.get_ancestors(include_self).values_list('name', flat=True))
path.reverse()
return ', '.join(path[:-1])
@property
def geom(self):
try:
return self.location_gadm.geom
except Gadm.DoesNotExist:
try:
return self.location_pnt.geom
except SiteLocation.DoesNotExist:
return None
@property
def is_site(self):
site_type = LocationType.get_site_type()
return self.loc_type == site_type
@property
def printable_programmes(self):
return ', '.join(
self.site_programs.values_list('description', flat=True))
