Python events.ReadyRevisionEvent类代码示例

def watch_ready(request):
    """Start watching ready-for-l10n revisions."""
    if request.LANGUAGE_CODE != settings.WIKI_DEFAULT_LANGUAGE:
        raise Http404
    ReadyRevisionEvent.notify(request.user)
    statsd.incr('wiki.watches.ready')
    return HttpResponse()

    def test_product_specific_ready(self):
        """Verify product-specific ready for l10n notifications."""
        # Add a Firefox OS watcher.
        ReadyRevisionEvent.notify(UserFactory(), product='firefox-os')

        # Create a document for Firefox
        doc = DocumentFactory()
        doc.products.add(ProductFactory(slug='firefox'))

        # Mark a revision a ready for L10n. There should be only one email
        # to the watcher created in setUp.
        self._mark_as_ready_revision(doc=doc)
        eq_(1, len(mail.outbox))
        _assert_ready_mail(mail.outbox[0])

        # Add firefox-os to the document's products. Mark as ready for l10n,
        # and there should be two new emails.
        doc.products.add(ProductFactory(slug='firefox-os'))
        self._mark_as_ready_revision(doc=doc)
        eq_(3, len(mail.outbox))
        _assert_ready_mail(mail.outbox[1])
        _assert_ready_mail(mail.outbox[2])

        # Add a Firefox watcher, mark as ready for l10n, and there should
        # be three new emails.
        ReadyRevisionEvent.notify(UserFactory(), product='firefox')
        self._mark_as_ready_revision(doc=doc)
        eq_(6, len(mail.outbox))

    def setUp(self):
        """Have a user watch for revision approval. Log in."""
        self.ready_watcher = user(email="[email protected]", save=True)
        ReadyRevisionEvent.notify(self.ready_watcher)

        readyer = user(save=True)
        add_permission(readyer, Revision, "mark_ready_for_l10n")
        self.client.login(username=readyer.username, password="testpass")

    def setUp(self):
        """Have a user watch for revision approval. Log in."""
        self.ready_watcher = UserFactory(email='[email protected]')
        ReadyRevisionEvent.notify(self.ready_watcher)

        readyer = UserFactory()
        add_permission(readyer, Revision, 'mark_ready_for_l10n')
        self.client.login(username=readyer.username, password='testpass')

def unwatch_ready(request, product=None):
    """Stop watching ready-for-l10n revisions for a given product."""
    if request.LANGUAGE_CODE != settings.WIKI_DEFAULT_LANGUAGE:
        raise Http404

    kwargs = {}
    if product is not None:
        kwargs['product'] = product
    ReadyRevisionEvent.stop_notifying(request.user, **kwargs)

    return HttpResponse()

def watch_ready(request, product=None):
    """Start watching ready-for-l10n revisions for given product."""
    if request.LANGUAGE_CODE != settings.WIKI_DEFAULT_LANGUAGE:
        raise Http404

    kwargs = {}
    if product is not None:
        kwargs['product'] = product
    ReadyRevisionEvent.notify(request.user, **kwargs)
    statsd.incr('wiki.watches.ready')

    return HttpResponse()

    def test_user_watching_both(self):
        """If a single person is watching ready and approved revisions and a
        revision becomes ready, send only the readiness email, not the approval
        one."""
        # Have the Approved watcher watch Ready as well:
        ReadyRevisionEvent.notify(self.approved_watcher)

        self._review_revision(is_ready=True, significance=MEDIUM_SIGNIFICANCE)
        # 1 mail to watcher, 1 to creator, 1 to reviewer
        eq_(3, len(mail.outbox))
        _assert_ready_mail(mail.outbox[0])
        _assert_creator_mail(mail.outbox[1])

def render_readouts(request, readouts, template, locale=None, extra_data=None,
                    product=None):
    """Render a readouts, possibly with overview page.

    Use the given template, pass the template the given readouts, limit the
    considered data to the given locale, and pass along anything in the
    `extra_data` dict to the template in addition to the standard data.

    """
    current_locale = locale or request.LANGUAGE_CODE
    on_default_locale = request.LANGUAGE_CODE == settings.WIKI_DEFAULT_LANGUAGE

    default_kwargs = {
        'locale': settings.WIKI_DEFAULT_LANGUAGE,
    }
    locale_kwargs = {
        'locale': request.LANGUAGE_CODE,
    }
    ready_kwargs = {}

    if product is not None:
        default_kwargs['product'] = product.slug
        locale_kwargs['product'] = product.slug
        ready_kwargs['product'] = product.slug

    data = {'readouts': SortedDict((slug, class_(request, locale=locale,
                                                 product=product))
                                   for slug, class_ in readouts.iteritems()
                                   if class_.should_show_to(request)),
            'default_locale': settings.WIKI_DEFAULT_LANGUAGE,
            'default_locale_name':
                LOCALES[settings.WIKI_DEFAULT_LANGUAGE].native,
            'current_locale': current_locale,
            'current_locale_name': LOCALES[current_locale].native,
            'request_locale_name': LOCALES[request.LANGUAGE_CODE].native,
            'is_watching_default_approved':
                ApproveRevisionInLocaleEvent.is_notifying(
                    request.user, **default_kwargs),
            'is_watching_other_approved':
                None if on_default_locale
                else ApproveRevisionInLocaleEvent.is_notifying(
                    request.user, **locale_kwargs),
            'is_watching_default_locale':
                ReviewableRevisionInLocaleEvent.is_notifying(
                    request.user, **default_kwargs),
            'is_watching_other_locale':
                None if on_default_locale
                else ReviewableRevisionInLocaleEvent.is_notifying(
                    request.user, **locale_kwargs),
            'is_watching_default_ready':
                ReadyRevisionEvent.is_notifying(request.user, **ready_kwargs),
            'on_default_locale': on_default_locale,
            'announce_form': AnnouncementForm(),
            'announcements': Announcement.get_for_locale_name(current_locale),
            'product': product,
            'products': Product.objects.filter(visible=True),
        }
    if extra_data:
        data.update(extra_data)
    return render(request, 'dashboards/' + template, data)

def _set_up_ready_watcher():
    """Make a user who watches for revision readiness."""
    ready_watcher = user(email="[email protected]", save=True)
    ReadyRevisionEvent.notify(ready_watcher)
    return ready_watcher

def unwatch_ready(request):
    """Stop watching ready-for-l10n revisions."""
    if request.LANGUAGE_CODE != settings.WIKI_DEFAULT_LANGUAGE:
        raise Http404
    ReadyRevisionEvent.stop_notifying(request.user)
    return HttpResponse()

def _set_up_ready_watcher():
    """Make a user who watches for revision readiness."""
    ready_watcher = UserFactory(email='[email protected]')
    ReadyRevisionEvent.notify(ready_watcher)
    return ready_watcher