def get_context(self):
        context = super(OrganizationDashboardView, self).get_context()

        context['metrics'] = [{
            # 'title': _('Data'),
            'widgets': [
                {
                    'title': _('Datasets'),
                    'metric': 'datasets',
                    'type': 'line',
                    'endpoint': 'datasets.list',
                    'args': {'org': self.organization}
                },
                {
                    'title': _('Reuses'),
                    'metric': 'reuses',
                    'type': 'line',
                    'endpoint': 'reuses.list',
                    'args': {'org': self.organization}
                },
                {
                    'title': _('Followers'),
                    'metric': 'followers',
                    'type': 'line',
                }
            ]
        }]

        return context

def notify_membership_response(org, request):
    if request.status == "accepted":
        subject = _('You are now a member of the organization "%(org)s"', org=org)
        template = "new_member"
    else:
        subject, template = _("Membership refused"), "membership_refused"
    mail.send(subject, request.user, template, org=org, request=request)

def notify_membership_response(org, request):
    if request.status == 'accepted':
        subject, template = _(
            'You are now a member of the organization "%(org)s"', org=org),
        'new_member'
    else:
        subject, template = _('Membership refused'), 'membership_refused'
    mail.send(subject, request.user, template, org=org, request=request)

 def pre_validate(self, form):
     if self.data:
         if current_user.is_anonymous():
             raise validators.ValidationError(
                 _('You must be authenticated'))
         elif not admin_permission and current_user.id != self.data.id:
             raise validators.ValidationError(
                 _('You can only set yourself as owner'))
     return True

    def test_labelize(self):
        self.assertEqual(self.facet.labelize('label', True),
                         'label: {0}'.format(_('yes')))
        self.assertEqual(self.facet.labelize('label', False),
                         'label: {0}'.format(_('no')))

        self.assertEqual(self.facet.labelize('label', 'true'),
                         'label: {0}'.format(_('yes')))
        self.assertEqual(self.facet.labelize('label', 'false'),
                         'label: {0}'.format(_('no')))

 def pre_validate(self, form):
     if not self.data:
         return
     for tag in self.data:
         if not MIN_TAG_LENGTH <= len(tag) <= MAX_TAG_LENGTH:
             message = _('Tag "%(tag)s" must be between %(min)d and %(max)d characters long.',
                 min=MIN_TAG_LENGTH, max=MAX_TAG_LENGTH, tag=tag)
             raise validators.ValidationError(message)
         if not RE_TAG.match(tag):
             message = _('Tag "%(tag)s" must be alphanumeric characters or symbols: -_.', tag=tag)
             raise validators.ValidationError(message)

def notify_new_follower(follow):
    if isinstance(follow.following, User):
        subject =_('%(user)s followed you', user=follow.follower)
        mail.send(subject, follow.following, 'new_follower', follow=follow)
    elif isinstance(follow.following, Organization):
        subject = _('%(user)s followed your organization', user=follow.follower)
        recipients = [m.user for m in follow.following.members]
        mail.send(subject, recipients, 'new_follower_org', follow=follow)
    elif isinstance(follow.following, Dataset):
        pass
    elif isinstance(follow.following, Reuse):
        pass

 def pre_validate(self, form):
     if self.data:
         try:
             uris.validate(self.data)
         except uris.ValidationError:
             raise validators.ValidationError(_('Invalid URL'))
     return True

def recent_feed():
    feed = AtomFeed(_('Last datasets'),
                    feed_url=request.url, url=request.url_root)
    datasets = (Dataset.objects.visible().order_by('-created_at')
                .limit(current_site.feed_size))
    for dataset in datasets:
        author = None
        if dataset.organization:
            author = {
                'name': dataset.organization.name,
                'uri': url_for('organizations.show',
                               org=dataset.organization.id, _external=True),
            }
        elif dataset.owner:
            author = {
                'name': dataset.owner.fullname,
                'uri': url_for('users.show',
                               user=dataset.owner.id, _external=True),
            }
        feed.add(dataset.title,
                 render_template('dataset/feed_item.html', dataset=dataset),
                 content_type='html',
                 author=author,
                 url=url_for('datasets.show',
                             dataset=dataset.id, _external=True),
                 updated=dataset.last_modified,
                 published=dataset.created_at)
    return feed.get_response()

    def get(self, level):
        '''List each zone for a given level with their datasets count'''
        level = GeoLevel.objects.get_or_404(id=level)
        features = []

        for zone in GeoZone.objects(level=level.id):
            # fetch nested levels IDs
            ids = GeoZone.objects(parents=zone.id).only('id').distinct('id')
            ids.append(zone.id)
            # Count datasets in zone
            nb_datasets = Dataset.objects(spatial__zones__in=ids).count()
            features.append({
                'id': zone.id,
                'type': 'Feature',
                'geometry': zone.geom,
                'properties': {
                    'name': _(zone.name),
                    'code': zone.code,
                    'level': zone.level,
                    'datasets': nb_datasets
                }
            })

        return {
            'type': 'FeatureCollection',
            'features': features
        }

