Exemple #1
0
    def test_init(self):
        # Test that you have to use a dict some other resources
        with self.assertRaises(ValueError):
            GenericForeignKeyField(((Note, NoteResource)), 'nofield')

        # Test that you must register some other resources
        with self.assertRaises(ValueError):
            GenericForeignKeyField({}, 'nofield')

        # Test that the resources you raise must be models
        with self.assertRaises(ValueError):
            GenericForeignKeyField({NoteResource: Note}, 'nofield')
Exemple #2
0
class PostResource(ModelResource):
    author = GenericForeignKeyField({
        User: UserResource,
    }, 'author')
    last_modified_by = GenericForeignKeyField({
        User: UserResource,
    }, 'last_modified_by')

    class Meta:
        queryset = Posts.objects.all()
        resource_name = 'post'
        authentication = ApiKeyAuthentication()
        authorization = DjangoAuthorization()
Exemple #3
0
    def test_resource_from_uri(self):
        note_2 = Note.objects.create(title='Generic and such',
                                     content='Sometimes it is to lorem ipsum')

        gfk_field = GenericForeignKeyField(
            {
                Note: NoteResource,
                Quote: QuoteResource
            }, 'nofield')

        self.assertEqual(
            gfk_field.resource_from_uri(gfk_field.to_class(),
                                        '/api/v1/notes/%s/' % note_2.pk).obj,
            note_2)
Exemple #4
0
class ObjectACLResource(MyTardisModelResource):
    content_object = GenericForeignKeyField(
        {
            Experiment: ExperimentResource,
            # ...
        },
        'content_object')

    class Meta:
        authentication = default_authentication
        authorization = ACLAuthorization()
        queryset = ObjectACL.objects.all()
        filtering = {
            'pluginId': ('exact', ),
            'entityId': ('exact', ),
        }

    def hydrate(self, bundle):
        # Fill in the content type.
        if bundle.data['content_type'] == 'experiment':
            experiment = Experiment.objects.get(pk=bundle.data['object_id'])
            bundle.obj.content_type = experiment.get_ct()
        else:
            raise NotImplementedError(str(bundle.obj))
        return bundle
Exemple #5
0
class PlaylistItemResource(ModelResource):
    co_to = {
        Release: ReleaseResource,
        #Media: MediaResource,
        Media: SimpleMediaResource,
        Jingle: JingleResource,
    }

    content_object = GenericForeignKeyField(to=co_to,
                                            attribute='content_object',
                                            null=False,
                                            full=True)

    class Meta:
        queryset = PlaylistItem.objects.all()
        excludes = [
            'id',
        ]

    def dehydrate(self, bundle):
        bundle.data[
            'content_type'] = '%s' % bundle.obj.content_object.__class__.__name__.lower(
            )
        bundle.data[
            'resource_uri'] = '%s' % bundle.obj.content_object.get_api_url()
        return bundle
Exemple #6
0
class RatingResource(ModelResource):
    post = GenericForeignKeyField({
        BlogProxy: PostResource,
        BlogPost: BlogPostResource,
        Recipe: RecipeResource
    }, 'content_object')

    class Meta:
        queryset = Rating.objects.all()
        resource_name = "rating"
        fields = ['id', 'object_pk', 'value',]
        list_allowed_methods = ['get', 'post',]
        detail_allowed_methods = ['get',]
        throttle = CacheDBThrottle()
        filtering = {
            'object_pk': ('exact',),
            }
        serializer = CamelCaseJSONSerializer()
        authentication = ApiKeyAuthentication()
        authorization = DjangoAuthorization()

    def alter_list_data_to_serialize(self, request, data):
        data['ratings'] = data['objects']
        del data['objects']
        return data

    def alter_deserialized_list_data(self, request, data):
        data['objects'] = data['ratings']
        del data['ratings']
        return data
Exemple #7
0
class BanyanUserNotificationsResource(ModelResource):
    user = fields.ForeignKey('accounts.api.BanyanUserResource', 'user')
    from_user = fields.ForeignKey('accounts.api.BanyanUserResource',
                                  'from_user',
                                  null=True,
                                  blank=True)
    content_object = GenericForeignKeyField(
        {
            Story: StoryResource,
            Piece: PieceResource,
            BanyanUser: BanyanUserResource,
        },
        'content_object',
        null=True,
        blank=True)

    class Meta:
        queryset = BanyanUserNotifications.objects.all()
        resource_name = 'notifications'
        list_allowed_methods = []
        detail_allowed_methods = ['get']
        authentication = ApiKeyAuthentication()  #Only from the devices
        authorization = BanyanUserNotificationsAuthorization()
        filtering = {
            'user': ALL_WITH_RELATIONS,
        }
