def __get__(self, instance, owner):
# mongoengine calls this after document initialization
# We register signals handlers here to have a owner reference
if not hasattr(self, 'owner'):
self.owner = owner
pre_save.connect(self.populate_on_pre_save, sender=owner)
if self.follow:
post_delete.connect(self.cleanup_on_delete, sender=owner)
return super(SlugField, self).__get__(instance, owner)
def __get__(self, instance, owner):
# mongoengine calls this after document initialization
# We register signals handlers here to have a owner reference
if not hasattr(self, 'owner'):
self.owner = owner
pre_save.connect(self.populate_on_pre_save, sender=owner)
if self.follow:
post_delete.connect(self.cleanup_on_delete, sender=owner)
return super(SlugField, self).__get__(instance, owner)
author = None
if author:
result['author'] = author
return result
@property
def views_count(self):
return self.metrics.get('views', 0)
def count_datasets(self):
self.metrics['datasets'] = len(self.datasets)
self.save(signal_kwargs={'ignores': ['post_save']})
def count_discussions(self):
from udata.models import Discussion
self.metrics['discussions'] = Discussion.objects(subject=self,
closed=None).count()
self.save()
def count_followers(self):
from udata.models import Follow
self.metrics['followers'] = Follow.objects(
until=None).followers(self).count()
self.save()
pre_save.connect(Reuse.pre_save, sender=Reuse)
post_save.connect(Reuse.post_save, sender=Reuse)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = render_to_string('registration/email/activate_email.txt',
c)
send_mail(subject, email, None, [self.email])
return True
def activate(self, activation_key, save=True):
if self.activation_key != activation_key:
return False
if self.activation_due < datetime.utcnow():
return False
if self.is_active:
return False
self.is_active = True
if save:
self.save()
return True
def has_usable_password(self):
"""Dummy method for django.contrib.auth.forms.PasswordResetForm
compatibility
"""
return True
pre_save.connect(User.ensure_inactive, User)
result['license'] = self.license.url
if self.organization:
author = self.organization.json_ld
elif self.owner:
author = self.owner.json_ld
else:
author = None
if author:
result['author'] = author
return result
pre_save.connect(Dataset.pre_save, sender=Dataset)
post_save.connect(Dataset.post_save, sender=Dataset)
class CommunityResource(ResourceMixin, WithMetrics, db.Owned, db.Document):
'''
Local file, remote file or API added by the community of the users to the
original dataset
'''
dataset = db.ReferenceField(Dataset, reverse_delete_rule=db.NULLIFY)
meta = {
'ordering': ['-created_at'],
'queryset_class': db.OwnedQuerySet,
}
def ready(self):
from .models import Location
pre_save.connect(receiver=Location.update_modified, sender=Location)
def clear_api_key(self):
self.apikey = None
@classmethod
def get(cls, id_or_slug):
obj = cls.objects(slug=id_or_slug).first()
return obj or cls.objects.get_or_404(id=id_or_slug)
@classmethod
def pre_save(cls, sender, document, **kwargs):
cls.before_save.send(document)
@classmethod
def post_save(cls, sender, document, **kwargs):
cls.after_save.send(document)
if kwargs.get('created'):
cls.on_create.send(document)
else:
cls.on_update.send(document)
datastore = MongoEngineUserDatastore(db, User, Role)
pre_save.connect(User.pre_save, sender=User)
post_save.connect(User.post_save, sender=User)
class FollowUser(Follow):
following = db.ReferenceField(User)
def __str__(self):
return self.title
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.title = document.title.capitalize()
document.description = document.description.capitalize()
document.location = document.location.title()
document.landmark = document.landmark.title()
document.city = document.city.title()
if not document.slug:
document.slug = slugify(document.title)
pre_save.connect(Event.pre_save, sender=Event)
class Channel(Document):
title = fields.StringField(max_lenght=100, blank=False)
slug = fields.StringField(max_lenght=150, blank=False)
platform = fields.StringField(default="Swachhata",
choices=['Swachhata', 'ICMYC'])
app_name = fields.StringField(blank=False)
type = fields.StringField(blank=False)
archived = fields.BooleanField(default=False)
created_at = fields.DateTimeField(default=datetime.datetime.now)
updated_at = fields.DateTimeField()
meta = {'collection': 'channels'}
return chain(
*[dataset.check_availability()
for dataset in Dataset.objects(organization=self).visible()[:20]]
)
@cached_property
def json_ld(self):
type_ = 'GovernmentOrganization' if self.public_service \
else 'Organization'
result = {
'@context': 'http://schema.org',
'@type': type_,
'alternateName': self.slug,
'url': url_for('organizations.show', org=self, _external=True),
'name': self.name,
}
if self.description:
result['description'] = mdstrip(self.description)
logo = self.logo(external=True)
if logo:
result['logo'] = logo
return result
pre_save.connect(Organization.pre_save, sender=Organization)
post_save.connect(Organization.post_save, sender=Organization)
def clear_api_key(self):
self.apikey = None
@classmethod
def get(cls, id_or_slug):
obj = cls.objects(slug=id_or_slug).first()
return obj or cls.objects.get_or_404(id=id_or_slug)
@classmethod
def pre_save(cls, sender, document, **kwargs):
cls.before_save.send(document)
@classmethod
def post_save(cls, sender, document, **kwargs):
cls.after_save.send(document)
if kwargs.get('created'):
cls.on_create.send(document)
else:
cls.on_update.send(document)
datastore = MongoEngineUserDatastore(db, User, Role)
pre_save.connect(User.pre_save, sender=User)
post_save.connect(User.post_save, sender=User)
class FollowUser(Follow):
following = db.ReferenceField(User)
'''Auto populate urlhash from url'''
if not self.urlhash or 'url' in self._get_changed_fields():
self.urlhash = hash_url(self.url)
super(Reuse, self).clean()
@classmethod
def get(cls, id_or_slug):
obj = cls.objects(slug=id_or_slug).first()
return obj or cls.objects.get_or_404(id=id_or_slug)
@classmethod
def url_exists(cls, url):
urlhash = hash_url(url)
return cls.objects(urlhash=urlhash).count() > 0
pre_save.connect(Reuse.pre_save, sender=Reuse)
post_save.connect(Reuse.post_save, sender=Reuse)
class ReuseIssue(Issue):
subject = db.ReferenceField(Reuse)
class ReuseDiscussion(Discussion):
subject = db.ReferenceField(Reuse)
class FollowReuse(Follow):
following = db.ReferenceField(Reuse)
return result
@property
def views_count(self):
return self.metrics.get('views', 0)
def count_members(self):
self.metrics['members'] = len(self.members)
self.save()
def count_datasets(self):
from udata.models import Dataset
self.metrics['datasets'] = Dataset.objects(
organization=self).visible().count()
self.save()
def count_reuses(self):
from udata.models import Reuse
self.metrics['reuses'] = Reuse.objects(organization=self).count()
self.save()
def count_followers(self):
from udata.models import Follow
self.metrics['followers'] = Follow.objects(
until=None).followers(self).count()
self.save()
pre_save.connect(Organization.pre_save, sender=Organization)
post_save.connect(Organization.post_save, sender=Organization)
height = DecimalField(required=True, default=0, precision=1)
heightUnit = StringField(required=True,
default='cm') # choices=['cm', 'm', 'ft'])
foodPreference = StringField(
required=True, default='Vegetarian'
) # choices=['Vegan', 'Vegetarian', 'Non-Vegetarian'])
timeZone = StringField(default='0') # Timezone Offset Value
bmi = IntField(default=0)
medicalCondition = StringField()
targetWeight = IntField(default=0)
targetDate = StringField(default='') # YYYY/MM/DD format
targetCalories = IntField(default=0)
accountCreationDate = DateTimeField(default=datetime.utcnow())
userPhoto = StringField(default='')
messages = ListField(EmbeddedDocumentField(Messages))
mealAssigned = ListField(ReferenceField(Meal))
mealExpiry = DateTimeField()
unreadCount = IntField(default=0)
@staticmethod
def pre_save_func(sender, document):
document['password'] = bcrypt.generate_password_hash(
document['password'])
dob = parser.parse(document['dateOfBirth'])
today = datetime.today()
age = relativedelta.relativedelta(today, dob)
document['age'] = age.years
pre_save.connect(User.pre_save_func, sender=User)
'registration/email/activate_subject.txt', c)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
email = render_to_string(
'registration/email/activate_email.txt', c)
send_mail(subject, email, None, [self.email])
return True
def activate(self, activation_key, save=True):
if self.activation_key != activation_key:
return False
if self.activation_due < datetime.utcnow():
return False
if self.is_active:
return False
self.is_active = True
if save:
self.save()
return True
def has_usable_password(self):
"""Dummy method for django.contrib.auth.forms.PasswordResetForm
compatibility
"""
return True
pre_save.connect(User.ensure_inactive, User)
