Ejemplo n.º 1
0
    def test_custom_api_serializer(self):
        """Confirm that an Api can use a custom serializer"""

        # Origin: https://github.com/django-tastypie/django-tastypie/pull/817

        class JSONSerializer(Serializer):
            formats = ('json', )

        api = Api(serializer_class=JSONSerializer)
        api.register(NoteResource())

        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'], 'application/json',
                         msg="Expected application/json response but received %s" % resp['content-type'])

        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'application/xml'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'], 'application/json',
                         msg="Expected application/json response but received %s" % resp['content-type'])
Ejemplo n.º 2
0
    def test_top_level_include_schema_content(self):
        api = Api()

        note_resource = NoteResource()
        user_resource = UserResource()

        api.register(note_resource)
        api.register(user_resource)

        request = HttpRequest()
        request.GET = {'fullschema': 'true'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)

        content = json.loads(resp.content.decode('utf-8'))

        content['notes']['schema'] = adjust_schema(content['notes']['schema'])
        content['users']['schema'] = adjust_schema(content['users']['schema'])

        dummy_request = HttpRequest()
        dummy_request.method = 'GET'

        notes_schema = adjust_schema(json.loads(note_resource.get_schema(dummy_request).content.decode('utf-8')))
        user_schema = adjust_schema(json.loads(user_resource.get_schema(dummy_request).content.decode('utf-8')))

        self.assertEqual(content['notes']['list_endpoint'], '/api/v1/notes/')
        self.assertEqual(content['notes']['schema'], notes_schema)

        self.assertEqual(content['users']['list_endpoint'], '/api/v1/users/')
        self.assertEqual(content['users']['schema'], user_schema)
Ejemplo n.º 3
0
    def test_top_level_jsonp(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {"HTTP_ACCEPT": "text/javascript"}
        request.GET = {"callback": "foo"}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
        self.assertEqual(
            resp.content.decode("utf-8"),
            'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
        )

        request = HttpRequest()
        request.META = {"HTTP_ACCEPT": "text/javascript"}
        request.GET = {"callback": ""}

        try:
            resp = api.top_level(request)
            self.fail("Broken callback didn't fail!")
        except BadRequest:
            # Regression: We expect this, which is fine, but this used to
            #             be an import error.
            pass
Ejemplo n.º 4
0
def get_urls(version=1):
    api = Api(api_name='auth')

    if version == 1:
        api.register(User())

    return api.urls
Ejemplo n.º 5
0
    def test_top_level_include_schema_content(self):
        api = Api()

        note_resource = NoteResource()
        user_resource = UserResource()

        api.register(note_resource)
        api.register(user_resource)

        request = HttpRequest()
        request.GET = {"fullschema": "true"}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)

        content = json.loads(resp.content.decode("utf-8"))

        content["notes"]["schema"] = adjust_schema(content["notes"]["schema"])
        content["users"]["schema"] = adjust_schema(content["users"]["schema"])

        dummy_request = HttpRequest()
        dummy_request.method = "GET"

        notes_schema = adjust_schema(json.loads(note_resource.get_schema(dummy_request).content.decode("utf-8")))
        user_schema = adjust_schema(json.loads(user_resource.get_schema(dummy_request).content.decode("utf-8")))

        self.assertEqual(content["notes"]["list_endpoint"], "/api/v1/notes/")
        self.assertEqual(content["notes"]["schema"], notes_schema)

        self.assertEqual(content["users"]["list_endpoint"], "/api/v1/users/")
        self.assertEqual(content["users"]["schema"], user_schema)
Ejemplo n.º 6
0
def get_urls(version=1):
    api = Api(api_name='common')

    if version == 1:
        api.register(Country())

    return api.urls
Ejemplo n.º 7
0
def named_api(api_name):
    """ api_name is the version part of the api path
    """
    new_api = Api(api_name=api_name)

    for resource in resources.__all__:
        new_api.register(getattr(resources, resource)())
    return new_api
Ejemplo n.º 8
0
def get_api():
	# create the naespaces for the applications
	api = Api(api_name='simpleapp')
	api.register(TypeResource())
	api.register(ProductResource())
	
	base_path_regex = r'^api/v1/'
	return base_path_regex,api
Ejemplo n.º 9
0
    def test_top_level(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content.decode('utf-8'), '{"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}}')
Ejemplo n.º 10
0
 def test_top_level(self):
     api = Api()
     api.register(NoteResource())
     api.register(UserResource())
     request = HttpRequest()
     
     resp = api.top_level(request)
     self.assertEqual(resp.status_code, 200)
     self.assertEqual(resp.content, '{"notes": "/api/v1/notes/", "users": "/api/v1/users/"}')
Ejemplo n.º 11
0
def build_api_urls():
    v1_api = Api(api_name='v1')
    v1_api.register(VideoResource())
    v1_api.register(CategoryResource())

    return patterns(
        'richard.videos.views',

        (r'^api/', include(v1_api.urls)),
        )
Ejemplo n.º 12
0
def resouce_autodiscover(api_name="v1", api_module_name="api"):
    api = Api(api_name=api_name)
    for app in settings.INSTALLED_APPS:
        try:
            resorce_api = import_module('%s.%s' % (app, api_module_name))
            for resource_klass_name in resorce_api.__all__:
                resource_klass = getattr(resorce_api, resource_klass_name)
                api.register(resource_klass())
        except:
            continue
    return api