Exemple #8
0
class ActivityResource(ModelResource):
    user = fields.ForeignKey(BanyanUserResource, 'user', full=True)
    content_object = GenericForeignKeyField(
        {
            Story: StoryResource,
            Piece: PieceResource,
            BanyanUser: BanyanUserResource,
        }, 'content_object')

    class Meta:
        always_return_data = True
        queryset = Activity.objects.all()
        authentication = MultiAuthentication(ApiKeyAuthentication(),
                                             SessionAuthentication(),
                                             Authentication())
        authorization = ActivityAuthorization()
        filtering = {
            'object_id': ALL_WITH_RELATIONS,
            'content_type': ALL_WITH_RELATIONS,
            'user': ALL_WITH_RELATIONS,
            'type': ['exact']
        }

    def hydrate_user(self, bundle):
        if bundle.request.user.is_authenticated():
            bundle.data['user'] = bundle.request.user
        return bundle
Exemple #9
0
class ActionResource(ModelResource):
    """
    API resource for accessing action profiles (script and dialogue).
    """
    action_type = fields.ForeignKey(ActionTypeResource,
                                    'action_type',
                                    null=True)
    related_item = fields.ForeignKey(ItemResource, 'related_item', null=True)
    content_object = GenericForeignKeyField(
        {
            DefaultActionSet: DefaultActionSetResource,
            Item: ItemResource,
            ItemCombo: ItemComboResource,
            Layer: LayerResource,
            TreeTopic: TreeTopicResource,
        }, 'content_object')

    class Meta:
        resource_name = 'action'
        queryset = Action.objects.all()
        always_return_data = True
        authorization = DjangoAuthorization()
        filtering = {
            'id': ALL,
            'content_object': ALL,
            'content_type': ['exact'],
            'object_id': ['exact'],
        }
Exemple #10
0
class AssignedKeywordResource(ModelResource):
    assignments = fields.ToOneField('mezzanine_recipes.api.KeywordResource', 'keyword', full=True)
    post = GenericForeignKeyField({
        BlogProxy: PostResource,
        BlogPost: BlogPostResource,
        Recipe: RecipeResource
    }, 'content_object')

    class Meta:
        queryset = AssignedKeyword.objects.all()
        resource_name = "assigned_keywords"
        fields = ['id', 'object_pk', '_order',]
        list_allowed_methods = ['get',]
        detail_allowed_methods = ['get',]
        throttle = CacheDBThrottle()
        filtering = {
            'object_pk': ('exact',),
            }
        serializer = CamelCaseJSONSerializer()
        authentication = ApiKeyAuthentication()
        authorization = ReadOnlyAuthorization()

    def alter_list_data_to_serialize(self, request, data):
        data['assignedKeywords'] = data['objects']
        del data['objects']
        return data

    def alter_deserialized_list_data(self, request, data):
        data['objects'] = data['assignedKeywords']
        del data['assignedKeywords']
        return data
Exemple #11
0
class LikeResource(CommonModelResource, AutoAssignCreatedByMixinResource):
    CREATED_BY_FIELD = 'src'
    created_by = fields.ForeignKey(UserReferenceResource,
                                   CREATED_BY_FIELD,
                                   use_in='detail')  #delete parent field
    src = fields.ForeignKey(UserReferenceResource,
                            CREATED_BY_FIELD,
                            full=True,
                            readonly=True)
    dst = fields.ForeignKey(CommonResource, 'dst')

    get_dst = GenericForeignKeyField(
        {
            CommonModel: CommonModelResource,
            CommonGoal: CommonGoalResource,
            Update: UpdateResource
            # Inspiration: InspirationResource # IN THE FUTURE
        },
        'get_dst',
        readonly=True,
        full=False)

    class Meta:
        queryset = Like.objects.all()
        resource_name = 'like'
        authentication = CommonApiKeyAuthentication()
        filtering = {'dst': ALL_WITH_RELATIONS, 'id': ALL}
        ordering = ['id']
