class Meta:
queryset = Tag.objects.all().order_by('-pk')
authentication = SessionAuthentication()
authorization = Authorization()
validation = FormValidation(form_class=TagForm)
filtering = {'value': ALL_WITH_RELATIONS, 'id': ALL_WITH_RELATIONS}
class Meta:
queryset = Group.objects.all()
always_return_data = True
resource_name = 'group'
authentication = MultiAuthentication(MultiApiKeyAuthentication(), SessionAuthentication())
authorization = RatticGroupAuthorization()
validation = FormValidation(form_class=GroupForm)
class Meta:
model = Feedback
queryset = Feedback.objects.order_by('-created_time')
fields = ['text']
allowed_methods = ['post']
authorization = PermissionAuthorization()
validation = FormValidation(form_class=FeedbackForm)
class Meta:
queryset = Subscriber.objects.all()
resource_name = 'subscribers'
authorization = Authorization()
list_allowed_methods = ['get', 'post']
detailed_allowed_methods = ['get', 'post']
validation = FormValidation(form_class=SubscriberForm)
def test_init(self):
self.assertRaises(ImproperlyConfigured, FormValidation)
try:
valid = FormValidation(form_class=NoteForm)
except Exception as e:
self.fail("Initialization failed when it should have succeeded.")
class Meta:
queryset = Model.objects.all()
authorization = get_table_data_auth(md)()
serializer = GeoJsonSerializer()
max_limit = None
validation = FormValidation(form_class=modelform_factory(
md.model_class(), exclude=('id', )))
class Meta:
queryset = User.objects.all()
resource_name = 'user'
always_return_data = True
excludes = ['password', 'is_active', 'is_staff', 'is_superuser']
authentication = Authentication()
authorization = Authorization()
validation = FormValidation(form_class=UserForm)
class Meta:
resource_name = 'notes'
queryset = Note.objects.all()
authorization = Authorization()
validation = FormValidation(form_class=NoteForm)
filtering = {
"created": ALL
}
class Meta:
resource_name = 'contact'
queryset = Contact.objects.all()
list_allowed_methods = ['get', 'post', 'put', 'delete', 'patch']
list_allowed_methods = ['get', 'post', 'put', 'delete', 'patch']
authentication = Authentication()
authorization = Authorization()
validation = FormValidation(form_class=ContactForm)
class Meta:
resource_name = 'banana/work-doc'
queryset = WorkDoc.objects.all()
include_absolute_url = True
allowed_methods = ['get', 'put']
validation = FormValidation(form_class=WorkDocForm)
authentication = SessionAuthentication()
authorization = WorkDocAuthorization()
class Meta:
resource_name = 'banana/gratitude'
queryset = Gratitude.objects.all()
include_absolute_url = True
allowed_methods = ['get', 'post', 'put', 'delete']
validation = FormValidation(form_class=GratitudeForm)
authentication = SessionAuthentication()
authorization = UserIsRequestorAuthorization()
class Meta:
queryset = Namespace.objects.all()
resource_name = 'peach/namespace'
fields = ['name', 'display_name', 'public', 'archive']
allowed_methods = ['get', 'put', 'post', 'delete']
validation = FormValidation(form_class=NamespaceForm)
authentication = SessionAuthentication()
authorization = NamespaceAuthorization(user_field_name='owner')
class Meta:
queryset = User.objects.all()
list_allowed_methods = ('post',)
detail_allowed_methods = ()
authentication = ConsumerAuthentication()
authorization = DjangoAuthorization()
validation = FormValidation(form_class=SignupFormFirstLastName)
resource_name = 'registration'
class Meta:
queryset = EventAction.objects.all()
list_allowed_methods = ('post', 'delete')
detail_allowed_methods = ()
authentication = ConsumerApiKeyAuthentication()
# FIXME should really be django auth | need to ass users to the appropriate user group
authorization = Authorization()
# authorization = DjangoAuthorization()
validation = FormValidation(form_class=EventActionForm)
class Meta:
model = Follow
queryset = Follow.objects.order_by('-created_time')
allowed_methods = ['get', 'post', 'delete']
always_return_data = True
fields = ['user', 'id', 'target']
authentication = SessionAuthentication()
authorization = PermissionAuthorization()
validation = FormValidation(form_class=FollowForm)
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}
class Meta:
queryset = Link.objects.all()
resource_name = 'link'
fields = ['url', 'is_public', 'is_archived', 'auto_update']
allow_methods = ['get', 'post', 'patch']
authentication = MultiAuthentication(SessionAuthentication(),
ApiKeyAuthentication())
authorization = Authorization()
validation = FormValidation(form_class=LinkForm)
class Meta:
queryset = TemplateScheme.objects.all()
resource_name = 'schemes'
filtering = {
'template': ALL_WITH_RELATIONS,
}
authorization = Authorization()
validation = FormValidation(form_class=forms.TemplateSchemeForm)
class Meta:
resource_name = 'campaign'
queryset = Campaign.objects_visible.all()
fields = ('name')
allowed_methods = ('get', 'post', 'put', 'delete', 'patch')
authorization = Auth('account')
always_return_data = True
validation = FormValidation(form_class=CampaignForm)
class Meta:
authorization = Auth('owner')
allowed_methods = ('get', 'post', 'get', 'put', 'delete')
always_return_data = True
filtering = {"is_deleted": (ALL)}
fields = ('name', 'id_random')
validation = FormValidation(form_class=AudienceForm)
queryset = Audience.objects.all()
resource_name = 'audience'
class Meta:
queryset = User.objects.all()
fields = ['email', 'name']
authentication = MultiAuthentication(UserResourceCustomAuthentication(), SessionAuthentication(), BasicAuthentication())
authorization = Authorization()
validation = FormValidation(form_class=UserCreationForm)
list_allowed_methods = []
detail_allowed_methods = ['get', 'post']
include_resource_uri = False
class Meta:
allowed_methods = ['post']
queryset = get_user_model().objects.all()
object_class = get_user_model()
always_return_data = True
authentication = Authentication()
authorization = Authorization()
validation = FormValidation(form_class=UserCreationForm)
fields = ['username']
class Meta:
queryset = Person.objects.all()
resource_name = 'person'
authorization = Authorization()
fields = ['first_name', 'last_name', 'phone_number']
filtering = {
"first_name": ('exact'),
"last_name": ('exact'),
}
validation = FormValidation(form_class=PersonForm)
class Meta:
queryset = Tag.objects.all()
always_return_data = True
filtering = {
'name': ('exact', 'contains', 'icontains', 'startswith', 'istartswith'),
}
resource_name = 'tag'
authentication = MultiAuthentication(SessionAuthentication(), MultiApiKeyAuthentication())
authorization = TagAuthorization()
validation = FormValidation(form_class=TagForm)
class Meta(ModelResource.Meta):
queryset = SellerPaypal.objects.filter()
excludes = ['id']
list_allowed_methods = ['post']
allowed_methods = ['get', 'put', 'patch']
resource_name = 'seller'
validation = FormValidation(form_class=SellerPaypalValidation)
filtering = {
'seller': ALL_WITH_RELATIONS,
}
class Meta:
queryset = DeviceToken.objects.all()
resource_name = 'devicetoken'
allowed_methods = [
'get',
'post',
]
authentication = OAuth20Authentication()
authorization = Authorization()
validation = FormValidation(form_class=DeviceTokenForm)
class Meta:
queryset = BaseCategoryRestriction.objects.all()
always_return_data = True
authentication = MultiAuthentication(SessionAuthentication(),
BasicAuthentication())
authorization = UserObjectsOnlyAuthorization()
validation = FormValidation(form_class=BaseCategoryRestrictionApiForm)
list_allowed_methods = ['get', 'post']
detail_allowed_methods = ['get', 'put', 'delete']
resource_name = "threshold/category"
class Meta:
model = List
queryset = List.objects.order_by("kind", "-modified_time")
fields = ['name', 'public', 'position', 'id', 'kind', 'count']
allowed_methods = ['get', 'put', 'post', 'delete']
always_return_data = True
authentication = SessionAuthentication()
authorization = ListAuthorization()
validation = FormValidation(form_class=ListForm)
def obj_create(self, bundle, **kwargs):
"Para el registro de usuario"
self._meta.validation = FormValidation(
form_class=CustomUserRegisterForm)
if 'social_network' in bundle.data:
bundle.data['password'] = '******'
bundle_created = super(CustomUserResource,
self).obj_create(bundle, **kwargs)
resp = self.full_dehydrate(bundle_created)
resp.data['status'] = 'ok'
return resp
class Meta:
resource_name = 'user'
allowed_methods = ['get','post','put','patch']
detail_allowed_methods = ['get', 'post', 'put', 'patch']
include_resource_uri = True
always_return_data = True
validation = FormValidation(form_class=UserForm)
authentication = Authentication()
authorization = UserAuthorization()
queryset = LtgUser.objects.all()
excludes = ['password','is_superuser','is_staff','is_active','date_joined','last_login']
def test_is_valid(self):
valid = FormValidation(form_class=NoteForm)
bundle = Bundle()
self.assertEqual(valid.is_valid(bundle), {
'is_active': [u'This field is required.'],
'slug': [u'This field is required.'],
'__all__': [u'Having no content makes for a very boring note.'],
'title': [u'This field is required.'],
})
bundle = Bundle(data={
'title': 'Foo.',
'slug': '123456789012345678901234567890123456789012345678901234567890',
'content': '',
'is_active': True,
})
self.assertEqual(valid.is_valid(bundle), {
'slug': [u'Ensure this value has at most 50 characters (it has 60).'],
'__all__': [u'Having no content makes for a very boring note.'],
})
bundle = Bundle(data={
'title': 'Foo.',
'slug': 'bar',
'content': '',
'is_active': True,
})
self.assertEqual(valid.is_valid(bundle), {
'__all__': [u'Having no content makes for a very boring note.'],
})
bundle = Bundle(data={
'title': 'Foo.',
'slug': 'bar',
'content': 'This! Is! CONTENT!',
'is_active': True,
})
self.assertEqual(valid.is_valid(bundle), {})
# NOTE: Bundle data is left untouched!
self.assertEqual(bundle.data['title'], 'Foo.')