def __new__(cls, name, bases, attrs):
new_class = super(EmitNewActivityMetaClass, cls).__new__(
cls, name, bases, attrs)
if new_class.key:
post_save.connect(cls.post_save, sender=new_class)
_registered_activities[new_class.key] = new_class
return new_class
def __new__(cls, name, bases, attrs):
new_class = super(EmitNewActivityMetaClass, cls).__new__(
cls, name, bases, attrs)
if new_class.key:
post_save.connect(cls.post_save, sender=new_class)
_registered_activities[new_class.key] = new_class
return new_class
def register(adapter):
'''Register a search adapter'''
# register the class in the catalog
if adapter.model and adapter.model not in adapter_catalog:
adapter_catalog[adapter.model] = adapter
# Automatically reindex objects on save
post_save.connect(reindex_model_on_save, sender=adapter.model)
return adapter
def __new__(cls, name, bases, attrs):
# Ensure any child class dispatch the signals
adapter = super(SearchAdapterMetaClass, cls).__new__(cls, name, bases, attrs)
# register the class in the catalog
if adapter.model and adapter.model not in adapter_catalog:
adapter_catalog[adapter.model] = adapter
# Automatically reindex objects on save
post_save.connect(reindex_model_on_save, sender=adapter.model)
return adapter
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)
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,
}
@property
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)
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)
else:
st = "%s %s" % (self.street.short_name, self.street.name)
else:
st = self.street.name
n += ["%s %s" % (st, " ".join(a))]
else:
n += [" ".join(a)]
if levels or to_level is not None:
if to_level is not None:
levels = 10
p = self.building.adm_division
while p and levels:
if to_level is not None and p.level == to_level:
break
if p.short_name:
n = ["%s %s" % (p.short_name, p.name)] + n
else:
n = [p.name] + n
p = p.parent
levels -= 1
return sep.join(n)
# @todo: cmp_addr
#
RU_SHORT_AFTER = {"б-р", "проезд", "пер", "ш"}
# Signals
post_save.connect(Address.update_primary, sender=Address)
resolve_user(notification.sender)
notification.save(
) # MongoEngine takes care of dirty flags, it will only update if changed.
received_notifications = BaseNotification.objects(
__raw__={
'receiver._cls': PlayerTarget._class_name,
'receiver.player': document.minecraft_player.id,
'receiver.user': {
'$ne': document.id
}
})
for notification in received_notifications:
resolve_user(notification.sender)
notification.save(
) # MongoEngine takes care of dirty flags, it will only update if changed.
post_save.connect(handle_user_update, sender=User)
class PMNotification(BaseNotification):
deletable = BooleanField(default=True)
source = StringField()
message = StringField(required=True)
def render_notification_listing(self):
return render_template('notification_list_entry_pm.html',
notification=self)
def __new__(cls, name, bases, attrs):
new_class = super(EmitNewActivityMetaClass, cls).__new__(cls, name, bases, attrs)
post_save.connect(cls.post_save, sender=new_class)
return new_class
def handle_user_update(sender, document, created):
sent_notifications = BaseNotification.objects(__raw__={
'sender._cls': PlayerTarget._class_name,
'sender.player': document.minecraft_player.id,
'sender.user': {'$ne': document.id}
})
for notification in sent_notifications:
resolve_user(notification.sender)
notification.save() # MongoEngine takes care of dirty flags, it will only update if changed.
received_notifications = BaseNotification.objects(__raw__={
'receiver._cls': PlayerTarget._class_name,
'receiver.player': document.minecraft_player.id,
'receiver.user': {'$ne': document.id}
})
for notification in received_notifications:
resolve_user(notification.sender)
notification.save() # MongoEngine takes care of dirty flags, it will only update if changed.
post_save.connect(handle_user_update, sender=User)
class PMNotification(BaseNotification):
deletable = BooleanField(default=True)
source = StringField()
message = StringField(required=True)
def render_notification_listing(self):
return render_template('notification_list_entry_pm.html', notification=self)
import uuid
from mongoengine.django.auth import User
from mongoengine.signals import post_save
import auth.documents
def create_api_key(sender, document, created):
if created == True:
key = unicode(uuid.uuid4())
api_key = auth.documents.ApiKey(user=document, key=key, domains=[])
api_key.save()
post_save.connect(create_api_key, sender=User)