Exemple #12
0
class PlaylistItemResource(ModelResource):

    #media = fields.ToOneField('alibrary.api.MediaResource', 'media', null=True, full=True)

    co_to = {
        Release: ReleaseResource,
        #Media: MediaResource,
        Media: SimpleMediaResource,
        Jingle: JingleResource,
    }

    content_object = GenericForeignKeyField(to=co_to,
                                            attribute='content_object',
                                            null=False,
                                            full=True)

    class Meta:
        queryset = PlaylistItem.objects.all()
        #resource_name = 'playlistitem'
        excludes = [
            'id',
        ]

    def dehydrate(self, bundle):
        bundle.data[
            'content_type'] = '%s' % bundle.obj.content_object.__class__.__name__.lower(
            )
        return bundle
Exemple #13
0
class CommentResource(ModelResource):

    user = fields.ForeignKey(UserResource, 'user')
    content_object = GenericForeignKeyField(
        {
            Bookmark: BookmarkResource,
            #List: ListResource
        },
        'content_object')

    class Meta:
        model = Comment
        queryset = Comment.objects.all()
        allowed_methods = ['get', 'post', 'delete']
        always_return_data = True
        authentication = SessionAuthentication()
        authorization = CommentAuthorization()
        validation = FormValidation(form_class=CommentForm)
        filtering = {'object_pk': ALL}

    def dehydrate(self, bundle):
        user = bundle.obj.user
        bundle.data['avatar'] = avatar(user.email, 32)
        bundle.data['user_name'] = user.username
        bundle.data['submit_date'] = humanize.naturaltime(
            bundle.data['submit_date'])
        return bundle
Exemple #14
0
    def test_resource_from_uri(self):
        note_2 = Note.objects.create(
            title='Generic and such',
            content='Sometimes it is to lorem ipsum'
        )

        gfk_field = GenericForeignKeyField({
            Note: NoteResource,
            Quote: QuoteResource
        }, 'nofield')

        self.assertEqual(
            gfk_field.resource_from_uri(
                gfk_field.to_class(),
                '/api/v1/notes/%s/' % note_2.pk
            ).obj,
            note_2
        )
Exemple #15
0
    def test_build_related_resource(self):
        gfk_field = GenericForeignKeyField(
            {
                Note: NoteResource,
                Quote: QuoteResource
            }, 'nofield')

        quote_1 = Quote.objects.create(
            byline='Issac Kelly',
            content='To ipsum or not to ipsum, that is the cliche')
        qr = QuoteResource()
        qr.build_bundle(obj=quote_1)

        bundle = gfk_field.build_related_resource('/api/v1/quotes/%s/' %
                                                  quote_1.pk)

        # Test that the GFK field builds the same as the QuoteResource
        self.assertEqual(bundle.obj, quote_1)
class RatingResource(ModelResource):
    content_object = GenericForeignKeyField({
        Note: NoteResource,
        Quote: QuoteResource
    }, 'content_object')

    class Meta:
        resource_name = 'ratings'
        queryset = Rating.objects.all()
Exemple #17
0
    def test_resource_from_uri(self):
        note_2 = Note.objects.create(title='Generic and such',
                                     content='Sometimes it is to lorem ipsum')

        gfk_field = GenericForeignKeyField(
            {
                Note: NoteResource,
                Quote: QuoteResource
            }, 'nofield')

        request = MockRequest()
        request.GET = {'format': 'json'}
        request.method = 'GET'

        self.assertEqual(
            gfk_field.resource_from_uri(gfk_field.to_class(),
                                        '/api/v1/notes/%s/' % note_2.pk,
                                        request).obj, note_2)
Exemple #18
0
class DetailResource(ModelResource):
    user = GenericForeignKeyField({
        User: UserResource,
    }, 'user')

    class Meta:
        queryset = UserDetail.objects.all()
        resource_name = 'detail'
        authentication = ApiKeyAuthentication()
        authorization = DjangoAuthorization()
Exemple #19
0
    def test_build_related_resource(self):
        gfk_field = GenericForeignKeyField({
            Note: NoteResource,
            Quote: QuoteResource
        }, 'nofield')

        quote_1 = Quote.objects.create(
            byline='Issac Kelly',
            content='To ipsum or not to ipsum, that is the cliche'
        )
        qr = QuoteResource()
        qr.build_bundle(obj=quote_1)

        bundle = gfk_field.build_related_resource(
            '/api/v1/quotes/%s/' % quote_1.pk
        )

        # Test that the GFK field builds the same as the QuoteResource
        self.assertEqual(bundle.obj, quote_1)
class MeterReadResource(ModelResource):
    content_object = GenericForeignKeyField({
        Meter: MeterResource,
    }, 'content_object')

    class Meta:
        queryset = MeterRead.objects.all()
        allowed_methods = ['get', 'post', 'patch']
        authentication = BasicAuthentication()
        authorization = DjangoAuthorization()
