Python models.QuestionSubscription类代码示例

def question_posted(action, new):
    question = action.node

    if not question.is_notifiable:
        return

    subscribers = User.objects.filter(
            Q(subscription_settings__enable_notifications=True, subscription_settings__new_question='i') |
            (Q(subscription_settings__new_question_watched_tags='i') &
              Q(marked_tags__name__in=question.tagnames.split(' ')) &
              Q(tag_selections__reason='good'))
    ).exclude(id=question.author.id).distinct()

    subscribers = filter_subscribers(subscribers)

    send_template_email(subscribers, "notifications/newquestion.html", {'question': question})

    subscription = QuestionSubscription(question=question, user=question.author)
    subscription.save()

    new_subscribers = User.objects.filter(
            Q(subscription_settings__all_questions=True) |
            Q(subscription_settings__all_questions_watched_tags=True,
                    marked_tags__name__in=question.tagnames.split(' '),
                    tag_selections__reason='good'))

    for user in new_subscribers:
        create_subscription_if_not_exists(question, user)

def question_posted(sender, instance, **kwargs):
    question = instance.content_object

    subscribers = User.objects.values('email', 'username').filter(
            Q(subscription_settings__enable_notifications=True, subscription_settings__new_question='i') |
            (Q(subscription_settings__new_question_watched_tags='i') &
              Q(marked_tags__name__in=question.tagnames.split(' ')) &
              Q(tag_selections__reason='good'))
    ).exclude(id=question.author.id)

    recipients = create_recipients_dict(subscribers)

    send_email(settings.EMAIL_SUBJECT_PREFIX + _("New question on %s") % settings.APP_SHORT_NAME,
               recipients, "notifications/newquestion.html", {
        'question': question,
    })

    if question.author.subscription_settings.questions_asked:
        subscription = QuestionSubscription(question=question, user=question.author)
        subscription.save()

    new_subscribers = User.objects.filter(
            Q(subscription_settings__all_questions=True) |
            Q(subscription_settings__all_questions_watched_tags=True,
                    marked_tags__name__in=question.tagnames.split(' '),
                    tag_selections__reason='good'))

    for user in new_subscribers:
        create_subscription_if_not_exists(question, user)

def create_subscription_if_not_exists(question, user):
    try:
        subscription = QuestionSubscription.objects.get(
            question=question, user=user)
    except:
        subscription = QuestionSubscription(question=question, user=user)
        subscription.save()

def question_viewed(sender, user, **kwargs):
    try:
        subscription = QuestionSubscription.objects.get(question=sender, user=user)
        subscription.last_view = datetime.datetime.now()
        subscription.save()
    except:
        if user.subscription_settings.questions_viewed:
            subscription = QuestionSubscription(question=sender, user=user)
            subscription.save()

    def handle_noargs(self, **options):
        users = User.objects.all()
        for u in users:
            s = SubscriptionSettings(user=u)
            s.save()

            user_questions = u.questions.all()

            for q in user_questions:
                sub = QuestionSubscription(user=u, question=q)
                sub.save()

def question_viewed(action, new):
    if not action.viewuser.is_authenticated():
        return

    try:
        subscription = QuestionSubscription.objects.get(question=action.node, user=action.viewuser)
        subscription.last_view = datetime.datetime.now()
        subscription.save()
    except:
        if action.viewuser.subscription_settings.questions_viewed:
            subscription = QuestionSubscription(question=action.node, user=action.viewuser)
            subscription.save()

def create_subscription_if_not_exists(question, user):
    try:
        subscription = QuestionSubscription.objects.get(question=question, user=user)
        return subscription
    except QuestionSubscription.MultipleObjectsReturned:
        pass
    except QuestionSubscription.DoesNotExist:
        subscription = QuestionSubscription(question=question, user=user)
        subscription.save()
        return subscription
    except Exception, e:
        logging.error(e)

def question_viewed(instance, user, **kwargs):
    if not user.is_authenticated():
        return

    try:
        subscription = QuestionSubscription.objects.get(question=instance, user=user)
        subscription.last_view = datetime.datetime.now()
        subscription.save()
    except:
        if user.subscription_settings.questions_viewed:
            subscription = QuestionSubscription(question=instance, user=user)
            subscription.save()

def create_subscription_for_mailing_list(question,userquery):
        userlist = [user for user in userquery if user != question.author]
        existingUserList = [subscription.user for  subscription in QuestionSubscription.objects.filter(question=question)]

## remove deleted Mailing List subscriptions
        for sub_remove in list(set(existingUserList) - set (userlist)):
                subscriptions = QuestionSubscription.objects.filter(question=question, user=sub_remove)
                subscriptions.delete()

## Add Mailing List subscriptions
        for sub_add in list(set(userlist) - set (existingUserList)):
                subscription = QuestionSubscription(question=question, user=sub_add)
                subscription.save()

def question_posted(instance, **kwargs):
    question = instance

    subscribers = (
        User.objects.values("email", "username")
        .filter(
            Q(subscription_settings__enable_notifications=True, subscription_settings__new_question="i")
            | (
                Q(subscription_settings__new_question_watched_tags="i")
                & Q(marked_tags__name__in=question.tagnames.split(" "))
                & Q(tag_selections__reason="good")
            )
        )
        .exclude(id=question.author.id)
        .distinct()
    )

    recipients = create_recipients_dict(subscribers)

    send_email(
        settings.EMAIL_SUBJECT_PREFIX + _("New question on %(app_name)s") % dict(app_name=settings.APP_SHORT_NAME),
        recipients,
        "notifications/newquestion.html",
        {"question": question},
    )

    if question.author.subscription_settings.questions_asked:
        subscription = QuestionSubscription(question=question, user=question.author)
        subscription.save()

    new_subscribers = User.objects.filter(
        Q(subscription_settings__all_questions=True)
        | Q(
            subscription_settings__all_questions_watched_tags=True,
            marked_tags__name__in=question.tagnames.split(" "),
            tag_selections__reason="good",
        )
    )

    for user in new_subscribers:
        create_subscription_if_not_exists(question, user)

def question_posted(action, new):
    question = action.node

    if not question.is_notifiable:
        return

    '''
## Mailing List Depending Upon Category
    _recipient_ids = ",".join([category.mail_recipients for category in OsqaCategory.objects.filter(id__in = question.category.split(','))]).split(",")
    recipient_ids =[ recipient.strip()  for recipient in _recipient_ids if recipient.strip() ]
    if len(recipient_ids):
        category_subscribers = User.objects.filter(id__in =recipient_ids ).distinct()
        all_subscribers = category_subscribers

## Mailing List Subscribers
    recipient_list = [ recipient.strip()  for recipient in question.recipientnames.split(',') if recipient.strip() ]

    if len(recipient_list):
        mailing_subscribers = User.objects.filter(id__in = recipient_list ).distinct()

        if len(recipient_ids):
                all_subscribers = category_subscribers  | mailing_subscribers
        else:
                all_subscribers = mailing_subscribers
    '''
    send_template_email(all_subscribers, "notifications/newquestion.html", {'question': question})

    subscription = QuestionSubscription(question=question, user=question.author)
    subscription.save()

    new_subscribers = User.objects.filter(
            Q(subscription_settings__all_questions=True) |
            Q(subscription_settings__all_questions_watched_tags=True,
                    marked_tags__name__in=question.tagnames.split(' '),
                    tag_selections__reason='good'))

    for user in new_subscribers:
        create_subscription_if_not_exists(question, user)