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)