def save_base(self, raw=False, cls=None, origin=None,

            force_insert=False, force_update=False):

        """

        Does the heavy-lifting involved in saving. Subclasses shouldn't need to

        override this method. It's separate from save() in order to hide the

        need for overrides of save() to pass around internal-only parameters

        ('raw', 'cls', and 'origin').

        """

        if cls is None:

            meta = cls._meta

            if not meta.proxy:

                origin = cls

        if origin:

            signals.pre_save.send(sender=origin, instance=self, raw=raw)

        # We also go through this process to defer the save of proxy objects

        # to their actual underlying model.

        if not raw or meta.proxy:

            if meta.proxy:

                org = cls

            else:

                org = None

                if field and getattr(self, parent._meta.pk.attname) is None and getattr(self, field.attname) is not None:

                self.save_base(cls=parent, origin=org)

                if field:

                    setattr(self, field.attname, self._get_pk_val(parent._meta))

            if meta.proxy:

                return

        if not meta.proxy:

            pk_val = self._get_pk_val(meta)

            pk_set = pk_val is not None

            ROA_FORMAT = getattr(settings, "ROA_FORMAT", 'json')

            get_args = {'format': ROA_FORMAT}

            serializer = serializers.get_serializer(ROA_FORMAT)

            if hasattr(serializer, 'serialize_object'):

                payload = serializer().serialize_object(self)

            else:

                payload = {}

                for field in meta.local_fields:

                    # Handle FK fields

                    if isinstance(field, models.ForeignKey):

                        field_attr = getattr(self, field.name)

                        if field_attr is None:

                            payload[field.attname] = None

                        else:

                            payload[field.attname] = field_attr.id

                    # Handle all other fields

                    else:

                        payload[field.name] = field.value_to_string(self)

                # Handle M2M relations in case of update

                if force_update or pk_set and not self.id is None:

                    for field in meta.many_to_many:

                        # First try to get ids from var set in query's add/remove/clear

                        if hasattr(self, '%s_updated_ids' % field.attname):

                            field_ids = getattr(self, '%s_updated_ids' % field.attname)

                        else:

                            field_ids = [obj.id for obj in field.value_from_object(self)]

                        payload[field.attname] = ','.join(smart_unicode(id) for id in field_ids)

            if force_update or pk_set and not self.id is None:

                record_exists = True

                resource = Resource(self.get_resource_url_detail())

                try:

                    logger.debug(u"""Modifying : "%s" through %s

                                  with payload "%s" and GET args "%s" """ % (

                                  force_unicode(self), 

                                  force_unicode(resource.uri),

                                  force_unicode(payload), 

                                  force_unicode(get_args)))

                    response = resource.put(payload=payload, **get_args)

                except RequestFailed, e:

                    raise ROAException(e)

            else:

                record_exists = False

                resource = Resource(self.get_resource_url_list())

                try:

                    logger.debug(u"""Creating  : "%s" through %s

                                  with payload "%s" and GET args "%s" """ % (

                                  force_unicode(self), 

                                  force_unicode(resource.uri),

                                  force_unicode(payload), 

                                  force_unicode(get_args)))

                    response = resource.post(payload=payload, **get_args)

                except RequestFailed, e:

                    raise ROAException(e)

            for local_name, remote_name in ROA_MODEL_NAME_MAPPING:

                response = response.replace(remote_name, local_name)

            response = force_unicode(response).encode(settings.DEFAULT_CHARSET)

            deserializer = serializers.get_deserializer(ROA_FORMAT)

            if hasattr(deserializer, 'deserialize_object'):

                result = deserializer(response).deserialize_object(response)

            else:

                result = deserializer(response).next()

            self.id = int(result.object.id)

            self = result.object

        if origin:

            signals.post_save.send(sender=origin, instance=self,

                created=(not record_exists), raw=raw)

class RemotePageWithProxy(RemotePage):

    class Meta:

        proxy = True

    @staticmethod

    def get_resource_url_list():

        return u'http://127.0.0.1:8081/django_roa_server/remotepagewithproxy/'

    RemotePageWithNamedRelations, RemotePageWithProxy

    def test_proxy_relation(self):

        remote_page = RemotePage.objects.create(title=u'A remote page')

        proxy_remote_page = RemotePageWithProxy.objects.create(title=u'A proxy remote page')

        self.assertEqual(repr(remote_page), '<RemotePage: A remote page (1)>')

        self.assertEqual(repr(proxy_remote_page), '<RemotePageWithProxy: A proxy remote page (2)>')

        self.assertEqual(repr(RemotePage.objects.all()), '[<RemotePage: A remote page (1)>, <RemotePage: A proxy remote page (2)>]')

        self.assertEqual(repr(RemotePageWithProxy.objects.all()), '[<RemotePage: A remote page (1)>, <RemotePage: A proxy remote page (2)>]')

        proxy_remote_page.title = u'A modified proxy remote page'

        proxy_remote_page.save()

        proxy_remote_page = RemotePageWithProxy.objects.get(id=2)

        self.assertEqual(repr(proxy_remote_page), '<RemotePage: A modified proxy remote page (2)>')

        self.assertEqual(repr(RemotePage.objects.all()[1]), '<RemotePage: A modified proxy remote page (2)>')

        proxy_remote_page.delete()

        remote_page.delete()

    url(r'^django_roa_server/remotepagewithproxy/count/$', remote_pages_count),

    url(r'^django_roa_server/remotepagewithproxy/?(?P<id>\d+)?/?$', remote_pages),