Exemple #21
0
class CommentResource(ModelResource):
    replied_to = fields.ToOneField('mezzanine_recipes.api.CommentResource',
                                   'replied_to',
                                   null=True)
    content_object = GenericForeignKeyField(
        {
            BlogProxy: PostResource,
            BlogPost: BlogPostResource,
            Recipe: RecipeResource
        }, 'content_object')

    class Meta:
        queryset = ThreadedComment.objects.visible()
        resource_name = "comments"
        fields = [
            'id',
            'object_pk',
            'comment',
            'submit_date',
            'user_name',
            'user_email',
            'user_url',
            'replied_to',
        ]
        list_allowed_methods = [
            'get',
            'post',
        ]
        detail_allowed_methods = [
            'get',
        ]
        throttle = CacheDBThrottle()
        filtering = {
            'object_pk': ('exact', ),
        }
        serializer = CamelCaseJSONSerializer()
        authentication = ApiKeyAuthentication()
        authorization = DjangoAuthorization()
        limit = 0

    def dehydrate_user_email(self, bundle):
        return None

    def dehydrate_user_url(self, bundle):
        return None

    def alter_list_data_to_serialize(self, request, data):
        data['comments'] = data['objects']
        del data['objects']
        return data

    def alter_deserialized_list_data(self, request, data):
        data['objects'] = data['comments']
        del data['comments']
        return data
Exemple #22
0
class FocusResource(BaseResource):
    content_object = GenericForeignKeyField(
        {
            Question: QuestionResource,
            Article: ArticleResource,
            Tag: TagResource,
            User: UserResource,
        }, 'content_object')

    def post_list(self, request, **kwargs):
        deserialized = self.deserialize(request,
                                        request.body,
                                        format=request.META.get(
                                            'CONTENT_TYPE',
                                            'application/json'))
        deserialized = self.alter_deserialized_detail_data(
            request, deserialized)
        bundle = self.build_bundle(data=dict_strip_unicode_keys(deserialized),
                                   request=request)
        content_object = self.content_object.hydrate(bundle).obj
        obj = Focus.objects.filter(
            user=bundle.request.user,
            content_type=ContentType.objects.get_for_model(content_object),
            object_id=content_object.id)
        if obj.exists():
            bundle = self.full_bundle(obj[0], bundle.request)
            super(FocusResource, self).obj_delete(bundle, **kwargs)
            return http.HttpNoContent()
        updated_bundle = self.obj_create(
            bundle, **self.remove_api_resource_names(kwargs))
        location = self.get_resource_uri(updated_bundle)

        if not self._meta.always_return_data:
            return http.HttpCreated(location=location)
        else:
            updated_bundle = self.full_dehydrate(updated_bundle)
            updated_bundle = self.alter_detail_data_to_serialize(
                request, updated_bundle)
            return self.create_response(request,
                                        updated_bundle,
                                        response_class=http.HttpCreated,
                                        location=location)

    def obj_create(self, bundle, **kwargs):
        return super(FocusResource, self).obj_create(bundle,
                                                     user=bundle.request.user)

    class Meta:
        queryset = Focus.objects.all()
        resource_name = 'focus'
        authentication = SessionAuthentication()
        authorization = DjangoAuthorization()
        list_allowed_methods = ['post']
        detail_allowed_methods = []
        always_return_data = True
Exemple #23
0
class SearchResource(Resource):
    item = GenericForeignKeyField(RESOURCE_MAP,
                                  'object',
                                  readonly=True,
                                  full=True,
                                  null=True)
    score = fields.FloatField(attribute='score',
                              readonly=True,
                              blank=True,
                              null=True)

    class Meta:
        resource_name = 'search'
        object_class = SearchObject
        authentication = CommonApiKeyAuthentication()

    def get_object_list(self, request):

        # for case no search
        from haystack.inputs import AutoQuery
        from haystack.query import SearchQuerySet

        params = request.GET

        sqs = SearchQuerySet()

        if len(params.getlist('content_type')):
            for content_type in params.getlist('content_type'):
                sqs = sqs.models(get_model(*content_type.split('.')))

        #if params.get('order_by'):
        #    sqs = sqs.order_by(params.get('order_by', ''))

        if params.get('q', ''):
            sqs = sqs.filter_or(content=AutoQuery(params.get('q', '').lower()))

        for k, v in params.iteritems():
            if k not in ['q', 'page', 'limit', 'content_type', 'order_by']:
                sqs = sqs.filter_or(**{k: v})

        limit = int(request.GET.get('limit', 20))

        page = int(request.GET.get('page', 1)) - 1
        object_list = sqs[page * limit:(page * limit + limit)]

        objects = []

        for result in object_list:
            objects.append(result)

        return objects

    def obj_get_list(self, bundle, **kwargs):
        # Filtering disabled for brevity...
        return self.get_object_list(bundle.request)