Ejemplo n.º 13
0
    def test_jsonp_not_on_by_default(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}
        request.GET = {'callback': 'foo'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'].split(';')[0], 'application/json')
        self.assertFalse("foo" in resp.content.decode('utf-8'))
Ejemplo n.º 14
0
def resouce_autodiscover():
    from django.conf import settings
    from django.utils.importlib import import_module
    v1_api = Api(api_name='v1')
    for app in settings.INSTALLED_APPS:
        try:
            resorce_api = import_module('%s.api' % app)
            for resource_klass_name in resorce_api.__all__:
                resource_klass = getattr(resorce_api, resource_klass_name)
                v1_api.register(resource_klass())
        except:
            continue
    return v1_api
Ejemplo n.º 15
0
    def test_top_level_jsonp(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {"HTTP_ACCEPT": "text/javascript"}
        request.GET = {"callback": "foo"}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp["content-type"].split(";")[0], "text/javascript")
        self.assertEqual(
            resp.content,
            'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})',
        )
Ejemplo n.º 16
0
def api_factory():
    API_VERSION = 'v1'
    pootle_api = Api(api_name=API_VERSION)
    pootle_api.register(LanguageResource())
    pootle_api.register(ProjectResource())
    pootle_api.register(TranslationProjectResource())
    return pootle_api
Ejemplo n.º 17
0
    def __init__(self, resources):
        self.tastypieApi = TastypieApi(api_name='resources')
        self.dummy_resources = []
        self.resources = {}

        for resource_class in resources:
            resource = resource_class()
            self.resources[resource._meta.resource_name] = resource
            self.tastypieApi.register(resource)
Ejemplo n.º 18
0
    def test_global_registry(self):
        tastypie.available_apis = {}
        api = Api()
        self.assertEqual(len(api._registry), 0)
        self.assertEqual(len(tastypie.available_apis), 0)

        api.register(NoteResource())
        self.assertEqual(len(api._registry), 1)
        self.assertEqual(sorted(api._registry.keys()), ["notes"])
        self.assertEqual(len(tastypie.available_apis), 1)
        self.assertEqual(tastypie.available_apis["v1"]["class"], api)
        self.assertEqual(tastypie.available_apis["v1"]["resources"], ["notes"])
        self.assertEqual(tastypie.available_apis["v1"]["representations"], {"NoteRepresentation": "notes"})

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
        self.assertEqual(len(tastypie.available_apis), 1)
        self.assertEqual(tastypie.available_apis["v1"]["class"], api)
        self.assertEqual(tastypie.available_apis["v1"]["resources"], ["notes", "users"])
        self.assertEqual(
            tastypie.available_apis["v1"]["representations"],
            {"UserRepresentation": "users", "NoteRepresentation": "notes"},
        )

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
        self.assertEqual(len(tastypie.available_apis), 1)
        self.assertEqual(tastypie.available_apis["v1"]["class"], api)
        self.assertEqual(tastypie.available_apis["v1"]["resources"], ["notes", "users"])
        self.assertEqual(
            tastypie.available_apis["v1"]["representations"],
            {"UserRepresentation": "users", "NoteRepresentation": "notes"},
        )

        self.assertEqual(len(api._canonicals), 2)
        api.register(UserResource(), canonical=False)
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
        self.assertEqual(len(api._canonicals), 2)
        self.assertEqual(len(tastypie.available_apis), 1)
        self.assertEqual(tastypie.available_apis["v1"]["class"], api)
        self.assertEqual(tastypie.available_apis["v1"]["resources"], ["notes", "users"])
        self.assertEqual(
            tastypie.available_apis["v1"]["representations"],
            {"UserRepresentation": "users", "NoteRepresentation": "notes"},
        )
Ejemplo n.º 19
0
class Api:
    def __init__(self, resources):
        self.tastypieApi = TastypieApi(api_name='resources')
        self.dummy_resources = []
        self.resources = {}

        for resource_class in resources:
            resource = resource_class()
            self.resources[resource._meta.resource_name] = resource
            self.tastypieApi.register(resource)


    @property
    def urls(self):
        from django.conf.urls.defaults import url, patterns
        from dummy import DummyResource
        
        pattern_list =  []
        for resource_name, resource in self.resources.items():
            if resource_name in self.dummy_resources:
                pattern_list.append(
                    (r"^resources/%s/(\d*)/?$" % resource_name, DummyResource.get_view(resource)))

        urls = patterns("",*pattern_list)
        urls += self.tastypieApi.urls
        return urls

    def get_resource_list_uri(self, resource_name):
        return self.resources[resource_name].get_resource_list_uri()

    def get_resource_example_data(self, resource_name, method):
        return self.resources[resource_name].get_example_data(method)

    def resource_allows_method(self, resource_name, method):
        return method.lower() in self.resources[resource_name]._meta.allowed_methods


    def dehydrate(self,request, resource_name, obj):
        resource = self.resources[resource_name]
        bundle = resource.build_bundle(obj=obj, request=request)
        bundle = resource.full_dehydrate(bundle)
        return bundle.data
Ejemplo n.º 20
0
    def test_canonical_resource_for(self):
        tastypie.available_apis = {}
        api = Api()
        note_resource = NoteResource()
        user_resource = UserResource()
        api.register(note_resource)
        api.register(user_resource)
        self.assertEqual(len(api._canonicals), 2)

        self.assertEqual(isinstance(api.canonical_resource_for("notes"), NoteResource), True)

        api_2 = Api()
        self.assertRaises(URLReverseError, tastypie._get_canonical_resource_name, api_2, NoteRepresentation)
        self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, NoteRepresentation), "notes")
        self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, NoteRepresentation()), "notes")
        self.assertEqual(
            tastypie._get_canonical_resource_name(api.api_name, note_resource.detail_representation), "notes"
        )
        self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, UserRepresentation), "users")
        self.assertEqual(tastypie._get_canonical_resource_name(api.api_name, UserRepresentation()), "users")
        self.assertEqual(
            tastypie._get_canonical_resource_name(api.api_name, user_resource.detail_representation), "users"
        )

        api.unregister(user_resource.resource_name)
        self.assertRaises(NotRegistered, api.canonical_resource_for, "users")
