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)))
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')
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))
)