Exemple #24
0
    def test_get_related_resource(self):
        gfk_field = GenericForeignKeyField(
            {
                Note: NoteResource,
                Quote: QuoteResource
            }, 'nofield')

        definition_1 = Definition.objects.create(
            word='toast', content="Cook or brown (food, esp. bread or cheese)")

        # Test that you can not link to a model that does not have a resource
        with self.assertRaises(TypeError):
            gfk_field.get_related_resource(definition_1)

        note_1 = Note.objects.create(
            title='All aboard the rest train',
            content='Sometimes it is just better to lorem ipsum')

        self.assertTrue(
            isinstance(gfk_field.get_related_resource(note_1), NoteResource))
Exemple #25
0
    def test_get_related_resource(self):
        gfk_field = GenericForeignKeyField({
            Note: NoteResource,
            Quote: QuoteResource
        }, 'nofield')

        definition_1 = Definition.objects.create(
            word='toast',
            content="Cook or brown (food, esp. bread or cheese)"
        )

        # Test that you can not link to a model that does not have a resource
        with self.assertRaises(TypeError):
            gfk_field.get_related_resource(definition_1)

        note_1 = Note.objects.create(
            title='All aboard the rest train',
            content='Sometimes it is just better to lorem ipsum'
        )

        self.assertTrue(isinstance(gfk_field.get_related_resource(note_1), NoteResource))
Exemple #26
0
class HashTagged_ItemResource(ModelResource):

    user = fields.ForeignKey(UserResource, "user", full=True)

    content_object = GenericForeignKeyField(
        {
            HashTag: HashTagResource,
            User: UserResource
        }, 'content_object')

    class Meta:
        resource_name = 'hashtagged_item'
        queryset = HashTagged_Item.objects.all()
Exemple #27
0
    def test_resource_from_uri(self):
        note_2 = Note.objects.create(
            title='Generic and such',
            content='Sometimes it is to lorem ipsum'
        )

        gfk_field = GenericForeignKeyField({
            Note: NoteResource,
            Quote: QuoteResource
        }, 'nofield')

        request = MockRequest()
        request.GET = {'format': 'json'}
        request.method = 'GET'

        self.assertEqual(
            gfk_field.resource_from_uri(
                gfk_field.to_class(),
                '/api/v1/notes/%s/' % note_2.pk,
                request
            ).obj,
            note_2
        )
Exemple #28
0
class TimelineItemResource(ModelResource):
    # The GenericForeignKeyFields allows you to specify the related object
    # via its REST endpoint.  Any support models need to be listed in the
    # dict passed to GenericForeignKeyField
    content_object = GenericForeignKeyField({
        Event: EventResource,
    }, 'content_object')

    class Meta:
        queryset = TimelineItem.objects.filter(visible=True)
        resource_name = 'timeline-item'
        authorization = DjangoAuthorization()
        allowed_methods = ['post', 'get']
        always_return_data = True
Exemple #29
0
class ExportItemResource(ModelResource):

    export_session = fields.ForeignKey('exporter.api.ExportResource',
                                       'export_session',
                                       null=True,
                                       full=False)

    co_to = {
        Release: ReleaseResource,
        Artist: ArtistResource,
    }

    content_object = GenericForeignKeyField(to=co_to,
                                            attribute='content_object',
                                            null=False,
                                            full=False)

    class Meta:
        queryset = ExportItem.objects.all()
        list_allowed_methods = ['get', 'post']
        detail_allowed_methods = ['get', 'post', 'put', 'delete']
        resource_name = 'exportitem'
        # excludes = ['type','results_musicbrainz']
        #excludes = ['id',]
        authentication = MultiAuthentication(SessionAuthentication(),
                                             ApiKeyAuthentication())
        authorization = Authorization()
        always_return_data = True
        filtering = {
            'import_session': ALL_WITH_RELATIONS,
            'created': ['exact', 'range', 'gt', 'gte', 'lt', 'lte'],
        }

    def apply_authorization_limits(self, request, object_list):
        return object_list.filter(export_session__user=request.user)

    def obj_create(self, bundle, request, **kwargs):

        item = bundle.data['item']
        print bundle.data['item']['item_id']

        # dummy
        if item['item_type'] == 'release':
            co = Release.objects.get(pk=int(item['item_id']))

        bundle.data['content_object'] = co

        return super(ExportItemResource,
                     self).obj_create(bundle, request, **kwargs)