Ejemplo n.º 21
0
    def test_top_level_jsonp(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}
        request.GET = {'callback': 'foo'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'].split(';')[0], 'text/javascript')
        self.assertEqual(resp.content, 'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})')

        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}
        request.GET = {'callback': ''}

        try:
            resp = api.top_level(request)
            self.fail("Broken callback didn't fail!")
        except BadRequest:
            # Regression: We expect this, which is fine, but this used to
            #             be an import error.
            pass
Ejemplo n.º 22
0
    def test_register(self):
        api = Api()
        self.assertEqual(len(api._registry), 0)

        api.register(NoteResource())
        self.assertEqual(len(api._registry), 1)
        self.assertEqual(sorted(api._registry.keys()), ["notes"])

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])

        self.assertEqual(len(api._canonicals), 2)
        api.register(UserResource(), canonical=False)
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
        self.assertEqual(len(api._canonicals), 2)
Ejemplo n.º 23
0
 def test_global_registry(self):
     api = Api()
     self.assertEqual(len(api._registry), 0)
     
     api.register(NoteResource())
     self.assertEqual(len(api._registry), 1)
     self.assertEqual(sorted(api._registry.keys()), ['notes'])
     
     api.register(UserResource())
     self.assertEqual(len(api._registry), 2)
     self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
     
     api.register(UserResource())
     self.assertEqual(len(api._registry), 2)
     self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
     
     self.assertEqual(len(api._canonicals), 2)
     api.register(UserResource(), canonical=False)
     self.assertEqual(len(api._registry), 2)
     self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
     self.assertEqual(len(api._canonicals), 2)
Ejemplo n.º 24
0
    def test_canonical_resource_for(self):
        api = Api()
        note_resource = NoteResource()
        user_resource = UserResource()
        api.register(note_resource)
        api.register(user_resource)
        self.assertEqual(len(api._canonicals), 2)

        self.assertEqual(isinstance(api.canonical_resource_for('notes'), NoteResource), True)
        api.unregister(user_resource._meta.resource_name)
        self.assertRaises(NotRegistered, api.canonical_resource_for, 'users')
Ejemplo n.º 25
0
    def test_register(self):
        # NOTE: these have all been registered in core.tests.api_urls
        api = Api()
        self.assertEqual(len(api._registry), 0)

        api.register(NoteResource())
        self.assertEqual(len(api._registry), 1)
        self.assertEqual(sorted(api._registry.keys()), ['notes'])

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])

        self.assertEqual(len(api._canonicals), 2)
        api.register(UserResource(), canonical=False)
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ['notes', 'users'])
        self.assertEqual(len(api._canonicals), 2)
Ejemplo n.º 26
0
    def test_register(self):
        # NOTE: these have all been registered in core.tests.api_urls
        api = Api()
        self.assertEqual(len(api._registry), 0)

        api.register(NoteResource())
        self.assertEqual(len(api._registry), 1)
        self.assertEqual(sorted(api._registry.keys()), ["notes"])

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])

        api.register(UserResource())
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])

        self.assertEqual(len(api._canonicals), 2)
        api.register(UserResource(), canonical=False)
        self.assertEqual(len(api._registry), 2)
        self.assertEqual(sorted(api._registry.keys()), ["notes", "users"])
        self.assertEqual(len(api._canonicals), 2)

        self.assertRaises(ValueError, api.register, NoteResource)
Ejemplo n.º 27
0
 def test_urls(self):
     api = Api()
     api.register(NoteResource())
     api.register(UserResource())
     
     patterns = api.urls
     self.assertEqual(len(patterns), 3)
     self.assertEqual(sorted([pattern.name for pattern in patterns if hasattr(pattern, 'name')]), ['api_v1_top_level'])
     self.assertEqual([[pattern.name for pattern in include.url_patterns if hasattr(pattern, 'name')] for include in patterns if hasattr(include, 'reverse_dict')], [['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail'], ['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail']])
     
     api = Api(api_name='v2')
     api.register(NoteResource())
     api.register(UserResource())
     
     patterns = api.urls
     self.assertEqual(len(patterns), 3)
     self.assertEqual(sorted([pattern.name for pattern in patterns if hasattr(pattern, 'name')]), ['api_v2_top_level'])
     self.assertEqual([[pattern.name for pattern in include.url_patterns if hasattr(pattern, 'name')] for include in patterns if hasattr(include, 'reverse_dict')], [['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail'], ['api_dispatch_list', 'api_get_schema', 'api_get_multiple', 'api_dispatch_detail']])
