コード例 #1
0
    def update(self, instance, validated_data, profile_category):

        no_notification_columns = ['name', 'gender', 'avatar_url', 'contag']
        public_columns = ['name', 'gender', 'avatar_url', 'contag', 'mobile_number']

        print type(validated_data)
        validated_data = json.loads(validated_data)
        for field in validated_data:

            column_name = field.keys()[0]

            if column_name.__eq__('avatar_url'):
                instance.update_profile_picture_from_url(field[column_name])
            else:
                existing_value = getattr(instance, column_name)

                #If the new value is blank set it as null
                new_value = None if not field[column_name] else field[column_name]

                is_new = False if existing_value else True

                #if new value is null or same as old value then notification should not be created
                is_updated = True if (existing_value != new_value) else False

                setattr(instance, column_name, new_value)

                is_public = False
                if column_name not in public_columns:
                    right = ProfileRight.objects.filter(from_user=instance, unit_type=column_name)

                    if not right:
                        right = ProfileRight.objects.create(from_user=instance, unit_type=column_name)
                    else:
                        right = right[0]
                    is_public = right.is_public

                #Change existing add requests to share requests
                if not existing_value and new_value:
                    existing_requests = ProfileRequest.objects.filter(for_user=instance.id, request_type=column_name)
                    Notification.objects.filter(user=instance.id,
                                                notification_type="profile_request_add",
                                                request__in =
                                                existing_requests).update(notification_type="profile_request_share")

                if is_updated and column_name not in no_notification_columns:
                    make_notification.profile_updated(from_user=instance, column_name=column_name,
                                                      is_public=is_public, is_new=is_new)



        instance.save()

        return instance
コード例 #2
0
    def update(self, instance, validated_data):

        instance.platform_id = validated_data.get("platform_id")
        instance.platform_token = validated_data.get("platform_token", None)
        instance.platform_secret = validated_data.get("platform_secret", None)
        instance.platform_permissions = validated_data.get("platform_permissions", None)
        instance.platform_email = validated_data.get("platform_email", None)
        instance.platform_username = validated_data.get("platform_username", None)

        instance.save()

        make_notification.profile_updated(from_user=instance.user, column_name=instance.social_platform.platform_name,
                                          is_new=False)

        return instance
コード例 #3
0
    def create(self, validated_data):

        user = self.context["current_user"]

        profile = SocialProfile.objects.create(user=user, **validated_data)

        platform_name = profile.social_platform.platform_name

        right = ProfileRight.objects.filter(from_user=user, unit_type=platform_name)

        existing_requests = ProfileRequest.objects.filter(for_user=user.id,
                                                          request_type=platform_name)
        Notification.objects.filter(user=user.id,
                                    notification_type="profile_request_add",
                                    request__in =
                                    existing_requests).update(notification_type="profile_request_share")

        if not len(right):
            ProfileRight.objects.create(from_user=user, unit_type=platform_name)

        make_notification.profile_updated(from_user=user, column_name=platform_name, is_new=True)

        return profile
コード例 #4
0
ファイル: views.py プロジェクト: trolltartar/contagbackend
    def post(self, request):

        try:
            print request.data["user_ids"]
            column_name = request.data["field_name"]
            print column_name
            is_public = request.data["is_public"]
            print is_public
            custom_share = request.data["user_ids"]
            is_private = not is_public and not len(custom_share)

            right = ProfileRight.objects.filter(from_user=request.user, unit_type=column_name)

            if len(right):
                right = right[0]
                right.is_public = is_public
                right.is_private = is_private
                right.save()
            else:
                right = ProfileRight.objects.create(from_user=request.user, unit_type=column_name,
                                            is_private=is_private, is_public=is_public)



            if is_public:
                #Create feed only for those who haven't had access to it till now
                feeds = Feed.objects.filter(from_user=request.user, column_name=column_name, is_shown=1)
                #Find existing users who have had this feed in the past
                existing_users = [feed.for_user for feed in feeds]
                #Find all users for the current user
                all_users = Contact.objects.filter(user=request.user, is_on_contag=1)
                #Filter out all users who previously got this feed
                send_to = []
                for contact in all_users:
                    if contact.contact_contag_user not in existing_users:
                        if Contact.objects.filter(user=contact.contact_contag_user, contact_contag_user=request.user).exists():
                            send_to.append(contact.contact_contag_user)


                from notifier.make_notification import profile_updated
                profile_updated(from_user=request.user, for_users=send_to, is_public=False, column_name=column_name)


                requests = ProfileRequest.objects.filter(for_user=request.user, request_type=column_name)
                requests.update(status="allow")
                Notification.objects.filter(request__in = requests).update(is_shown=False)
            else:
                existing_shares = ProfileShare.objects.filter(from_user=request.user, unit_type=column_name)
                if len(custom_share):
                    #print custom_share
                    existing_shares = [users.for_user.id for users in existing_shares]
                    print existing_shares
                    requested_shares = [int(share) for share in custom_share.split(",")]
                    print requested_shares
                    delete_shares = [share for share in existing_shares if share not in requested_shares]
                    print delete_shares
                    ProfileShare.objects.filter(from_user=request.user, unit_type=column_name, for_user_id__in = delete_shares).delete()

                    new_shares = [user_id for user_id in requested_shares if user_id not in existing_shares]

                    print "New Shares: "
                    print new_shares
                    for share in new_shares:
                        print share
                        ProfileShare.objects.create(from_user=request.user, unit_type=column_name, for_user_id=share)


                        make_notification.profile_updated(from_user=request.user, column_name=column_name,
                                                              is_public=right.is_public, is_new=True,
                                                              for_users=[User.objects.get(pk=share)])


                        #In case a request already requests for this profile attribute for the given user from this user
                        #remove it
                        profile_request = ProfileRequest.objects.filter(for_user=request.user, from_user_id=share, request_type=column_name)
                        if profile_request:
                            profile_request[0].status = "allow"
                            profile_request[0].save()
                            Notification.objects.filter(request=profile_request[0]).update(is_shown=False)
                else:
                    existing_shares.delete()

            return JSONResponse(SUCCESS_MESSAGE, status=200)
        except Exception as e:
            print traceback.format_exc(e)
            beam(e, request)
            return JSONResponse(ERROR_MESSAGE, status=20)