def notify_new_issue(issue):
    if isinstance(issue.subject, (Dataset, Reuse)):
        recipients = owner_recipients(issue)
        subject = _('Your %(type)s have a new issue', type=issue.subject.verbose_name)
        mail.send(subject, recipients, 'new_issue', issue=issue)
    else:
        log.warning('Unrecognized issue subject type %s', type(issue.subject))

 def mark_as_deleted(self):
     copied_user = copy(self)
     self.email = '{}@deleted'.format(self.id)
     self.password = None
     self.active = False
     self.first_name = 'DELETED'
     self.last_name = 'DELETED'
     self.avatar = None
     self.avatar_url = None
     self.website = None
     self.about = None
     self.extras = None
     self.deleted = datetime.now()
     self.save()
     for organization in self.organizations:
         organization.members = [member
                                 for member in organization.members
                                 if member.user != self]
         organization.save()
     for discussion in Discussion.objects(discussion__posted_by=self):
         for message in discussion.discussion:
             if message.posted_by == self:
                 message.content = 'DELETED'
         discussion.save()
     Follow.objects(follower=self).delete()
     Follow.objects(following=self).delete()
     mail.send(_('Account deletion'), copied_user, 'account_deleted')

def recent_feed():
    feed = AtomFeed(_('Last reuses'),
                    feed_url=request.url, url=request.url_root)
    reuses = Reuse.objects.visible().order_by('-created_at').limit(15)
    for reuse in reuses:
        author = None
        if reuse.organization:
            author = {
                'name': reuse.organization.name,
                'uri': url_for('organizations.show',
                               org=reuse.organization.id, _external=True),
            }
        elif reuse.owner:
            author = {
                'name': reuse.owner.fullname,
                'uri': url_for('users.show',
                               user=reuse.owner.id, _external=True),
            }
        feed.add(reuse.title,
                 render_template('reuse/feed_item.html', reuse=reuse),
                 content_type='html',
                 author=author,
                 url=url_for('reuses.show', reuse=reuse.id, _external=True),
                 updated=reuse.created_at,
                 published=reuse.created_at)
    return feed.get_response()

def send_frequency_reminder(self):
    # We exclude irrelevant frequencies.
    frequencies = [f for f in UPDATE_FREQUENCIES.keys()
                   if f not in ('unknown', 'realtime', 'punctual')]
    now = datetime.now()
    reminded_orgs = {}
    reminded_people = []
    allowed_delay = current_app.config['DELAY_BEFORE_REMINDER_NOTIFICATION']
    for org in Organization.objects.visible():
        outdated_datasets = []
        for dataset in Dataset.objects.filter(
                frequency__in=frequencies, organization=org).visible():
            if dataset.next_update + timedelta(days=allowed_delay) < now:
                dataset.outdated = now - dataset.next_update
                dataset.frequency_str = UPDATE_FREQUENCIES[dataset.frequency]
                outdated_datasets.append(dataset)
        if outdated_datasets:
            reminded_orgs[org] = outdated_datasets
    for reminded_org, datasets in reminded_orgs.iteritems():
        print(u'{org.name} will be emailed for {datasets_nb} datasets'.format(
              org=reminded_org, datasets_nb=len(datasets)))
        recipients = [m.user for m in reminded_org.members]
        reminded_people.append(recipients)
        subject = _('You need to update some frequency-based datasets')
        mail.send(subject, recipients, 'frequency_reminder',
                  org=reminded_org, datasets=datasets)

    print('{nb_orgs} orgs concerned'.format(nb_orgs=len(reminded_orgs)))
    reminded_people = flatten(reminded_people)
    print('{nb_emails} people contacted ({nb_emails_twice} twice)'.format(
        nb_emails=len(reminded_people),
        nb_emails_twice=len(reminded_people) - len(Set(reminded_people))))
    print('Done')

 def iter_choices(self):
     localized_choices = [
         (value, _(label) if label else '', selected)
         for value, label, selected in super(SelectField, self).iter_choices()
     ]
     for value, label, selected in sorted(localized_choices, key=lambda c: c[1]):
         yield (value, label, selected)

 def __call__(self, **kwargs):
     placeholder = kwargs.pop('placeholder', _(self.label.text))
     if placeholder:
         kwargs['placeholder'] = placeholder
     required = kwargs.pop('required', self.flags.required)
     if required is True:
         kwargs['required'] = required
     return super(FieldHelper, self).__call__(**kwargs)

 def process_formdata(self, valuelist):
     if valuelist and len(valuelist) == 1 and valuelist[0]:
         try:
             self.data = self.model.objects.get(id=clean_oid(valuelist[0],
                                                             self.model))
         except self.model.DoesNotExist:
             message = _('{0} does not exists').format(self.model.__name__)
             raise validators.ValidationError(message)

def notify_badge_added(badge):
    if isinstance(badge.subject, Organization):
        recipients = owner_recipients(badge)
        subject = _('Your %(type)s gain a new badge',
                    type=badge.subject.verbose_name)
        mail.send(subject, recipients, 'badge_added', badge=badge)
    else:
        log.warning('Unrecognized badge subject type %s', type(badge.subject))

def notify_new_issue_comment(issue, **kwargs):
    if isinstance(issue.subject, (Dataset, Reuse)):
        comment = kwargs['message']
        recipients = owner_recipients(issue) + [m.posted_by for m in issue.discussion]
        recipients = filter(lambda u: u != comment.posted_by, set(recipients))
        subject = _('%(user)s commented your issue', user=comment.posted_by.fullname)
        mail.send(subject, recipients, 'new_issue_comment', issue=issue, comment=comment)
    else:
        log.warning('Unrecognized issue subject type %s', type(issue.subject))

def notify_issue_closed(issue, **kwargs):
    if isinstance(issue.subject, (Dataset, Reuse)):
        comment = kwargs['message']
        recipients = owner_recipients(issue) + [m.posted_by for m in issue.discussion]
        recipients = filter(lambda u: u != comment.posted_by, set(recipients))
        subject = _('An issue has been closed')
        mail.send(subject, recipients, 'issue_closed', issue=issue, comment=comment)
    else:
        log.warning('Unrecognized issue subject type %s', type(issue.subject))