def send_notification_to_user_with_id(user_id, notification):
User = get_user_model()
user = User.objects.only('username', 'uuid', 'id').get(pk=user_id)
for device in user.devices.all():
notification.set_parameter('ios_badgeType', 'Increase')
notification.set_parameter('ios_badgeCount', '1')
user_id_contents = (str(user.uuid) + str(user.id)).encode('utf-8')
user_id = sha256(user_id_contents).hexdigest()
notification.set_filters([
{
"field": "tag",
"key": "user_id",
"relation": "=",
"value": user_id
},
{
"field": "tag",
"key": "device_uuid",
"relation": "=",
"value": device.uuid
},
])
onesignal_client.send_notification(notification)
def _process_post_mentions(self):
if not self.text:
self.user_mentions.all().delete()
else:
usernames = extract_usernames_from_string(string=self.text)
if not usernames:
self.user_mentions.all().delete()
else:
existing_mention_usernames = []
for existing_mention in self.user_mentions.only('id', 'user__username').all().iterator():
if existing_mention.user.username not in usernames:
existing_mention.delete()
else:
existing_mention_usernames.append(existing_mention.user.username)
PostUserMention = get_post_user_mention_model()
User = get_user_model()
for username in usernames:
username = username.lower()
if username not in existing_mention_usernames:
try:
user = User.objects.only('id', 'username').get(username=username)
user_is_post_creator = user.pk == self.creator_id
if user.can_see_post(post=self) and not user_is_post_creator:
PostUserMention.create_post_user_mention(user=user, post=self)
existing_mention_usernames.append(username)
except User.DoesNotExist:
pass
def get(self, request, user_username):
request_data = request.data.copy()
request_data['username'] = user_username
serializer = GetUserSerializer(data=request_data)
serializer.is_valid(raise_exception=True)
data = serializer.validated_data
username = data.get('username')
User = get_user_model()
user = User.get_user_with_username(username)
user_serializer = None
if not request.user.is_anonymous:
authenticated_user = request.user
if authenticated_user.username == user_username:
user_serializer = GetAuthenticatedUserSerializer(
user, context={"request": request})
if not user_serializer:
user_serializer = GetUserUserSerializer(
user, context={"request": request})
return Response(user_serializer.data, status=status.HTTP_200_OK)
def check_username_not_taken(user, username):
if username == user.username:
return
User = get_user_model()
if User.is_username_taken(username=username):
raise ValidationError(_('The username is already taken.'))
def check_email_not_taken(user, email):
if email == user.email:
return
User = get_user_model()
if User.is_email_taken(email=email):
raise ValidationError(_('The email is already taken.'))
def get_temporary_username(email):
username = email.split('@')[0]
temp_username = sanitise_username(username) + str(secrets.randbelow(9999))
User = get_user_model()
while User.is_username_taken(temp_username):
temp_username = username + str(secrets.randbelow(9999))
return temp_username
def _process_post_comment_mentions(self):
usernames = extract_usernames_from_string(string=self.text)
if not usernames:
self.user_mentions.all().delete()
else:
existing_mention_usernames = []
for existing_mention in self.user_mentions.only(
'id', 'user__username').all().iterator():
if existing_mention.user.username not in usernames:
existing_mention.delete()
else:
existing_mention_usernames.append(
existing_mention.user.username)
PostCommentUserMention = get_post_comment_user_mention_model()
User = get_user_model()
for username in usernames:
username = username.lower()
if username not in existing_mention_usernames:
try:
user = User.objects.only(
'id', 'username').get(username=username)
user_can_see_post_comment = user.can_see_post_comment(
post_comment=self)
user_is_commenter = user.pk == self.commenter_id
if not user_can_see_post_comment or user_is_commenter:
continue
if self.parent_comment:
user_is_parent_comment_creator = self.parent_comment.commenter_id == user.pk
user_has_replied_before = self.parent_comment.replies.filter(
commenter_id=user.pk).exists()
if user_has_replied_before or user_is_parent_comment_creator:
# Its a reply to a comment, if the user previously replied to the comment
# or if he's the creator of the parent comment he will already be alerted of the reply,
# no need for mention
continue
else:
user_has_commented_before = self.post.comments.filter(
commenter_id=user.pk).exists()
if user_has_commented_before:
# Its a comment to a post, if the user previously commented on the post
# he will already be alerted of the comment, no need for mention
continue
PostCommentUserMention.create_post_comment_user_mention(
user=user, post_comment=self)
existing_mention_usernames.append(username)
except User.DoesNotExist:
pass
def to_representation(self, value):
request = self.context.get('request')
if not request.user.is_anonymous:
if request.user.pk == value.pk:
return value.count_posts()
return value.count_posts_for_user_with_id(request.user.pk)
User = get_user_model()
return User.count_unauthenticated_public_posts_for_user_with_username(
username=value.username)
def handle(self, *args, **options):
User = get_user_model()
users = User.objects.all()
for user in users:
old_username = user.username
# convert to ascii
normalised_username = unicodedata.normalize(
'NFD', old_username).encode('ascii', 'ignore').decode('utf-8')
normalised_username = self.sanitise_username(normalised_username)
logger.info('Normalised username {0} to {1}'.format(
old_username, normalised_username))
def get_participants(self):
User = get_user_model()
# Add post creator
post_creator = User.objects.filter(pk=self.creator_id)
# Add post commentators
post_commenters = User.objects.filter(posts_comments__post_id=self.pk, is_deleted=False)
# If community post, add community members
if self.community:
community_members = User.objects.filter(communities_memberships__community_id=self.community_id,
is_deleted=False)
result = post_creator.union(post_commenters, community_members)
else:
result = post_creator.union(post_commenters)
return result
def approve_with_actor_with_id(self, actor_id):
Post = get_post_model()
PostComment = get_post_comment_model()
Community = get_community_model()
User = get_user_model()
content_object = self.content_object
moderation_severity = self.category.severity
current_status = self.status
self.status = ModeratedObject.STATUS_APPROVED
ModeratedObjectStatusChangedLog.create_moderated_object_status_changed_log(
changed_from=current_status, changed_to=self.status, moderated_object_id=self.pk, actor_id=actor_id)
if isinstance(content_object, Post) or \
isinstance(content_object, PostComment) or \
isinstance(content_object, Community):
content_object.delete_notifications()
if isinstance(content_object, User) and moderation_severity == ModerationCategory.SEVERITY_CRITICAL:
content_object.delete_outgoing_notifications()
self.save()
def get(self, request):
query_params = request.query_params.dict()
serializer = SearchUsersSerializer(data=query_params)
serializer.is_valid(raise_exception=True)
data = serializer.validated_data
count = data.get('count', 20)
query = data.get('query')
user = request.user
if user.is_anonymous:
User = get_user_model()
users = User.get_public_users_with_query(query=query)
else:
users = user.search_users_with_query(query=query)
users_serializer = SearchUsersUserSerializer(
users[:count], many=True, context={'request': request})
return Response(users_serializer.data, status=status.HTTP_200_OK)
def verify_with_actor_with_id(self, actor_id):
current_verified = self.verified
self.verified = True
ModeratedObjectVerifiedChangedLog.create_moderated_object_verified_changed_log(
changed_from=current_verified, changed_to=self.verified, moderated_object_id=self.pk, actor_id=actor_id)
Post = get_post_model()
Hashtag = get_hashtag_model()
PostComment = get_post_comment_model()
Community = get_community_model()
User = get_user_model()
ModerationPenalty = get_moderation_penalty_model()
content_object = self.content_object
moderation_severity = self.category.severity
penalty_targets = None
if self.is_approved():
if isinstance(content_object, User):
penalty_targets = [content_object]
elif isinstance(content_object, Post):
penalty_targets = [content_object.creator]
elif isinstance(content_object, PostComment):
penalty_targets = [content_object.commenter]
elif isinstance(content_object, Community):
penalty_targets = content_object.get_staff_members()
elif isinstance(content_object, ModeratedObject):
penalty_targets = content_object.get_reporters()
elif isinstance(content_object, Hashtag):
penalty_targets = []
for penalty_target in penalty_targets:
duration_of_penalty = None
penalties_count = penalty_target.count_moderation_penalties_for_moderation_severity(
moderation_severity=moderation_severity) + 1
if moderation_severity == ModerationCategory.SEVERITY_CRITICAL:
duration_of_penalty = timezone.timedelta(weeks=5000)
elif moderation_severity == ModerationCategory.SEVERITY_HIGH:
duration_of_penalty = timezone.timedelta(days=penalties_count ** 4)
elif moderation_severity == ModerationCategory.SEVERITY_MEDIUM:
duration_of_penalty = timezone.timedelta(hours=penalties_count ** 3)
elif moderation_severity == ModerationCategory.SEVERITY_LOW:
duration_of_penalty = timezone.timedelta(minutes=penalties_count ** 2)
moderation_expiration = timezone.now() + duration_of_penalty
ModerationPenalty.create_suspension_moderation_penalty(moderated_object=self,
user_id=penalty_target.pk,
expiration=moderation_expiration)
if (isinstance(content_object, Post) or isinstance(content_object, PostComment) or isinstance(
content_object,
Community)) or (
isinstance(content_object, User) and moderation_severity == ModerationCategory.SEVERITY_CRITICAL):
content_object.soft_delete()
if moderation_severity == ModerationCategory.SEVERITY_CRITICAL and isinstance(content_object, Post):
# We have hashes
content_object.delete_media()
content_object.save()
self.save()
def __init__(self):
PostReaction = get_post_reaction_model()
PostComment = get_post_comment_model()
User = get_user_model()
Emoji = get_emoji_model()
Post = get_post_model()
CommunityInvite = get_community_invite_model()
Community = get_community_model()
class NotificationUserSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = (
'id',
'username',
)
class NotificationEmojiSerializer(serializers.ModelSerializer):
class Meta:
model = Emoji
fields = (
'id',
'keyword',
)
class NotificationPostSerializer(serializers.ModelSerializer):
class Meta:
model = Post
fields = (
'id',
'uuid',
)
class NotificationPostReactionSerializer(serializers.ModelSerializer):
reactor = NotificationUserSerializer()
emoji = NotificationEmojiSerializer()
post = NotificationPostSerializer()
class Meta:
model = PostReaction
fields = ('id', 'reactor', 'emoji', 'post')
self.NotificationPostReactionSerializer = NotificationPostReactionSerializer
class NotificationCommunitySerializer(serializers.ModelSerializer):
class Meta:
model = Community
fields = ('id', 'name', 'title')
class NotificationCommunityInviteSerializer(serializers.ModelSerializer
):
creator = NotificationUserSerializer()
invited_user = NotificationUserSerializer()
community = NotificationCommunitySerializer()
class Meta:
model = CommunityInvite
fields = ('id', 'creator', 'invited_user', 'community')
self.NotificationCommunityInviteSerializer = NotificationCommunityInviteSerializer
class NotificationPostCommentSerializer(serializers.ModelSerializer):
commenter = NotificationUserSerializer()
post = NotificationPostSerializer()
class Meta:
model = PostComment
fields = ('id', 'commenter', 'post')
self.NotificationPostCommentSerializer = NotificationPostCommentSerializer
class NotificationPostCommentReplySerializer(
serializers.ModelSerializer):
commenter = NotificationUserSerializer()
post = NotificationPostSerializer()
class Meta:
model = PostComment
fields = ('id', 'commenter', 'post')
self.NotificationPostCommentReplySerializer = NotificationPostCommentReplySerializer
class FollowNotificationSerializer(serializers.Serializer):
following_user = NotificationUserSerializer()
self.FollowNotificationSerializer = FollowNotificationSerializer
class ConnectionRequestNotificationSerializer(serializers.Serializer):
connection_requester = NotificationUserSerializer()
self.ConnectionRequestNotificationSerializer = ConnectionRequestNotificationSerializer
def get_staff_members(self):
User = get_user_model()
staff_members_query = Q(communities_memberships__community_id=self.pk)
staff_members_query.add(
Q(communities_memberships__is_administrator=True) | Q(communities_memberships__is_moderator=True), Q.AND)
return User.objects.filter(staff_members_query)
