def setUp(self): self.item_resource = ItemResource() self.bar_resource = BarResource() self.foo_resource = FooResource() api = Api(name='v1') api.register(self.item_resource) api.register(self.bar_resource) api.register(self.foo_resource) self.bar_ctype = ContentType.objects.get(name='bar')
def __init__(self, *app_names): """ app_names: One or more fully qualified django app names ie: api = AutoAPI('django.contrib.auth', 'example') """ self.api = Api() apps = [] if app_names: for app in app_names: app = load_app(app) apps.append(app) else: # Add all the apps if none are specified apps = get_apps() for app in apps: self.register_app(app)
def setUp(self): class TestResource(ModelResource): class Meta(ModelResource.Meta): model = GeoBar default_filters = { 'name__gte': 'beta', 'name__lte': 'zeta' } allowed_filters = [ 'name__lte', ] allowed_ordering = [ '-name', ] self.resource = TestResource() self.resource.Meta.api = Api(name='v1') # # setup a specific geodjango resource to test # class GeoTestResource(ModelResource): class Meta(ModelResource.Meta): model = GeoBar default_filters = { } # only test some of the default geometry filters allowed_filters = [ 'geom__bbcontains', 'geom__contains', 'geom__intersects', ] allowed_ordering = [ ] self.georesource = GeoTestResource() self.georesource.Meta.api = Api(name='v1') # # setup some default geom types to use throughout tests # self.point = Point(-122.306814, 47.266380) self.line = LineString( (-123.296814,47.066380), (-121.324768,48.370848) ) self.poly = Polygon( ((-123.296814,47.066380), (-123.296814,48.370848), (-121.324768,48.370848), (-121.324768,47.066380), (-123.296814,47.066380)) ) self.poly2 = Polygon( ((0, 0), (0, 1), (1, 1), (0, 0)) ) self.multipoly = MultiPolygon( self.poly, self.poly2 ) self.invalid_point_wkt = 'POINT( -2000, -2000 )'
def __init__(self, *app_names, **options): """ app_names: One or more fully qualified django app names ie: api = AutoAPI('django.contrib.auth', 'example') """ self.api_app_name = options.get('folder') if self.api_app_name is None: self.api_app_name = 'api' self.api = Api() selected_apps = get_apps(*app_names) for app in selected_apps: self.register_app(app)
def setUp(self): class TestResource(ModelResource): class Meta(ModelResource.Meta): model = Bar default_filters = {'name__gte': 'beta', 'name__lte': 'zeta'} allowed_filters = [ 'name__lte', ] allowed_ordering = [ '-name', ] self.resource = TestResource() self.resource.Meta.api = Api(name='v1')
def setUp(self): super(UriTestCase, self).setUp() # create resource class TestResource(ModelResource): class Meta(ModelResource.Meta): model = Bar pk_field = 'name' resource_name = 'custom_pk' self.resource = TestResource() self.resource.Meta.api = Api(name="v1") self.resource.Meta.api.register(TestResource()) # override urls self.original_urls = example.urls.urlpatterns example.urls.urlpatterns += patterns( '', url(r'^api/', include(self.resource.Meta.api.urls)))
class Meta(ModelResource.Meta): model = Foo api = Api(name='v1')
def setUp(self): super(ResourceFormatTestCase, self).setUp() # # create a resource as just functions # class TestResourceAsFunc(ModelResource): class Meta(ModelResource.Meta): conduit = ( 'conduit.test.conduit_formats.build_pub', 'conduit.test.conduit_formats.return_response', ) model = Bar pk_field = 'id' self.resource_as_func = TestResourceAsFunc() self.resource_as_func.Meta.api = Api(name="v1") self.resource_as_func.Meta.api.register(TestResourceAsFunc()) # # create a resource as a mixin class ( w/ explit paths ) # class TestResourceAsMixin(ModelResource, ConduitBaseMixin): class Meta(ModelResource.Meta): conduit = ( 'conduit.test.conduit_formats.ConduitBaseMixin.build_pub', 'conduit.test.conduit_formats.ConduitBaseMixin.return_response', ) model = Bar pk_field = 'id' self.resource_as_mixin = TestResourceAsMixin() self.resource_as_mixin.Meta.api = Api(name="v1") self.resource_as_mixin.Meta.api.register(TestResourceAsMixin()) # # create a recommended resource ( no super class ) # class TestResourceAsContext(ModelResource): class Meta(ModelResource.Meta): conduit = ( 'conduit.test.conduit_formats.ConduitBaseMixin.build_pub', 'conduit.test.conduit_formats.ConduitBaseMixin.return_response', ) model = Bar pk_field = 'id' self.resource_as_context = TestResourceAsContext() self.resource_as_context.Meta.api = Api(name="v1") self.resource_as_context.Meta.api.register(TestResourceAsContext()) # # create a recommended resource ( no super class ) # where the Mixin methods we call will call into # private methods # class TestResourceAsPrivateer(ModelResource): class Meta(ModelResource.Meta): conduit = ( 'conduit.test.conduit_formats.ConduitMixinPrivateer.build_pub', 'conduit.test.conduit_formats.ConduitMixinPrivateer.return_response', ) model = Bar pk_field = 'id' self.resource_as_priv = TestResourceAsPrivateer() self.resource_as_priv.Meta.api = Api(name="v1") self.resource_as_priv.Meta.api.register(TestResourceAsPrivateer()) # override urls self.original_urls = example.urls.urlpatterns example.urls.urlpatterns += patterns( '', url(r'^api_as_func/', include(self.resource_as_func.Meta.api.urls)), url(r'^api_as_mixin/', include(self.resource_as_mixin.Meta.api.urls)), url(r'^api_as_context/', include(self.resource_as_context.Meta.api.urls)), url(r'^api_as_priv/', include(self.resource_as_priv.Meta.api.urls)))
## api/urls.py from django.conf.urls import patterns, include, url from conduit.api import Api from api.views import ( GeoBarResource, GeoBazResource, GeoFooResource ) api = Api() # register geomanager resources api.register(GeoBarResource()) api.register(GeoBazResource()) api.register(GeoFooResource()) urlpatterns = patterns('', url(r'^', include(api.urls)) )
class AutoAPI(object): """ Automatically create sample APIs from Django Apps or Models """ def __init__(self, *app_names): """ app_names: One or more fully qualified django app names ie: api = AutoAPI('django.contrib.auth', 'example') """ self.api = Api() apps = [] if app_names: for app in app_names: app = load_app(app) apps.append(app) else: # Add all the apps if none are specified apps = get_apps() for app in apps: self.register_app(app) def __to_string__(self): buff = '' buff += self.__resource_str__() buff += '\n\n\n' buff += self.__urlconf_str__() return buff def __urlconf_str__(self): buff = '## api/urls.py' buff += '\nfrom django.conf.urls import patterns, include, url' buff += '\nfrom conduit.api import Api' # Resource import string import_tmp = '\nfrom api.views import {0}' res_names = [res.Meta.model.__name__ + 'Resource' for res in self.api._resources] buff += import_tmp.format(', '.join(res_names)) buff += '\n\n' # Api Register strings buff += "\napi = Api(name='v1')" for res_name in res_names: buff += '\napi.register({0}())'.format(res_name) # Urlpatterns buff += "\n\nurlpatterns = patterns(''," buff += "\n url(r'^', include(api.urls))" buff += "\n)" buff += '\n' return buff def __resource_str__(self): resources_str = '## api/views.py' # Add improt strings resources_str += '\nfrom conduit.api import ModelResource' resources_str += '\nfrom conduit.api.fields import ForeignKeyField, ManyToManyField' for app_name, models in self.api._app_models.items(): resources_str += '\nfrom {0} import {1}'.format(app_name, ', '.join(models)) # Add resource class strings for res in self.api._resources: resources_str += '\n\n' resources_str += res.__to_string__() resources_str += '\n' return resources_str def _get_related_fields_by_name(self, model): related_fields = {} opts = getattr(model, '_meta', None) if opts: for f in opts.get_all_field_names(): field, model, direct, m2m = opts.get_field_by_name(f) if direct and field.rel: related_fields[field.name] = field return related_fields def _gen_resource(self, model): class AutoModelResource(SelfDescModelResource): class Meta(SelfDescModelResource.Meta): pass class Fields(SelfDescModelResource.Fields): pass AutoModelResource.Meta.model = model return AutoModelResource def _add_related(self, resource_instance): model = resource_instance.Meta.model related_fields = self._get_related_fields_by_name(model) # Iterate through related fields for name, field in related_fields.items(): related_model = field.related.parent_model # If a resource already exists on the api with this model # use that resource related_resource_instance = self.api._by_model.get(related_model, [None])[0] if related_resource_instance: related_resource = related_resource_instance.__class__ # Otherwise we create a new resource and attach it to the api else: related_resource = self._gen_resource(model) related_resource_instance = related_resource() self.api.register(related_resource_instance) # Update our parent resource instance to use related fields if hasattr(field.rel, 'through'): setattr(resource_instance.Fields, name, ManyToManyField(attribute=name, resource_cls=related_resource)) else: setattr(resource_instance.Fields, name, ForeignKeyField(attribute=name, resource_cls=related_resource)) return resource_instance def register_model(self, model): resource = self._gen_resource(model) resource_instance = resource() self.api.register(resource_instance) resource_instance = self._add_related(resource_instance) def register_app(self, app): app_models = get_models(app) # Save reference of model names from model module # Used in auto string generation app_models_names = [model.__name__ for model in app_models] self.api._app_models.update({app.__name__: app_models_names}) for model in app_models: self.register_model(model) @property def urls(self): return self.api.urls
class Meta(ModelResource.Meta): model = GeoBaz api = Api(name='v1')
## api/urls.py from django.conf.urls import patterns, include, url from conduit.api import Api from api.views import ( BarResource, BazResource, ContentTypeResource, FooResource, ItemResource, ) api = Api() api.register(BarResource()) api.register(BazResource()) api.register(ContentTypeResource()) api.register(FooResource()) api.register(ItemResource()) urlpatterns = patterns('', url(r'^', include(api.urls)) )
## api/urls.py from django.conf.urls import patterns, include, url from conduit.api import Api from api.views import BarResource, BazResource, FooResource api = Api() api.register(BarResource()) api.register(BazResource()) api.register(FooResource()) urlpatterns = patterns('', url(r'^', include(api.urls)) )