https://t.me/AnonymousX5
Server : Apache
System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64
User : njnconst ( 1116)
PHP Version : 8.4.18
Disable Function : NONE
Directory :  /lib64/python2.7/site-packages/django/contrib/comments/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //lib64/python2.7/site-packages/django/contrib/comments/moderation.pyc
�
r�\c@s�dZddlZddlmZddlmZddlmZddlm	Z	ddl
mZmZddl
mZdd	lmZdd
lmZdefd��YZd
efd��YZdefd��YZdefd��YZe�ZdS(s
A generic comment-moderation system which allows configuration of
moderation options on a per-model basis.

To use, do two things:

1. Create or import a subclass of ``CommentModerator`` defining the
   options you want.

2. Import ``moderator`` from this module and register one or more
   models, passing the models and the ``CommentModerator`` options
   class you want to use.


Example
-------

First, we define a simple model class which might represent entries in
a Weblog::

    from django.db import models

    class Entry(models.Model):
        title = models.CharField(maxlength=250)
        body = models.TextField()
        pub_date = models.DateField()
        enable_comments = models.BooleanField()

Then we create a ``CommentModerator`` subclass specifying some
moderation options::

    from django.contrib.comments.moderation import CommentModerator, moderator

    class EntryModerator(CommentModerator):
        email_notification = True
        enable_field = 'enable_comments'

And finally register it for moderation::

    moderator.register(Entry, EntryModerator)

This sample class would apply two moderation steps to each new
comment submitted on an Entry:

* If the entry's ``enable_comments`` field is set to ``False``, the
  comment will be rejected (immediately deleted).

* If the comment is successfully posted, an email notification of the
  comment will be sent to site staff.

For a full list of built-in moderation options and other
configurability, see the documentation for the ``CommentModerator``
class.

i����N(tsettings(t	send_mail(tsignals(t	ModelBase(tContexttloader(tcomments(tget_current_site(ttimezonetAlreadyModeratedcBseZdZRS(ss
    Raised when a model which is already registered for moderation is
    attempting to be registered again.

    (t__name__t
__module__t__doc__(((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyR	DstNotModeratedcBseZdZRS(sk
    Raised when a model which is not registered for moderation is
    attempting to be unregistered.

    (R
RR(((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyR
LstCommentModeratorcBs_eZdZdZdZdZeZdZ	dZ
d�Zd�Zd�Z
d�Zd�ZRS(sf
    Encapsulates comment-moderation options for a given model.

    This class is not designed to be used directly, since it doesn't
    enable any of the available moderation options. Instead, subclass
    it and override attributes to enable different options::

    ``auto_close_field``
        If this is set to the name of a ``DateField`` or
        ``DateTimeField`` on the model for which comments are
        being moderated, new comments for objects of that model
        will be disallowed (immediately deleted) when a certain
        number of days have passed after the date specified in
        that field. Must be used in conjunction with
        ``close_after``, which specifies the number of days past
        which comments should be disallowed. Default value is
        ``None``.

    ``auto_moderate_field``
        Like ``auto_close_field``, but instead of outright
        deleting new comments when the requisite number of days
        have elapsed, it will simply set the ``is_public`` field
        of new comments to ``False`` before saving them. Must be
        used in conjunction with ``moderate_after``, which
        specifies the number of days past which comments should be
        moderated. Default value is ``None``.

    ``close_after``
        If ``auto_close_field`` is used, this must specify the
        number of days past the value of the field specified by
        ``auto_close_field`` after which new comments for an
        object should be disallowed. Default value is ``None``.

    ``email_notification``
        If ``True``, any new comment on an object of this model
        which survives moderation will generate an email to site
        staff. Default value is ``False``.

    ``enable_field``
        If this is set to the name of a ``BooleanField`` on the
        model for which comments are being moderated, new comments
        on objects of that model will be disallowed (immediately
        deleted) whenever the value of that field is ``False`` on
        the object the comment would be attached to. Default value
        is ``None``.

    ``moderate_after``
        If ``auto_moderate_field`` is used, this must specify the number
        of days past the value of the field specified by
        ``auto_moderate_field`` after which new comments for an
        object should be marked non-public. Default value is
        ``None``.

    Most common moderation needs can be covered by changing these
    attributes, but further customization can be obtained by
    subclassing and overriding the following methods. Each method will
    be called with three arguments: ``comment``, which is the comment
    being submitted, ``content_object``, which is the object the
    comment will be attached to, and ``request``, which is the
    ``HttpRequest`` in which the comment is being submitted::

    ``allow``
        Should return ``True`` if the comment should be allowed to
        post on the content object, and ``False`` otherwise (in
        which case the comment will be immediately deleted).

    ``email``
        If email notification of the new comment should be sent to
        site staff or moderators, this method is responsible for
        sending the email.

    ``moderate``
        Should return ``True`` if the comment should be moderated
        (in which case its ``is_public`` field will be set to
        ``False`` before saving), and ``False`` otherwise (in
        which case the ``is_public`` field will not be changed).

    Subclasses which want to introspect the model for which comments
    are being moderated can do so through the attribute ``_model``,
    which will be the model class.

    cCs
||_dS(N(t_model(tselftmodel((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyt__init__�scCst|j|jk	rQtj|j|j|j�}tj|j|j|j�}n||krltd��n||S(s�
        Internal helper which will return a ``datetime.timedelta``
        representing the time between ``now`` and ``then``. Assumes
        ``now`` is a ``datetime.date`` or ``datetime.datetime`` later
        than ``then``.

        If ``now`` and ``then`` are not of the same type due to one of
        them being a ``datetime.date`` and the other being a
        ``datetime.datetime``, both will be coerced to
        ``datetime.date`` before calculating the delta.

        sTCannot determine moderation rules because date field is set to a value in the future(t	__class__tdatetimetdatetyeartmonthtdayt
ValueError(Rtnowtthen((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyt
_get_delta�s
!cCs�|jr"t||j�s"tSn|jr�|jdk	r�t||j�}|dk	r�|jtj�|�j	|jkr�tSnt
S(s�
        Determine whether a given comment is allowed to be posted on
        a given object.

        Return ``True`` if the comment should be allowed, ``False
        otherwise.

        N(tenable_fieldtgetattrtFalsetauto_close_fieldtclose_aftertNoneRRRtdaystTrue(Rtcommenttcontent_objecttrequesttclose_after_date((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pytallow�s		0cCse|jra|jdk	rat||j�}|dk	ra|jtj�|�j|jkratSnt	S(s!
        Determine whether a given comment on a given object should be
        allowed to show up immediately, or should be marked non-public
        and await approval.

        Return ``True`` if the comment should be moderated (marked
        non-public), ``False`` otherwise.

        N(
tauto_moderate_fieldtmoderate_afterR"RRRRR#R$R(RR%R&R'tmoderate_after_date((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pytmoderate�s

0c
Cs�|js
dSgtjD]}|d^q}tjd�}ti|d6|d6�}dt|�j|f}|j|�}	t	||	tj
|dt�dS(s
        Send email notification of a new comment to site staff when email
        notifications have been requested.

        Nis'comments/comment_notification_email.txtR%R&s[%s] New comment posted on "%s"t
fail_silently(temail_notificationRtMANAGERSRtget_templateRRtnametrenderRtDEFAULT_FROM_EMAILR$(
RR%R&R't
manager_tupletrecipient_listtttctsubjecttmessage((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pytemail�s	 


N(R
RRR"R R*R!RR/RR+RRR)R-R;(((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyRTsR				t	ModeratorcBsDeZdZd�Zd�Zd�Zd�Zd�Zd�ZRS(s}
    Handles moderation of a set of models.

    An instance of this class will maintain a list of one or more
    models registered for comment moderation, and their associated
    moderation classes, and apply moderation to all incoming comments.

    To register a model, obtain an instance of ``Moderator`` (this
    module exports one as ``moderator``), and call its ``register``
    method, passing the model class and a moderation class (which
    should be a subclass of ``CommentModerator``). Note that both of
    these should be the actual classes, not instances of the classes.

    To cease moderation for a model, call the ``unregister`` method,
    passing the model class.

    For convenience, both ``register`` and ``unregister`` can also
    accept a list of model classes in place of a single model; this
    allows easier registration of multiple models with the same
    ``CommentModerator`` class.

    The actual moderation is applied in two phases: one prior to
    saving a new comment, and the other immediately after saving. The
    pre-save moderation may mark a comment as non-public or mark it to
    be removed; the post-save moderation may delete a comment which
    was disallowed (there is currently no way to prevent the comment
    being saved once before removal) and, if the comment is still
    around, will send any notification emails the comment generated.

    cCsi|_|j�dS(N(t	_registrytconnect(R((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyRs	cCsBtjj|jdtj��tjj|jdtj��dS(sp
        Hook up the moderation methods to pre- and post-save signals
        from the comment models.

        tsenderN(Rtcomment_will_be_postedR>tpre_save_moderationRt	get_modeltcomment_was_postedtpost_save_moderation(R((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyR>scCskt|t�r|g}nxI|D]A}||jkrPtd|jj��n||�|j|<q"WdS(s�
        Register a model or a list of models for comment moderation,
        using a particular moderation class.

        Raise ``AlreadyModerated`` if any of the models are already
        registered.

        s)The model '%s' is already being moderatedN(t
isinstanceRR=R	t_metat
model_name(Rtmodel_or_iterabletmoderation_classR((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pytregister$s	
cCsbt|t�r|g}nx@|D]8}||jkrPtd|jj��n|j|=q"WdS(s�
        Remove a model or a list of models from the list of models
        whose comments will be moderated.

        Raise ``NotModerated`` if any of the models are not currently
        registered for moderation.

        s/The model '%s' is not currently being moderatedN(RERR=R
RFRG(RRHR((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyt
unregister4s	
cKsv|jj�}||jkr"dS|j}|j|}|j|||�sQtS|j|||�rrt|_ndS(sY
        Apply any necessary pre-save moderation steps to new
        comments.

        N(tcontent_typetmodel_classR=R&R)RR-t	is_public(RR?R%R'tkwargsRR&RI((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyRADs	
cKsC|jj�}||jkr"dS|j|j||j|�dS(sZ
        Apply any necessary post-save moderation steps to new
        comments.

        N(RLRMR=R;R&(RR?R%R'ROR((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyRDWs(	R
RRRR>RJRKRARD(((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyR<�s						(RRtdjango.confRtdjango.core.mailRtdjango.contrib.commentsRtdjango.db.models.baseRtdjango.templateRRtdjango.contribRtdjango.contrib.sites.modelsRtdjango.utilsRt	ExceptionR	R
tobjectRR<t	moderator(((sD/tmp/pip-install-XxeQeY/django/django/contrib/comments/moderation.pyt<module>7s�l

https://t.me/AnonymousX5 - 2025