Ejemplo n.º 28
0
    def test_urls(self):
        api = Api()
        api.register(NoteResource())
        api.register(UserResource())

        patterns = api.urls
        self.assertEqual(len(patterns), 3)
        self.assertEqual(
            sorted([pattern.name for pattern in patterns if hasattr(pattern, "name")]), ["api_v1_top_level"]
        )
        self.assertEqual(
            [
                [pattern.name for pattern in include.url_patterns if hasattr(pattern, "name")]
                for include in patterns
                if hasattr(include, "reverse_dict")
            ],
            [
                ["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
                ["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
            ],
        )

        api = Api(api_name="v2")
        api.register(NoteResource())
        api.register(UserResource())

        patterns = api.urls
        self.assertEqual(len(patterns), 3)
        self.assertEqual(
            sorted([pattern.name for pattern in patterns if hasattr(pattern, "name")]), ["api_v2_top_level"]
        )
        self.assertEqual(
            [
                [pattern.name for pattern in include.url_patterns if hasattr(pattern, "name")]
                for include in patterns
                if hasattr(include, "reverse_dict")
            ],
            [
                ["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
                ["api_dispatch_list", "api_get_schema", "api_get_multiple", "api_dispatch_detail"],
            ],
        )
Ejemplo n.º 29
0
    def test_top_level_jsonp(self):
        api = Api()
        api.serializer.formats = ['jsonp']
        api.register(NoteResource())
        api.register(UserResource())
        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}
        request.GET = {'callback': 'foo'}

        resp = api.top_level(request)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp['content-type'].split(';')[0], 'text/javascript')
        self.assertEqual(resp.content.decode('utf-8'), 'foo({"notes": {"list_endpoint": "/api/v1/notes/", "schema": "/api/v1/notes/schema/"}, "users": {"list_endpoint": "/api/v1/users/", "schema": "/api/v1/users/schema/"}})')

        request = HttpRequest()
        request.META = {'HTTP_ACCEPT': 'text/javascript'}
        request.GET = {'callback': ''}

        # Regression: We expect this, which is fine, but this used to
        #             be an import error.
        with self.assertRaises(BadRequest):
            api.top_level(request)
Ejemplo n.º 30
0
The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/3.0/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  path('', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.urls import include, path
    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from api.resources import  UserResource, DescriptionResource
from tastypie.api import Api

v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(DescriptionResource())


urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^api/', include(v1_api.urls)),

]

Ejemplo n.º 31
0
from django.conf.urls import patterns, include, url
from django.contrib import admin
from tastypie.api import Api
from telostats.stations.api import StationResource, SeriesResource

admin.autodiscover()

v1_api = Api(api_name='v1')
v1_api.register(StationResource())
v1_api.register(SeriesResource())

urlpatterns = patterns(
    '',
    url(r'^', include('telostats.stations.urls')),
    url(r'^api/', include(v1_api.urls)),
    url(r'^admin/', include(admin.site.urls)),
)
Ejemplo n.º 32
0
from tastypie.api import Api
from .api import (
    DeviceTokenResource,
    PhotoResource,
    UserResource,
    DentistProfileResource,
    AppointmentResource,
    EmergencyScheduleResource,
    NotificationResource,
    BookResource,
    UserCreateResource,
    UserProfileResource,
    NoteResource,
)

v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(DeviceTokenResource())
v1_api.register(PhotoResource())
v1_api.register(DentistProfileResource())
v1_api.register(AppointmentResource())
v1_api.register(EmergencyScheduleResource())
v1_api.register(NotificationResource())
v1_api.register(BookResource())
v1_api.register(UserCreateResource())
v1_api.register(UserProfileResource())
v1_api.register(NoteResource())

urlpatterns = patterns(
    '',
    (r'^', include(v1_api.urls)),
Ejemplo n.º 33
0
from django.conf.urls import include, patterns, url

from tastypie.api import Api

from mkt.abuse.resources import AppAbuseResource, UserAbuseResource

# Abuse API.
abuse = Api(api_name='abuse')
abuse.register(UserAbuseResource())
abuse.register(AppAbuseResource())

api_patterns = patterns('',
    url('^', include(abuse.urls)),
)
Ejemplo n.º 34
0
class ApiViewTestCase(TestCase):
    def setUp(self):
        super().setUp()
        self.api = Api(api_name='v1')

    def tearDown(self):
        self.clear_resource()

    def clear_resource(self):
        for _url in urlpatterns:
            if str(_url.pattern) == '^api/':
                urlpatterns.remove(_url)

    def register_resource(self, resource):
        self.api.register(resource)
        urlpatterns.append(url(r'^api/', include(self.api.urls)), )

    def test__is_api(self):
        """
        测试is_api是否有效
        :return:
        """
        class UserResource(BaseModelResource):
            class Meta:
                queryset = User.objects.all()
                resource_name = 'user'

            @api_view()
            def a(self, request, *args, **kwargs):
                return self.create_response(request)

        user_resource = UserResource()
        self.register_resource(user_resource)
        r = self.client.get('/api/v1/user/a/')
        self.assertEqual('{"_code": 0, "_message": ""}', r.content.decode())
        self.assertEqual('user_a', user_resource.prepend_url_list[0].name)
        self.assertEqual('^(?P<resource_name>user)/a/',
                         str(user_resource.prepend_url_list[0].pattern))

    def test_url_path_and_url_name(self):
        """
        测试定制url_name 和 url_path
        :return:
        """
        class UserResource(BaseModelResource):
            class Meta:
                object_class = User
                resource_name = 'test_url_path_and_url_name'

            @api_view(url_name='test_url_name', url_path='test_url_path')
            def a(self, request, *args, **kwargs):
                return self.create_response(request)

        user_resource = UserResource()
        self.register_resource(user_resource)
        r = self.client.get(
            '/api/v1/test_url_path_and_url_name/test_url_path/')
        self.assertEqual('{"_code": 0, "_message": ""}', r.content.decode())
        self.assertEqual('test_url_name',
                         user_resource.prepend_url_list[0].name)
        self.assertEqual(
            '^(?P<resource_name>test_url_path_and_url_name)/test_url_path/',
            str(user_resource.prepend_url_list[0].pattern))

    def _test_method(self, method: str):
        now_resource_name = f'test_method_check_{method}'

        class UserResource(BaseModelResource):
            class Meta:
                object_class = User
                resource_name = now_resource_name

            @api_view(allowed_methods=[method])
            def a(self, request, *args, **kwargs):
                return self.create_response(request)

        user_resource = UserResource()
        self.register_resource(user_resource)
        r = self.client.get(f'/api/v1/{now_resource_name}/a/')
        if method == 'get':
            self.assertEqual(200, r.status_code)
        else:
            self.assertEqual(405, r.status_code)
        r = self.client.post(f'/api/v1/{now_resource_name}/a/')
        if method == 'post':
            self.assertEqual(200, r.status_code)
        else:
            self.assertEqual(405, r.status_code)

    def test_method_check(self):
        """
        测试allowed_methods是否有效
        :return:
        """
        self._test_method('get')
        self._test_method('post')

    def test_auth(self):
        """
        测试auth选项是否有效
        :return:
        """
        class TestAuthentication(Authentication):
            def is_authenticated(self, request, **kwargs):
                return False

        class UserResource(BaseModelResource):
            class Meta:
                object_class = User
                resource_name = 'test_auth'
                authentication = TestAuthentication()

            @api_view(auth=True)
            def a(self, request, *args, **kwargs):
                return self.create_response(request, {})

        user_resource = UserResource()
        self.register_resource(user_resource)
        r = self.client.get('/api/v1/test_auth/a/')
        self.assertEqual(401, r.status_code)

    def test_single_api(self):
        """
        测试单个对象的api
        :return:
        """
        test_pk = 'e7f7d55a-4c45-4c45-a0b4-6724435168d7'
        test_case = self

        class UserResource(BaseModelResource):
            class Meta:
                object_class = User
                resource_name = 'test_single_api'
                queryset = User.objects.all()

            @api_view(single_api=True)
            def a(self, request, pk, *args, **kwargs):
                test_case.assertEqual(test_pk, pk)
                return self.create_response(request)

        user_resource = UserResource()
        self.register_resource(user_resource)
        r = self.client.get(
            '/api/v1/test_single_api/67ed3642-7b63-4f84-80b0-6cbdafac7253/')

        self.assertEqual(404, r.status_code)
        r = self.client.get(f'/api/v1/test_single_api/{test_pk}/a/')
        self.assertEqual(200, r.status_code)
Ejemplo n.º 35
0
# along with this program; if not, see <http://www.gnu.org/licenses/>.

from django.conf import settings
from django.conf.urls import include, patterns
from django.contrib import admin

from tastypie.api import Api

from pootle_language.api import LanguageResource
from pootle_project.api import ProjectResource
from pootle_translationproject.api import TranslationProjectResource

admin.autodiscover()

API_VERSION = 'v1'
pootle_api = Api(api_name=API_VERSION)
pootle_api.register(LanguageResource())
pootle_api.register(ProjectResource())
pootle_api.register(TranslationProjectResource())

urlpatterns = patterns(
    '',
    (r'^django_admin/', include(admin.site.urls)),

    # JavaScript i18n
    (
        r'^jsi18n/$',
        'django.views.i18n.javascript_catalog',
        {
            'packages': ('pootle', ),
        },
Ejemplo n.º 36
0
    2. Add a URL to urlpatterns:  path('', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.urls import include, path
    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include
from users.api import QuestionResource
from game.api import GameResource
from leaderboard.api import LeaderBoardResource
from tastypie.api import Api

v1_api = Api(api_name='v1')
v1_api.register(QuestionResource())

v2_api = Api(api_name='v2')
v2_api.register(QuestionResource())
v2_api.register(GameResource())

v3_api = Api(api_name='v3')
v3_api.register(QuestionResource())
v3_api.register(GameResource())
v3_api.register(LeaderBoardResource())

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include(v1_api.urls)),
    path('api/', include(v2_api.urls)),
Ejemplo n.º 37
0
from django.urls import path
from django.conf.urls import url, include

from django.conf.urls import url, include
from tastypie.api import Api


from publication.api.resources import PublicationsResource, CategoryResource
from base.api.resources import PartnersResource, AboutResource
from project.api.resources import  ProjectResource, SearchResource, GeoResource as GResource
from project.api.denonciation import DenonciationResource
from project.api.comments import CommentsResource
from event.api.resources import  EventResource
from geo.api.resources import PDECSResource, GeoResource

v1_api = Api(api_name='v1')
v1_api.register(CategoryResource())
v1_api.register(PublicationsResource())
v1_api.register(PartnersResource())
v1_api.register(EventResource())
v1_api.register(ProjectResource())
v1_api.register(AboutResource())
v1_api.register(SearchResource())
v1_api.register(DenonciationResource())
v1_api.register(CommentsResource())
v1_api.register(GeoResource())
v1_api.register(PDECSResource())
v1_api.register(GResource())


Ejemplo n.º 38
0
from django.conf.urls import patterns, include, url
from api import OrganizationResource, UserProfileResource, CourseResource, ProblemResource, EssayResource, EssayGradeResource, UserResource, CreateUserResource, MembershipResource
from tastypie.api import Api

v1_api = Api(api_name='v1')
v1_api.register(OrganizationResource())
v1_api.register(UserProfileResource())
v1_api.register(CourseResource())
v1_api.register(ProblemResource())
v1_api.register(EssayResource())
v1_api.register(EssayGradeResource())
v1_api.register(UserResource())
v1_api.register(CreateUserResource())
v1_api.register(MembershipResource())

urlpatterns = patterns('',
    (r'^api/', include(v1_api.urls)),
)

urlpatterns+=patterns('freeform_data.views',
      url(r'^login/$','login'),
      url(r'^logout/$','logout'),
)
Ejemplo n.º 39
0
from api.resources import ParkResource, \
    FacilityResource, \
    EntryResource, \
    NeighborhoodResource, \
    ActivityResource, \
    ParktypeResource, \
    ExploreParkResource, \
    ExploreFacilityResource, \
    ParkNameResource, \
    MBTAResource, \
    ExploreActivityResource, \
    FacilitytypeResource

admin.autodiscover()

v1_api = Api(api_name='v1')
v1_api.register(ActivityResource())
v1_api.register(EntryResource())
v1_api.register(ExploreActivityResource())
v1_api.register(ExploreFacilityResource())
v1_api.register(ExploreParkResource())
v1_api.register(FacilityResource())
v1_api.register(FacilitytypeResource())
v1_api.register(MBTAResource())
v1_api.register(NeighborhoodResource())
v1_api.register(ParkNameResource())
v1_api.register(ParkResource())
v1_api.register(ParktypeResource())

urlpatterns = patterns(
    '',
Ejemplo n.º 40
0
from tastypie.api import Api
from alphanumeric.api.resources import ProductResource

api = Api(api_name='v1')
api.register(ProductResource(), canonical=True)

urlpatterns = api.urls
Ejemplo n.º 41
0
from django.conf.urls import url, include
from clist import views

from tastypie.api import NamespacedApi as Api
from clist.api import v1

app_name = 'clist'

api_v1 = Api(api_name="v1", urlconf_namespace=f'{app_name}:api')
api_v1.register(v1.ResourceResource())
api_v1.register(v1.ContestResource())

urlpatterns = [
    url(r'^$', views.main, name='main'),
    url(r'^resources/$', views.resources, name='resources'),
    url(r'^resources/dumpdata/$',
        views.resources_dumpdata,
        name='resources_dumpdata'),
    url(r'^resource/(.*)/$', views.resource, name='resource'),
    url(r'^get/events/$', views.get_events),
    url(r'^problems/$', views.problems, name='problems'),
    url(r'^api/', include((api_v1.urls, app_name), namespace='api')),
    url(
        r'^api/v1/doc/',
        include(('tastypie_swagger.urls', app_name),
                namespace='tastypie_swagger'),
        kwargs={
            'version': '1.0',
            'tastypie_api_module': api_v1,
            'namespace': 'clist:tastypie_swagger',
        },
Ejemplo n.º 42
0
from django.conf.urls.defaults import *
from django.conf import settings
from libs.api import UserResource
from tastypie.api import Api
from django.contrib.staticfiles.urls import staticfiles_urlpatterns

api = Api(api_name='api')
api.register(UserResource())

# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns(
    '',
    (r'^$', include('apps.springboard.urls')),
    (r'^admin/', include(admin.site.urls)),
    (r'^courses/',
     include('apps.courses.urls', namespace="courses", app_name="courses")),
    (r'^profiles/',
     include('apps.profiles.urls', namespace="profiles", app_name="profiles")),
    (r'^alerts/',
     include('apps.alerts.urls', namespace="alerts", app_name="alerts")),
    (r'^tinymce/', include('tinymce.urls')),
    (r'^', include(api.urls)),
    url(r'^accounts/login/$',
        'django.contrib.auth.views.login',
        {'template_name': 'accounts/login.html'},
        name="login"),
    url(r'^accounts/logout/$',
        'django.contrib.auth.views.logout_then_login',
from django.conf.urls import patterns, url, include

from tastypie.api import Api

from .api import UserResource, CreateUserResource

# Create an empty pattern so that we can just build it using +=
urlpatterns = patterns(None)

#==============================================================================
# API Resources
#==============================================================================
v1_api = Api(api_name='v1')
v1_api.register(UserResource())
v1_api.register(CreateUserResource())

urlpatterns += patterns(
    '',
    url(r'^api/', include(v1_api.urls)),
)
Ejemplo n.º 44
0
from django.conf.urls.defaults import patterns, include, url
from tastypie.api import Api
from api import *

from django.contrib import admin
admin.autodiscover()

v1_api = Api(api_name='v1')

v1_api.register(UserResource())
v1_api.register(CurrentAccountResource())

urlpatterns = patterns('',
    url(r'^$', include('currentaccount.urls')),
    url(r'^current_account/', include('currentaccount.urls')),
    url(r'^admin/', include(admin.site.urls)),
    url(r'^api/', include(v1_api.urls)),
    url(r'^accounts/login/', 
        'django.contrib.auth.views.login', 
        { 'template_name' : 'currentaccount/login.html'} 
    ),
)

Ejemplo n.º 45
0
from api import ConversationResource, SpeakerResource, MessageResource, SentenceResource, WordResource
from tastypie.api import Api
from django.conf.urls import patterns, include, url

v1_api = Api(api_name='v1')

v1_api.register(ConversationResource())
v1_api.register(SpeakerResource())
v1_api.register(MessageResource())
v1_api.register(SentenceResource())
v1_api.register(WordResource())

urlpatterns = patterns(
    '',
    url('', include(v1_api.urls)),
)
Ejemplo n.º 46
0
Including another URLconf
    1. Import the include() function: from django.urls import include, path
    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
"""

from django.conf.urls import url, include
from django.contrib import admin
from django.views.generic import TemplateView

from tastypie.api import Api
from django.conf import settings
from app.api import BookResource, TagResource, CategoryResource, ArticleResource
import app.urls


v1_api = Api(api_name='v1')

v1_api.register(BookResource())
v1_api.register(TagResource())
v1_api.register(CategoryResource())
v1_api.register(ArticleResource())


urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^traditional/', include(app.urls)),  # 传统的 视图url 分发到app.url中
    url(r'^api/', include(v1_api.urls)), # tastypie restful 
    url(r'^$', TemplateView.as_view(template_name="index.html")),
]
if settings.DEBUG:
    import debug_toolbar
Ejemplo n.º 47
0
from tastypie.api import Api

from .api import ProcessResource

api = Api(api_name='v1')

api.register(ProcessResource())

urlpatterns = api.urls
Ejemplo n.º 48
0
    from crits.domains.api import DomainResource
    from crits.emails.api import EmailResource
    from crits.events.api import EventResource
    from crits.indicators.api import IndicatorResource, IndicatorActivityResource
    from crits.ips.api import IPResource
    from crits.objects.api import ObjectResource
    from crits.pcaps.api import PCAPResource
    from crits.raw_data.api import RawDataResource
    from crits.relationships.api import RelationshipResource
    from crits.samples.api import SampleResource
    from crits.screenshots.api import ScreenshotResource
    from crits.services.api import ServiceResource
    from crits.targets.api import TargetResource
    from crits.standards.api import StandardsResource

    v1_api = Api(api_name='v1')
    v1_api.register(ActorResource())
    v1_api.register(ActorIdentifierResource())
    v1_api.register(CampaignResource())
    v1_api.register(CertificateResource())
    v1_api.register(CommentResource())
    v1_api.register(DomainResource())
    v1_api.register(EmailResource())
    v1_api.register(EventResource())
    v1_api.register(IndicatorResource())
    v1_api.register(IndicatorActivityResource())
    v1_api.register(IPResource())
    v1_api.register(ObjectResource())
    v1_api.register(PCAPResource())
    v1_api.register(RawDataResource())
    v1_api.register(RelationshipResource())
Ejemplo n.º 49
0
from django.contrib import admin
from django.views.generic import RedirectView

from django.conf import settings
from data_manager.api import LayerResource, ThemeResource, TocThemeResource
from tastypie.api import Api
from django.contrib.staticfiles.urls import staticfiles_urlpatterns

import visualize
import explore
#from mapproxy.views import proxy_view
#import map_proxy
# print dir(map_proxy)
admin.autodiscover()

v1_api = Api(api_name='v1')
v1_api.register(LayerResource())
v1_api.register(ThemeResource())
v1_api.register(TocThemeResource())


urlpatterns = patterns('',
                        url('', include('social.apps.django_app.urls', namespace='social')),
                       (r'^api/', include(v1_api.urls)),
                       (r'^mp_profile/', include('mp_profile.urls')),
                       #(r'^sdc/', include('scenarios.urls')),
                       #(r'^drawing/', include('drawing.urls')),
                       (r'^data_manager/', include('data_manager.urls')),
                       #(r'^learn/', include('learn.urls')),
                       #(r'^scenario/', include('scenarios.urls')),
                       (r'^explore/', include('explore.urls')),
Ejemplo n.º 50
0
from django.conf.urls import patterns, include, url
from django.contrib import admin
from django.views.generic import TemplateView
from tastypie.api import Api
from miescuela.api import *

v1_api = Api(api_name='v1')
v1_api.register(ResultadoGlobalResource())
v1_api.register(EscuelaResource())
v1_api.register(LocalidadResource())

admin.autodiscover()

urlpatterns = patterns(
    '',
    #    url(r'^$', TemplateView.as_view(template_name="index.html"), name='base_index'),
    url(r'^api/', include(v1_api.urls)),
    url(r'^admin/', include(admin.site.urls)),
)
from .views.home import HomeView
from .views.static import StaticView

#
# Home view.
#
urlpatterns = patterns(
    '',
    url(r'^/?$', HomeView.as_view(), name='home'),
)

#
#  API routes.
#

api = Api(api_name=u"v1")
urlpatterns += patterns('', (r'^api/', include(api.urls)))

#
# Assets.
#
urlpatterns += patterns(
    '',
    url(r'^%s(?P<path>.*)$' % re.escape(settings.STATIC_URL.lstrip('/')),
        StaticView.as_view(), {
            'cache_forever': True,
            'insecure': True
        }))

urlpatterns += app_urlpatterns
Ejemplo n.º 52
0
from django.contrib import admin
from django.contrib.sitemaps.views import sitemap

from tastypie.api import Api

from froide.publicbody.api import (PublicBodyResource,
    JurisdictionResource, FoiLawResource)
from froide.foirequest.api import (FoiRequestResource,
    FoiMessageResource, FoiAttachmentResource)
from froide.publicbody.views import (PublicBodySitemap, FoiLawSitemap,
                                     JurisdictionSitemap, show_publicbody)
from froide.foirequest.views import (index, search, dashboard, auth,
                                     FoiRequestSitemap, shortlink)


v1_api = Api(api_name='v1')
v1_api.register(PublicBodyResource())
v1_api.register(JurisdictionResource())
v1_api.register(FoiLawResource())
v1_api.register(FoiRequestResource())
v1_api.register(FoiMessageResource())
v1_api.register(FoiAttachmentResource())


class StaticViewSitemap(Sitemap):
    priority = 1.0
    changefreq = 'daily'

    def items(self):
        return ['index', 'foirequest-list']
Ejemplo n.º 53
0
from django.views.generic import RedirectView
from django.views.generic import TemplateView
from decorator_include import decorator_include
from tastypie.api import Api

from rhizome.api.resources import *
from rhizome.api.decorators import api_debug
from rhizome import views

admin.autodiscover()

######################
# TASTYPIE Endpoints #
######################

v1_api = Api(api_name='v1')

v1_api.register(agg_refresh.AggRefreshResource())
v1_api.register(cache_meta.CacheMetaResource())
v1_api.register(
    calculated_indicator_component.CalculatedIndicatorComponentResource())
v1_api.register(custom_chart.CustomChartResource())
v1_api.register(custom_dashboard.CustomDashboardResource())
v1_api.register(date_datapoint.DateDatapointResource())
v1_api.register(doc_datapoint.DocDataPointResource())
v1_api.register(doc_detail_type.DocDetailTypeResource())
v1_api.register(doc_trans_form.DocTransFormResource())
v1_api.register(document.DocumentResource())
v1_api.register(document_detail.DocumentDetailResource())
v1_api.register(geo.GeoResource())
v1_api.register(group.GroupResource())
Ejemplo n.º 54
0
from django.conf.urls import patterns, include, url
# TASTYPIE API
from tastypie.api import Api
from gtfs.api import AlertResource

v1_api = Api(api_name='v1')
v1_api.register(AlertResource())

# GENERIC VIEWS
from gtfs.views import IndexView, DetailView

# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns(
    '',
    # Examples:
    # url(r'^$', 'malerts.views.home', name='home'),
    # url(r'^malerts/', include('malerts.foo.urls')),

    # url(r'^$', 'gtfs.views.alerts_html'),
    url(r'^alert.asciipb$', 'gtfs.views.alerts_ascii'),
    url(r'^api/', include(v1_api.urls)),
    url(r'^$', IndexView.as_view(), name='index'),
    url(r'^(?P<pk>\d+)/$', DetailView.as_view(), name="detail"),

    # Uncomment the admin/doc line below to enable admin documentation:
    url(r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # admin addons
Ejemplo n.º 55
0
from app_ambiente.apps.soap_server.api import *
from django.conf.urls import include, url
from django.contrib import admin
from django.conf import settings
from .api import LoginResource
from tastypie.api import Api

ambiente_api = Api(api_name='ambiente')
ambiente_api.register(LoginResource())

urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url(r'^api/', include(ambiente_api.urls)),
    url(r'^', include('app_ambiente.apps.principal.urls')),
    url(r'^users/', include('app_ambiente.apps.users.urls')),
    url(r'^solicitudes/', include('app_ambiente.apps.solicitudes.urls')),
    url(r'^static/(?P<path>.*)$', 'django.views.static.serve',
        {'document_root': settings.MEDIA_ROOT}),
]
Ejemplo n.º 56
0
from apps.main.api import MemberByFBTokenResource
from apps.main.api import MemberResource
from apps.main.api import NotificationResource
from apps.main.api import MessageResource
from apps.main.api import AddBidResource
from apps.main.api import ClaimBidResource
from apps.main.api import RemBidResource

from apps.main.api import RegisterInvitationResource
from apps.main.api import ServerClockResource

from apps.main.api import PaypalPaymentInfoResource
from apps.main.api import IOPaymentInfoResource
from apps.main.api import AppleIbidPackageIdsResource

v1_api = Api(api_name='v1')

v1_api.register(RegisterInvitationResource())
v1_api.register(ServerClockResource())
v1_api.register(NotificationResource())
v1_api.register(MemberResource())
v1_api.register(ConverTokensResource())
v1_api.register(MemberByFBTokenResource())
v1_api.register(CategoryResource())
v1_api.register(ItemResource())
v1_api.register(AuctionResource())
v1_api.register(MemberAuctionsResource())
v1_api.register(BidPackageResource())
v1_api.register(AddBidResource())
v1_api.register(RemBidResource())
v1_api.register(ClaimBidResource())
Ejemplo n.º 57
0
from django.conf.urls.defaults import patterns, url, include
from tastypie.api import Api
from api import *
from .views import *

v1 = Api(api_name='v1')
v1.register(ProfileResource())
# v1.register(EntryResource())

urlpatterns = patterns(
    '',
    url(r'^duo/signup/', Signup.as_view(), name='signup'),

    # url(r'^(?P<pk>\d+)/$',
    #     DetailView.as_view(),
    #     name="detail"),

    # url(r'^api/', include(v1.urls)),
    url(r'^duo/api/', include(v1.urls)),
)
Ejemplo n.º 58
0
 def setUp(self):
     super().setUp()
     self.api = Api(api_name='v1')
Ejemplo n.º 59
0
from django.conf.urls.defaults import *
from tastypie.api import Api
from api import TestResource

api = Api('test')

api.register(TestResource())

urlpatterns = patterns('',
    (r'^api/', include(api.urls)),
)
Ejemplo n.º 60
0
Archivo: urls.py Proyecto: at13/zamboni
from rest_framework.routers import SimpleRouter
from tastypie.api import Api
from tastypie_services.services import (ErrorResource, SettingsResource)

from mkt.submit.api import PreviewResource, StatusResource, ValidationResource
from mkt.api.base import AppRouter, handle_500, SlugRouter
from mkt.api.resources import (AppResource, CarrierResource, CategoryViewSet,
                               ConfigResource, error_reporter,
                               RefreshManifestViewSet, RegionResource)
from mkt.collections.views import CollectionViewSet
from mkt.features.views import AppFeaturesList
from mkt.ratings.resources import RatingResource
from mkt.search.api import SearchResource, SuggestionsResource


api = Api(api_name='apps')
api.register(ValidationResource())
api.register(AppResource())
api.register(PreviewResource())
api.register(SearchResource())
api.register(SuggestionsResource())
api.register(StatusResource())
api.register(RatingResource())


rocketfuel = SimpleRouter()
rocketfuel.register(r'collections', CollectionViewSet,
                    base_name='collections')

apps = SlugRouter()
apps.register(r'category', CategoryViewSet, base_name='app-category')