Exemple #30
0
class ResourceFileResource(ModelResource):
    content_object = GenericForeignKeyField(
        {GenericResource: GenericResourceResource}, 'content_object')

    class Meta:
        always_return_data = True
        queryset = ResourceFile.objects.all()
        resource_name = 'resource_file'
        filtering = {
            'id': 'exact',
        }
        authentication = MultiAuthentication(BasicAuthentication(),
                                             ApiKeyAuthentication(),
                                             SessionAuthentication())
        authorization = Authorization()
Exemple #31
0
class DublinCoreResource(ModelResource):
    content_object = GenericForeignKeyField(
        {GenericResource: GenericResourceResource}, 'content_object')

    class Meta:
        always_return_data = True
        queryset = QualifiedDublinCoreElement.objects.all()
        resource_name = 'dublincore'
        filtering = {
            'id': 'exact',
        }
        authentication = MultiAuthentication(BasicAuthentication(),
                                             ApiKeyAuthentication(),
                                             SessionAuthentication())
        #authorization = HydroshareAuthorization()
        authorization = Authorization()
Exemple #32
0
class ObjectACLAppResource(tardis.tardis_portal.api.ObjectACLResource):
    content_object = GenericForeignKeyField({
        Experiment: tardis.tardis_portal.api.ExperimentResource,
        # ...
    }, 'content_object')

    class Meta(tardis.tardis_portal.api.ObjectACLResource.Meta):
        # This will be mapped to <app_name>_experiment by MyTardis's urls.py
        # (eg /api/v1/sequencing_facility_objectacl/)
        resource_name = 'objectacl'
        authorization = AppACLAuthorization()

        filtering = {
            'pluginId': ('exact', ),
            'entityId': ('exact', ),
            'object_id': ('exact', ),
            'content_type': ('exact', ),
            'aclOwnershipType': ('exact', ),
        }
Exemple #33
0
class InviteResource(BaseResource):
    recipient = fields.ForeignKey(UserResource, attribute='recipient')
    content_object = GenericForeignKeyField({Question: QuestionResource},
                                            'content_object')

    def hydrate_recipient(self, bundle):
        recipient = bundle.data['recipient']
        try:
            if bundle.request.user.username == recipient:
                raise ApiFieldError("不能邀请自己")

            user = User.objects.get_by_natural_key(recipient)
            bundle.data['recipient'] = user
        except ObjectDoesNotExist:
            raise ApiFieldError("用户不存在")
        return bundle

    def save(self, bundle, skip_errors=False):
        obj = self.content_object.hydrate(bundle).obj
        if Invite.objects.filter(
                recipient=self.recipient.hydrate(bundle).obj,
                content_type=ContentType.objects.get_for_model(obj),
                object_id=obj.id).exists():
            raise ApiFieldError("用户邀请")

        return super(InviteResource, self).save(bundle, skip_errors)

    def obj_create(self, bundle, **kwargs):
        return super(InviteResource,
                     self).obj_create(bundle, sender=bundle.request.user)

    class Meta:
        queryset = Invite.objects.all()
        resource_name = 'invite'
        authentication = SessionAuthentication()
        authorization = DjangoAuthorization()
        list_allowed_methods = ['post']
        detail_allowed_methods = []
        always_return_data = True
Exemple #34
0
class ContentHideResource(ModelResource):
    user = fields.ForeignKey('accounts.api.BanyanUserResource', 'user')
    content_object = GenericForeignKeyField(
        {
            Story: StoryResource,
            Piece: PieceResource,
        }, 'content_object')

    class Meta:
        resource_name = 'hide_object'
        queryset = HiddenObject.objects.all()
        authentication = MultiAuthentication(ApiKeyAuthentication(),
                                             SessionAuthentication())
        authorization = Authorization()
        list_allowed_methods = ['post']
        detail_allowed_methods = []
        cache = SimpleCache()

    def hydrate_user(self, bundle):
        if bundle.request.user.is_authenticated():
            bundle.data['user'] = bundle.request.user
        return bundle