class TestNestedSimpleRouter(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'a', AViewSet)
self.a_router = NestedSimpleRouter(self.router, r'a', lookup='a')
self.a_router.register(r'b', BViewSet)
self.b_router = NestedSimpleRouter(self.a_router, r'b', lookup='b')
self.b_router.register(r'c', CViewSet)
def test_recursive_nested_simple_routers(self):
self.assertFalse(hasattr(self.router, 'parent_regex'))
urls = self.router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(urls[0].regex.pattern, u'^a/$')
self.assertEquals(urls[1].regex.pattern, u'^a/(?P<pk>[0-9a-f]{32})/$')
self.assertEqual(self.a_router.parent_regex,
u'a/(?P<a_pk>[0-9a-f]{32})/')
urls = self.a_router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(urls[0].regex.pattern,
u'^a/(?P<a_pk>[0-9a-f]{32})/b/$')
self.assertEquals(urls[1].regex.pattern,
u'^a/(?P<a_pk>[0-9a-f]{32})/b/(?P<pk>[^/.]+)/$')
self.assertEqual(self.b_router.parent_regex,
u'a/(?P<a_pk>[0-9a-f]{32})/b/(?P<b_pk>[^/.]+)/')
urls = self.b_router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(urls[0].regex.pattern,
u'^a/(?P<a_pk>[0-9a-f]{32})/b/(?P<b_pk>[^/.]+)/c/$')
self.assertEquals(
urls[1].regex.pattern,
u'^a/(?P<a_pk>[0-9a-f]{32})/b/(?P<b_pk>[^/.]+)/c/(?P<pk>[^/.]+)/$')
def _attach_nested_custom_fields(self, prefix, viewset, base_name):
"""
Creates dedicated viewset for nested customfields in context of
particular model.
"""
# cyclic imports, meh
from .viewsets import ObjectCustomFieldsViewSet
from ralph.api.viewsets import RalphAPIViewSet
model = viewset.queryset.model
custom_fields_related_viewset = type(
'{}CustomFieldsViewSet'.format(model._meta.object_name),
(ObjectCustomFieldsViewSet, RalphAPIViewSet),
{'related_model': model})
# notice that, although it's custom fields (nested) resource,
# for every model separated (nested) router is created!
nested_router = NestedSimpleRouter(
self,
prefix,
lookup=custom_fields_related_viewset.related_model_router_lookup)
nested_router.register(
self.nested_resource_prefix,
custom_fields_related_viewset,
base_name=self.nested_resource_base_name.format(base_name),
)
self.nested_registry.append(nested_router)
def test_drf_nested_routers_basic_example_variation(no_warnings):
from rest_framework_nested.routers import NestedSimpleRouter
class RootViewSet(viewsets.ModelViewSet):
queryset = Root.objects.all()
serializer_class = RootSerializer
lookup_value_regex = "[0-9]+"
class ChildViewSet(viewsets.ModelViewSet):
serializer_class = ChildSerializer
def get_queryset(self):
return Child.objects.filter(id=self.kwargs.get("parent_pk"))
router = routers.SimpleRouter()
router.register('root', RootViewSet, basename='root')
root_router = NestedSimpleRouter(router, r'root', lookup='parent')
root_router.register(r'child', ChildViewSet, basename='child')
urlpatterns = [
path(r'', include(router.urls)),
path(r'', include(root_router.urls)),
]
generate_schema(None, patterns=urlpatterns)
def test_explicit_no_trailing_slash(self):
router = SimpleRouter(trailing_slash=True)
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router, 'a', lookup='a', trailing_slash=False)
a_router.register('b', BViewSet)
self._assertDoesNotHaveTrailingSlash(a_router)
class TestNestedSimpleRouter(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'a', AViewSet)
self.a_router = NestedSimpleRouter(self.router, r'a', lookup='a')
self.a_router.register(r'b', BViewSet)
self.b_router = NestedSimpleRouter(self.a_router, r'b', lookup='b')
self.b_router.register(r'c', CViewSet)
def test_recursive_nested_simple_routers(self):
self.assertFalse(hasattr(self.router, 'parent_regex'))
urls = self.router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(urls[0].regex.pattern, u'^a/$')
self.assertEquals(urls[1].regex.pattern, u'^a/(?P<pk>[0-9a-f]{32})/$')
self.assertEqual(self.a_router.parent_regex, u'a/(?P<a_pk>[0-9a-f]{32})/')
urls = self.a_router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(urls[0].regex.pattern, u'^a/(?P<a_pk>[0-9a-f]{32})/b/$')
self.assertEquals(urls[1].regex.pattern, u'^a/(?P<a_pk>[0-9a-f]{32})/b/(?P<pk>[^/.]+)/$')
self.assertEqual(self.b_router.parent_regex, u'a/(?P<a_pk>[0-9a-f]{32})/b/(?P<b_pk>[^/.]+)/')
urls = self.b_router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(urls[0].regex.pattern, u'^a/(?P<a_pk>[0-9a-f]{32})/b/(?P<b_pk>[^/.]+)/c/$')
self.assertEquals(urls[1].regex.pattern, u'^a/(?P<a_pk>[0-9a-f]{32})/b/(?P<b_pk>[^/.]+)/c/(?P<pk>[^/.]+)/$')
class TestNestedSimpleRouter(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'detail', DetailRouteViewSet)
self.detail_router = NestedSimpleRouter(
self.router,
r'detail',
lookup='detail'
)
self.detail_router.register(r'list', ListRouteViewSet)
self.list_router = NestedSimpleRouter(
self.detail_router,
r'list',
lookup='list'
)
def test_dynamic_routes(self):
self.assertFalse(hasattr(self.router, 'parent_regex'))
urls = map_by_name(self.router.urls)
self.assertEquals(
get_regex_pattern(urls['basicmodel-list']), u'^detail/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-detail']),
u'^detail/(?P<pk>[^/.]+)/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-set-password']),
u'^detail/(?P<pk>[^/.]+)/set_password/$'
)
def test_nested_parent(self):
self.assertEqual(
self.detail_router.parent_regex,
u'detail/(?P<detail_pk>[^/.]+)/'
)
urls = map_by_name(self.detail_router.urls)
self.assertEquals(
get_regex_pattern(urls['basicmodel-list']),
u'^detail/(?P<detail_pk>[^/.]+)/list/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-recent-users']),
u'^detail/(?P<detail_pk>[^/.]+)/list/recent_users/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-detail']),
u'^detail/(?P<detail_pk>[^/.]+)/list/(?P<pk>[^/.]+)/$'
)
def test_nested_child(self):
self.assertEqual(
self.list_router.parent_regex,
u'detail/(?P<detail_pk>[^/.]+)/list/(?P<list_pk>[^/.]+)/'
)
class TestNestedSimpleRouter(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'detail', DetailRouteViewSet)
self.detail_router = NestedSimpleRouter(
self.router,
r'detail',
lookup='detail'
)
self.detail_router.register(r'list', ListRouteViewSet)
self.list_router = NestedSimpleRouter(
self.detail_router,
r'list',
lookup='list'
)
def test_dynamic_routes(self):
self.assertFalse(hasattr(self.router, 'parent_regex'))
urls = map_by_name(self.router.urls)
self.assertEquals(
get_regex_pattern(urls['basicmodel-list']), u'^detail/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-detail']),
u'^detail/(?P<pk>[^/.]+)/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-set-password']),
u'^detail/(?P<pk>[^/.]+)/set_password/$'
)
def test_nested_parent(self):
self.assertEqual(
self.detail_router.parent_regex,
u'detail/(?P<detail_pk>[^/.]+)/'
)
urls = map_by_name(self.detail_router.urls)
self.assertEquals(
get_regex_pattern(urls['basicmodel-list']),
u'^detail/(?P<detail_pk>[^/.]+)/list/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-recent-users']),
u'^detail/(?P<detail_pk>[^/.]+)/list/recent_users/$'
)
self.assertEquals(
get_regex_pattern(urls['basicmodel-detail']),
u'^detail/(?P<detail_pk>[^/.]+)/list/(?P<pk>[^/.]+)/$'
)
def test_nested_child(self):
self.assertEqual(
self.list_router.parent_regex,
u'detail/(?P<detail_pk>[^/.]+)/list/(?P<list_pk>[^/.]+)/'
)
class TestBadLookupValue(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'parents', AViewSet, base_name='ui-parent_1')
def test_bad_lookup(self):
with self.assertRaises(ValueError):
self.a_router = NestedSimpleRouter(self.router, r'parents', lookup='ui-parent_2')
self.a_router.register(r'child', BViewSet, base_name='ui-parent-child')
class TestBadLookupValue(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'parents', AViewSet, base_name='ui-parent_1')
def test_bad_lookup(self):
with self.assertRaises(ValueError):
self.a_router = NestedSimpleRouter(self.router, r'parents', lookup='ui-parent_2')
self.a_router.register(r'child', BViewSet, base_name='ui-parent-child')
def test_explicit_no_trailing_slash(self):
router = SimpleRouter(trailing_slash=True)
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router,
'a',
lookup='a',
trailing_slash=False)
a_router.register('b', BViewSet)
self._assertDoesNotHaveTrailingSlash(a_router)
def test_inherits_trailing_slash(self):
"""
Test whether the trailing_slash=False value is inherited when it
is unspecified on the nested router.
"""
router = SimpleRouter(trailing_slash=True)
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router, 'a', lookup='a')
a_router.register('b', BViewSet)
self._assertHasTrailingSlash(a_router)
def test_explicit_trailing_slash(self):
"""
Test whether the trailing_slash=False value is properly overridden when setting
trailing_slash=True on the nested router.
"""
router = SimpleRouter(trailing_slash=False)
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router, 'a', lookup='a', trailing_slash=True)
a_router.register('b', BViewSet)
self._assertHasTrailingSlash(a_router)
def test_inherits_trailing_slash(self):
"""
Test whether the trailing_slash=False value is inherited when it
is unspecified on the nested router.
"""
router = SimpleRouter(trailing_slash=True)
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router, 'a', lookup='a')
a_router.register('b', BViewSet)
self._assertHasTrailingSlash(a_router)
class TestEmptyPrefix(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'', AViewSet)
self.a_router = NestedSimpleRouter(self.router, r'', lookup='a')
self.a_router.register(r'b', BViewSet)
def test_empty_prefix(self):
urls = self.router.urls
urls = self.a_router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(get_regex_pattern(urls[0]), u'^(?P<a_pk>[0-9a-f]{32})/b/$')
self.assertEquals(get_regex_pattern(urls[1]), u'^(?P<a_pk>[0-9a-f]{32})/b/(?P<pk>[^/.]+)/$')
class TestEmptyPrefix(TestCase):
def setUp(self):
self.router = SimpleRouter()
self.router.register(r'', AViewSet)
self.a_router = NestedSimpleRouter(self.router, r'', lookup='a')
self.a_router.register(r'b', BViewSet)
def test_empty_prefix(self):
urls = self.router.urls
urls = self.a_router.urls
self.assertEquals(len(urls), 2)
self.assertEquals(get_regex_pattern(urls[0]), u'^(?P<a_pk>[0-9a-f]{32})/b/$')
self.assertEquals(get_regex_pattern(urls[1]), u'^(?P<a_pk>[0-9a-f]{32})/b/(?P<pk>[^/.]+)/$')
def test_inherits_nonstandard_trailing_slash(self):
"""
Test whether the trailing_slash attribute, when set with a custom value,
is inherited by the nested routed.
"""
router = SimpleRouter()
router.trailing_slash = '/?'
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router, 'a', lookup='a')
a_router.register('b', BViewSet)
self.assertEqual(a_router.trailing_slash, u'/?', "router does not have trailing slash when it should")
self.assertTrue(pattern_from_url(a_router.urls[0]).endswith('/?$'),
"router created url without trailing slash when it should have")
def test_explicit_trailing_slash(self):
"""
Test whether the trailing_slash=False value is properly overridden when setting
trailing_slash=True on the nested router.
"""
router = SimpleRouter(trailing_slash=False)
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router,
'a',
lookup='a',
trailing_slash=True)
a_router.register('b', BViewSet)
self._assertHasTrailingSlash(a_router)
def test_inherits_nonstandard_trailing_slash(self):
"""
Test whether the trailing_slash attribute, when set with a custom value,
is inherited by the nested routed.
"""
router = SimpleRouter()
router.trailing_slash = '/?'
router.register('a', AViewSet)
a_router = NestedSimpleRouter(router, 'a', lookup='a')
a_router.register('b', BViewSet)
self.assertEqual(a_router.trailing_slash, u'/?',
"router does not have trailing slash when it should")
self.assertTrue(
pattern_from_url(a_router.urls[0]).endswith('/?$'),
"router created url without trailing slash when it should have")
def register_nested(self, parent_prefix, prefix, viewset,
base_name=None, parent_lookup_name=None):
"""
Register a nested viewset wihtout worrying of instantiate a nested
router for registry.
"""
kwargs = {
'trailing_slash': bool(self.trailing_slash)
}
if parent_lookup_name is not None:
kwargs.update(lookup=parent_lookup_name)
nested_router = NestedSimpleRouter(
self,
parent_prefix,
**kwargs
)
nested_router.register(prefix, viewset, base_name)
self._nested_object_registry.append(nested_router)
def register_nested(self,
parent_prefix,
prefix,
viewset,
base_name=None,
parent_lookup_name=None,
depth_level=1):
"""
Register a nested viewset wihtout worrying of instantiate a nested
router for registry.
"""
kwargs = {'trailing_slash': bool(self.trailing_slash)}
if parent_lookup_name is not None:
kwargs.update(lookup=parent_lookup_name)
# Section for the depth of the route and add more routes
if depth_level > 1:
routers = ifilter(
lambda r:
(r._depth_level ==
(depth_level - 1)) and r._nested_prefix == parent_prefix,
self._nested_object_registry)
try:
parent_router = routers.next()
except StopIteration:
raise RuntimeError('parent registered resource not found')
else:
parent_router = self
nested_router = NestedSimpleRouter(parent_router, parent_prefix,
**kwargs)
nested_router._nested_prefix = prefix
nested_router._depth_level = depth_level
nested_router.register(prefix, viewset, base_name)
self._nested_object_registry.append(nested_router)
def test_drf_nested_routers_basic_example(no_warnings):
from rest_framework_nested.routers import NestedSimpleRouter
class RootViewSet(viewsets.ModelViewSet):
serializer_class = RootSerializer
queryset = Root.objects.all()
class ChildViewSet(viewsets.ModelViewSet):
serializer_class = ChildSerializer
queryset = Child.objects.all()
router = SimpleRouter()
router.register('root', RootViewSet, basename='root')
root_router = NestedSimpleRouter(router, r'root', lookup='parent')
root_router.register(r'child', ChildViewSet, basename='child')
urlpatterns = [
re_path(r'^', include(router.urls)),
re_path(r'^', include(root_router.urls)),
]
schema = generate_schema(None, patterns=urlpatterns)
assert_schema(schema, 'tests/contrib/test_drf_nested_routers.yml')
assert schema
from django.urls import path, include
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from accounts import views
router = SimpleRouter()
router.register(r'accounts', views.UserViewSet, basename='accounts')
notifications_router = NestedSimpleRouter(router, 'accounts', lookup='account')
notifications_router.register('notifications', views.UserNotificationsViewSet, basename='notifications')
urlpatterns = [
path('', include(router.urls)),
path('', include(notifications_router.urls))
]
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
from ..accounts.urls import router as accounts_router
router = DefaultRouter()
router.register(r'weight_entries', views.WeightEntryViewSet)
router.register(r'exercise_score_entries', views.ExerciseScoreEntryViewSet)
user_entries_router = NestedSimpleRouter(accounts_router, r'users', lookup='user')
user_entries_router.register(
'weight_entries',
viewset=views.UserWeightEntryViewSet,
basename='user-weight-entry'
)
user_entries_router.register(
'exercise_entries',
viewset=views.UserExerciseScoreEntryViewSet,
basename='user-exercise-entry'
)
urlpatterns = router.urls + user_entries_router.urls
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from mkt.extensions.views import (ExtensionSearchView, ExtensionVersionViewSet,
ExtensionViewSet,
ReviewerExtensionSearchView,
ReviewersExtensionViewSet, ValidationViewSet)
extensions = SimpleRouter()
extensions.register(r'validation', ValidationViewSet,
base_name='extension-validation')
extensions.register(r'extension', ExtensionViewSet)
extensions.register(r'queue', ReviewersExtensionViewSet,
base_name='extension-queue')
# Router for children of /extensions/extension/{extension_pk}/.
sub_extensions = NestedSimpleRouter(
extensions, r'extension', lookup='extension')
sub_extensions.register(r'versions', ExtensionVersionViewSet,
base_name='extension-version')
urlpatterns = patterns(
'',
url(r'', include(extensions.urls)),
url(r'', include(sub_extensions.urls)),
url(r'search/$', ExtensionSearchView.as_view(), name='extension-search'),
url(r'search/reviewers/$', ReviewerExtensionSearchView.as_view(),
name='extension-search-reviewers'),
)
from rest_framework_nested.routers import NestedSimpleRouter
from olympia.activity.views import VersionReviewNotesViewSet
from olympia.reviews.views import ReviewViewSet
from .views import (
AddonFeaturedView, AddonSearchView, AddonVersionViewSet, AddonViewSet,
StaticCategoryView)
addons = SimpleRouter()
addons.register(r'addon', AddonViewSet)
# Router for children of /addons/addon/{addon_pk}/.
sub_addons = NestedSimpleRouter(addons, r'addon', lookup='addon')
sub_addons.register('versions', AddonVersionViewSet, base_name='addon-version')
sub_addons.register('reviews', ReviewViewSet, base_name='addon-review')
sub_versions = NestedSimpleRouter(sub_addons, r'versions', lookup='version')
sub_versions.register(r'reviewnotes', VersionReviewNotesViewSet,
base_name='version-reviewnotes')
urlpatterns = patterns(
'',
url(r'', include(addons.urls)),
url(r'', include(sub_addons.urls)),
url(r'', include(sub_versions.urls)),
url(r'^search/$', AddonSearchView.as_view(), name='addon-search'),
url(r'^featured/$', AddonFeaturedView.as_view(), name='addon-featured'),
url(r'^categories/$', StaticCategoryView.as_view(), name='category-list'),
)
from api.users import views as api_users_views
router = SimpleRouter()
router.register('users', api_users_views.UserViewSet)
router.register('teams', api_teams_views.TeamViewSet)
router.register('tasks', api_tasks_views.TaskViewSet)
router.register('task_tags', api_tasks_views.TaskTagViewSet)
router.register('task_files', api_tasks_views.TaskFileViewSet, basename='task_files')
router.register('task_hints', api_tasks_views.TaskHintViewSet)
router.register('posts', api_posts_views.PostViewSet)
router.register('contests', api_contests_views.ContestViewSet)
router.register('contest_participant_relationship', api_contests_views.ContestParticipantRelationshipViewSet)
router.register('contest_task_relationship', api_contests_views.ContestTaskRelationshipViewSet)
contests_router = NestedSimpleRouter(router, 'contests', lookup='contest')
contests_router.register('tasks', api_contests_views.ContestTaskViewSet)
urlpatterns = [
re_path('^', include(router.urls)),
re_path('^', include(contests_router.urls)),
re_path('^register/$', api_users_views.UserCreateView.as_view(), name='registration_view'),
re_path('^confirm_email/$',
api_users_views.EmailConfirmationEndpointView.as_view(),
name='email_confirmation_view'),
re_path('^resend_confirmation/$',
api_users_views.ActivationEmailResendView.as_view(),
name='email_confirmation_resend_view'),
from django.conf.urls import include, url
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from .views import (
AddonReviewerViewSet, ReviewAddonVersionViewSet,
ReviewAddonVersionCompareViewSet)
addons = SimpleRouter()
addons.register(r'addon', AddonReviewerViewSet, basename='reviewers-addon')
versions = NestedSimpleRouter(addons, r'addon', lookup='addon')
versions.register(
r'versions', ReviewAddonVersionViewSet, basename='reviewers-versions')
compare = NestedSimpleRouter(versions, r'versions', lookup='version')
compare.register(
r'compare_to', ReviewAddonVersionCompareViewSet,
basename='reviewers-versions-compare')
urlpatterns = [
url(r'', include(addons.urls)),
url(r'', include(versions.urls)),
url(r'', include(compare.urls)),
]
cs_router.register(r'layercategories', LayerCategoryViewSet)
cs_router.register(r'levels', AdminLevelViewSet)
cs_router.register(r'areas', AreaViewSet)
cs_router.register(r'publications', PublicationInCasestudyViewSet)
cs_router.register(r'aims', AimViewSet)
cs_router.register(r'userobjectives', UserObjectiveViewSet)
cs_router.register(r'challenges', ChallengeViewSet)
cs_router.register(r'wmsresources', WMSResourceInCasestudyViewSet)
cs_router.register(r'sections', SectionViewSet)
cs_router.register(r'consensuslevels', ConsensusViewSet)
# /casestudies/*/userobjectives/...
uo_router = NestedSimpleRouter(cs_router,
r'userobjectives',
lookup='userobjective')
uo_router.register(r'flowtargets', FlowTargetViewSet)
# /casestudies/*/layercategories/...
layercat_router = NestedSimpleRouter(cs_router,
r'layercategories',
lookup='layercategory')
layercat_router.register(r'layers', LayerViewSet)
# /casestudies/*/levels/...
levels_router = NestedSimpleRouter(cs_router, r'levels', lookup='level')
levels_router.register(r'areas', AreaInLevelViewSet)
# /casestudies/*/chartcategories/...
chart_router = NestedSimpleRouter(cs_router,
r'chartcategories',
lookup='chartcategory')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url, include
from playlist import views
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
# Create a router and register our viewsets with it.
router = DefaultRouter()
router.register(r'playlists', views.PlaylistViewSet)
router.register(r'tracks', views.TrackViewSet)
router.register(r'users', views.UserViewSet)
playlists_router = NestedSimpleRouter(router, r'playlists', lookup='playlist')
playlists_router.register(r'tracks', views.PlaylistTrackViewSet)
# The API URLs are now determined automatically by the router.
# Additionally, we include the login URLs for the browsable API.
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(playlists_router.urls)),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework'))
]
destroy = not_allowed
def create(self, request, patch_pk):
p = Patch.objects.get(id=patch_pk)
if not p.is_editable(request.user):
raise PermissionDenied()
request.patch = p
return super(CheckViewSet, self).create(request)
def list(self, request, patch_pk):
queryset = self.filter_queryset(self.get_queryset())
queryset = queryset.filter(patch=patch_pk)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
router = DefaultRouter()
router.register("patches", PatchViewSet, "patch")
router.register("people", PeopleViewSet, "person")
router.register("projects", ProjectViewSet, "project")
router.register("users", UserViewSet, "user")
patches_router = NestedSimpleRouter(router, r"patches", lookup="patch")
patches_router.register(r"checks", CheckViewSet, base_name="patch-checks")
from django.conf.urls import include, url
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from olympia.bandwagon.views import CollectionAddonViewSet, CollectionViewSet
from . import views
accounts = SimpleRouter()
accounts.register(r'account', views.AccountViewSet, basename='account')
collections = NestedSimpleRouter(accounts, r'account', lookup='user')
collections.register(r'collections', CollectionViewSet,
basename='collection')
sub_collections = NestedSimpleRouter(collections, r'collections',
lookup='collection')
sub_collections.register('addons', CollectionAddonViewSet,
basename='collection-addon')
notifications = NestedSimpleRouter(accounts, r'account', lookup='user')
notifications.register(r'notifications', views.AccountNotificationViewSet,
basename='notification')
urlpatterns = [
url(r'^authenticate/$', views.AuthenticateView.as_view(),
name='accounts.authenticate'),
url(r'^login/start/$',
views.LoginStartView.as_view(),
name='accounts.login_start'),
from django.conf.urls import url
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
urlpatterns = [
url(r'^$', views.QuestionsListView.as_view(), name='questions_latest'),
url(r'^best/$', views.BestQuestionsListView.as_view(), name='questions_best'),
url(r'^unanswered/$', views.UnansweredQuestionsListView.as_view(), name='questions_unanswered'),
url(r'^bytag/(?P<pk>[0-9]+)/$', views.ByTagIdQuestionsListView.as_view(), name='questions_by_tag_id'),
url(r'^(?P<pk>[0-9]+)/$', views.QuestionsDetailView.as_view(), name='questions_detail'),
url(r'^add_question/$', views.AddQuestionView.as_view(), name='add_question'),
]
router = routers.SimpleRouter()
router.register(r'questions', views.QuestionsViewSet, base_name='questions')
router.register(r'comments', views.CommentsViewSet, base_name='comments')
answers_router = NestedSimpleRouter(router, r'questions', lookup='question')
answers_router.register(r'answers', views.AnswersViewSet, base_name='answers')
urlpatterns += router.urls
urlpatterns += answers_router.urls
TranscriptomeModelViewSet,
DataFileViewSet,
CovarianceViewSet,
)
# Create a router and register our viewsets with it.
router = DefaultRouter()
read_only_router = ReadOnlyRouter()
read_only_router.register("users", SimpleUserViewSet, "user")
read_only_router.register("transcriptomes", TranscriptomeModelViewSet, "transcriptome")
read_only_router.register("covariances", CovarianceViewSet, "covariance")
user_router = NestedSimpleRouter(read_only_router, r"users", lookup="user")
user_router.register(r"jobs", JobViewSet, base_name="jobs")
jobs_router = NestedSimpleRouter(user_router, r"jobs", lookup="job")
jobs_router.register(r"files", DataFileViewSet, base_name="")
urlpatterns = [
url(r"^", include(router.urls)),
url(r"^", include(read_only_router.urls)),
url(r"^", include(user_router.urls)),
url(r"^", include(jobs_router.urls)),
url(r"^signup/$", CreateUserView.as_view()),
url(r"^login/$", LoginView.as_view()),
]
# TODO: remove
urlpatterns += [url(r"^api-auth/", include("rest_framework.urls", namespace="rest_framework"))]
from django.conf.urls import include
from django.urls import re_path
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from olympia.bandwagon.views import CollectionAddonViewSet, CollectionViewSet
from . import views
accounts = SimpleRouter()
accounts.register(r'account', views.AccountViewSet, basename='account')
collections = NestedSimpleRouter(accounts, r'account', lookup='user')
collections.register(r'collections', CollectionViewSet, basename='collection')
sub_collections = NestedSimpleRouter(collections,
r'collections',
lookup='collection')
sub_collections.register('addons',
CollectionAddonViewSet,
basename='collection-addon')
notifications = NestedSimpleRouter(accounts, r'account', lookup='user')
notifications.register(r'notifications',
views.AccountNotificationViewSet,
basename='notification')
accounts_v4 = [
re_path(r'^login/start/$',
views.LoginStartView.as_view(),
name='accounts.login_start'),
from django.conf.urls import patterns, url, include
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
router = routers.DefaultRouter()
router.register(r"category", views.CategoryViewSet)
router.register(r"eligibility_check", views.EligibilityCheckViewSet, base_name="eligibility_check")
router.register(r"case", views.CaseViewSet)
eligibility_check_router = NestedSimpleRouter(router, "eligibility_check", lookup="eligibility_check_")
eligibility_check_router.register(r"property", views.PropertyViewSet, base_name="property")
urlpatterns = patterns("", url(r"^", include(router.urls)), url(r"^", include(eligibility_check_router.urls)))
router.register("ambulance", AmbulanceViewSet)
router.register("patient", PatientViewSet)
router.register("consultation", PatientConsultationViewSet)
# Local Body / LSG Viewsets
router.register("state", StateViewSet)
router.register("district", DistrictViewSet)
router.register("local_body", LocalBodyViewSet)
# Patient Sample
router.register("test_sample", PatientSampleViewSet)
# Ref: https://github.com/alanjds/drf-nested-routers
facility_nested_router = NestedSimpleRouter(router, r"facility", lookup="facility")
facility_nested_router.register(r"hospital_doctor", HospitalDoctorViewSet)
facility_nested_router.register(r"capacity", FacilityCapacityViewSet)
facility_nested_router.register(r"patient_stats", FacilityPatientStatsHistoryViewSet)
patient_nested_router = NestedSimpleRouter(router, r"patient", lookup="patient")
patient_nested_router.register(r"test_sample", PatientSampleViewSet)
consultation_nested_router = NestedSimpleRouter(router, r"consultation", lookup="consultation")
consultation_nested_router.register(r"daily_rounds", DailyRoundsViewSet)
app_name = "api"
urlpatterns = [
url(r"^", include(router.urls)),
url(r"^", include(facility_nested_router.urls)),
url(r"^", include(patient_nested_router.urls)),
url(r"^", include(consultation_nested_router.urls)),
from django.conf.urls import include, url
from django.contrib import admin
from rest_framework.routers import DefaultRouter, SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from rest_framework.authtoken.views import obtain_auth_token
from django.conf import settings
from domains.views import DomainsViewSet, NestedRecordsViewSet, panel
domains_router = SimpleRouter(trailing_slash=False)
domains_router.register(r'domains', DomainsViewSet)
records_router = NestedSimpleRouter(domains_router, r'domains', lookup='domain', trailing_slash=False)
records_router.register(r'records', NestedRecordsViewSet, base_name='records')
urlpatterns = [
url(r'^$', panel, name='panel'),
url(r'^panel/$', panel, name='panel'),
# Stock django auth forms
url('^', include('django.contrib.auth.urls')),
url(r'^api/', include(domains_router.urls)),
url(r'^api/', include(records_router.urls)),
url(r'^rest-auth/', include('rest_auth.urls')),
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
router = routers.DefaultRouter()
router.register(r'muscle_groups', views.MuscleGroupViewSet)
router.register(r'exercises', views.ExerciseViewSet)
router.register(r'workouts', views.WorkoutViewSet, basename='workout')
exercises_router = NestedSimpleRouter(router, r'workouts', lookup='workout')
exercises_router.register(
r'exercises',
viewset=views.WorkoutExerciseViewSet,
basename='workout-exercise'
)
urlpatterns = router.urls + exercises_router.urls
from django.contrib.auth.models import User
from rest_framework import routers, serializers, viewsets
from rest_framework_nested.routers import NestedSimpleRouter
from authentication.views import IndexView, LoginView, LogoutView
# Routers provide an easy way of automatically determining the URL conf.
router = routers.DefaultRouter()
router.register(r'accounts', AccountViewSet)
router.register(r'registration', RegistrationViewSet)
router.register(r'brewer', BrewerViewSet)
router.register(r'brews', BrewViewSet, 'Brew')
router.register(r'tastings', TastingViewSet)
accounts_router = NestedSimpleRouter(
router, r'accounts', lookup='account'
)
accounts_router.register(r'brews', AccountBrewsViewSet)
urlpatterns = patterns(
'',
url(r'^api/v1/', include(router.urls)),
url(r'^api/v1/', include(accounts_router.urls)),
url(r'^api/v1/auth/login/$', LoginView.as_view(), name='login'),
url(r'^api/v1/auth/logout/$', LogoutView.as_view(), name='logout'),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
url('^.*$', IndexView.as_view(), name='index'),
)
# -*- coding: utf-8 -*- from rest_framework_nested.routers import SimpleRouter, NestedSimpleRouter # Custom from .views import TaskListViewSet from tasks.views import TaskViewSet router = SimpleRouter() router.register(r'list-tasks', TaskListViewSet, 'tasklist') # For nested url task_router = NestedSimpleRouter(router, r'list-tasks', lookup='tasklist') task_router.register(r'tasks', TaskViewSet, 'task')
from django.contrib import admin
from rest_framework.urlpatterns import format_suffix_patterns
from buppli import api
from rest_framework.routers import DefaultRouter
from rest_framework_jwt.views import obtain_jwt_token, refresh_jwt_token
from rest_framework_nested.routers import NestedSimpleRouter
from buppli.views import IndexView, BucketListView, logout_view
router = DefaultRouter()
router.register(r'auth/register', api.UserViewSet)
router.register(r'bucketlists', api.BucketListViewSet)
router.register(r'public-bucketlist', api.PublicBucketListViewSet,
base_name='public_bucketlist')
bucketlist_router = NestedSimpleRouter(router, r'bucketlists',
lookup='bucketlist')
bucketlist_router.register(r'items', api.BucketListItemViewSet)
urlpatterns = [
url(r'^$', IndexView.as_view()),
url(r'^bucketlists$', BucketListView.as_view()),
url(r'^logout$', logout_view),
url(r'^api/v1/login/$', obtain_jwt_token, name='login'),
url(r'^api/v1/login/refresh_token/$', refresh_jwt_token),
url(r'^api/v1/', include(router.urls)),
url(r'^api/v1/', include(bucketlist_router.urls)),
url(r'^api/v1/docs/', include("rest_framework_swagger.urls")),
url(r'^admin/', include(admin.site.urls)),
url(r'^static/(?P<path>.*)$',
django.views.static.serve, {'document_root': settings.STATIC_ROOT}),
]
from django.conf.urls import include, url
from rest_framework.authtoken import views
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
from api.views import (CustomerViewSet, ProviderViewSet, UserPreferenceViewSet,
UserViewSet, costs, instance_type, status, storage)
ROUTER = DefaultRouter()
ROUTER.register(r'customers', CustomerViewSet)
ROUTER.register(r'providers', ProviderViewSet)
ROUTER.register(r'users', UserViewSet)
USER_ROUTER = NestedSimpleRouter(ROUTER, r'users', lookup='user')
USER_ROUTER.register(r'preferences',
UserPreferenceViewSet,
base_name='preferences')
# pylint: disable=invalid-name
urlpatterns = [
url(r'^token-auth/', views.obtain_auth_token, name='token-auth'),
url(r'^status/$', status, name='server-status'),
url(r'^reports/costs/$', costs, name='reports-costs'),
url(r'^reports/inventory/instance-type/$',
instance_type,
name='reports-instance-type'),
url(r'^reports/inventory/storage/$', storage, name='reports-storage'),
url(r'^', include(ROUTER.urls)),
url(r'^', include(USER_ROUTER.urls))
]
from django.urls import include, path
from rest_framework_nested.routers import DefaultRouter, NestedSimpleRouter
from .views import *
router = DefaultRouter()
router.register(r'cameras', CameraViewSet)
router.register(r'cafeterias', CafeteriaViewSet)
router.register(r'fixed_menu_reviews', FixedMenuOptionReviewViewSet)
cafeterias_router = NestedSimpleRouter(router,
r'cafeterias',
lookup='cafeteria')
cafeterias_router.register(r'fixed_menu_options',
FixedMenuOptionViewSet,
basename='cafeteria-fixed_menu_options')
fixed_menu_options_router = NestedSimpleRouter(cafeterias_router,
r'fixed_menu_options',
lookup='option')
fixed_menu_options_router.register(
r'reviews',
CafeteriaFixedMenuOptionReviewViewSet,
basename='cafeteria-fixed_menu_options-review')
cameras_router = NestedSimpleRouter(router, r'cameras', lookup='camera')
cameras_router.register(r'events',
CameraEventsViewSet,
basename='camera_events')
urlpatterns = [
from django.conf.urls import include, url
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from .views import (
AddonReviewerViewSet, ReviewAddonVersionViewSet)
addons = SimpleRouter()
addons.register(r'addon', AddonReviewerViewSet, basename='reviewers-addon')
versions = NestedSimpleRouter(addons, r'addon', lookup='addon')
versions.register(
r'versions', ReviewAddonVersionViewSet, basename='reviewers-versions')
urlpatterns = [
url(r'', include(addons.urls)),
url(r'', include(versions.urls)),
]
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.conf.urls import url
from django.contrib import admin
from django.urls import include, path
from polls.views import PollViewSet, QuestionViewSet, interactive_hook
from rest_framework_nested.routers import DefaultRouter, NestedSimpleRouter
from rest_framework_simplejwt.views import (
TokenObtainPairView,
TokenRefreshView,
)
router = DefaultRouter()
router.register(r'polls', PollViewSet)
poll_router = NestedSimpleRouter(router, r'polls', lookup='poll')
poll_router.register(r'questions', QuestionViewSet, basename='poll-questions')
# urlpatterns = router.urls
urlpatterns = (
# url(r'^', include(router.urls)),
# url(r'^', include(poll_router.urls)),
path('', admin.site.urls),
# url('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
# url('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
path('event/hook/', interactive_hook, name='event_hook'),
)
basename="district-summary-patient",
)
router.register("items", FacilityInventoryItemViewSet)
router.register("burn_rate", FacilityInventoryBurnRateViewSet)
router.register("shift", ShiftingViewSet, basename="patient-shift")
router.register("investigation/group", InvestigationGroupViewset)
router.register("investigation", PatientInvestigationViewSet)
# Ref: https://github.com/alanjds/drf-nested-routers
facility_nested_router = NestedSimpleRouter(router,
r"facility",
lookup="facility")
facility_nested_router.register(r"hospital_doctor", HospitalDoctorViewSet)
facility_nested_router.register(r"capacity", FacilityCapacityViewSet)
facility_nested_router.register(r"patient_stats",
FacilityPatientStatsHistoryViewSet)
facility_nested_router.register(r"inventory", FacilityInventoryLogViewSet)
facility_nested_router.register(r"inventorysummary",
FacilityInventorySummaryViewSet)
facility_nested_router.register(r"min_quantity",
FacilityInventoryMinQuantityViewSet)
facility_nested_router.register("burn_rate", FacilityInventoryBurnRateViewSet)
patient_nested_router = NestedSimpleRouter(router,
r"patient",
lookup="patient")
patient_nested_router.register(r"test_sample", PatientSampleViewSet)
patient_nested_router.register(r"investigation",
from django.conf.urls import url, include
from rest_framework_nested.routers import SimpleRouter, DefaultRouter, NestedSimpleRouter
from classes.views import ClassesViewSet, SemesterViewSet
from classes.views import ClassesSemesterViewSet
from student.views import ClassesStudentViewSet
root_router = DefaultRouter()
root_router.register('classes', ClassesViewSet, 'classes')
root_router.register('semester', SemesterViewSet, 'semester')
classes_router = SimpleRouter()
classes_router.register('classes', ClassesViewSet, base_name='list-classes')
classes_semester_router = NestedSimpleRouter(classes_router, 'classes', lookup='classes')
classes_semester_router.register('semester', ClassesSemesterViewSet, base_name='list-classes-semester')
classes_student_router = NestedSimpleRouter(classes_router, 'classes', lookup='classes')
classes_student_router.register('student', ClassesStudentViewSet, base_name='list-classes-student')
urlpatterns = [
url(r'', include(root_router.urls)),
url(r'list/', include(classes_router.urls)),
url(r'list/', include(classes_semester_router.urls)),
url(r'list/', include(classes_student_router.urls)),
]
from bugtracking.users.api.views import UserViewSet
from bugtracking.tracker.api.viewsets import TeamViewSet, TeamMembershipViewSet, ProjectViewSet, TicketViewSet, TeamInvitationViewSet
if settings.DEBUG:
router = DefaultRouter()
else:
router = SimpleRouter()
router.register("users", UserViewSet)
router.register(r'teams', TeamViewSet, basename='teams')
router.register(r'invitations', TeamInvitationViewSet, basename='invitations')
# don't want the memberships viewset registered by default; only using it to debug stuff
# router.register(r'memberships', TeamMembershipViewSet, basename='memberships')
team_router = NestedSimpleRouter(router, r'teams', lookup='team')
team_router.register(r'projects', ProjectViewSet, basename='projects')
team_router.register(r'invitations',
TeamInvitationViewSet,
basename='invitations')
project_router = NestedSimpleRouter(team_router, r'projects', lookup='project')
project_router.register(r'tickets', TicketViewSet, basename='tickets')
app_name = "api"
# urlpatterns = router.urls
urlpatterns = [
path(r'', include(router.urls)),
path(r'', include(team_router.urls)),
path(r'', include(project_router.urls))
]
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Add an import: from blog import urls as blog_urls
2. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls))
"""
from django.conf.urls import include, url
from django.contrib import admin
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
from blogposts.views import BlogpostViewSet, CommentViewSet, NestedCommentViewSet
from .views import UserViewSet
router = DefaultRouter()
router.register(r'users', UserViewSet)
router.register(r'blogposts', BlogpostViewSet)
router.register(r'comments', CommentViewSet)
blogposts_router = NestedSimpleRouter(router, r'blogposts', lookup='blogpost')
blogposts_router.register(r'comments', NestedCommentViewSet)
urlpatterns = [
url(r'^admin/', include(admin.site.urls)),
url(r'^api/', include(router.urls)),
url(r'^api/', include(blogposts_router.urls)),
url(r'^o/', include('oauth2_provider.urls', namespace='oauth2_provider')),
]
from django.conf.urls import include, url
from django.conf.urls.static import static
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
from wristband.stages.views import StagesViewSet
from wristband.apps.views import NestedAppViewSet, AppViewSet, DeployAppView
from wristband.authentication.views import login_view, logout_view, ObtainAuthToken
from wristband.common.views import healthcheck_view
router = DefaultRouter()
router.register(r'stages', StagesViewSet, base_name='stages')
router.register(r'apps', AppViewSet, base_name='apps')
stages_router = NestedSimpleRouter(router, r'stages', lookup='stage')
stages_router.register(r'apps', NestedAppViewSet, base_name='apps')
urlpatterns = [
url(r'^login/$', login_view, name='login'),
url(r'^logout/$', logout_view, name='logout'),
url(r'^token/$', ObtainAuthToken.as_view(), name='token'),
url(r'^ping/ping/$', healthcheck_view, name='healthcheck'),
url(r'^api/', include(router.urls)),
url(r'^api/', include(stages_router.urls)),
url(r'^api/apps/(?P<app_name>.*)/stages/(?P<stage>.*)/version/(?P<version>.*)/', DeployAppView.as_view()),
url(r'^docs/', include('rest_framework_swagger.urls'))
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
from django.urls import include, path
from rest_framework_nested.routers import NestedSimpleRouter, SimpleRouter
from . import viewsets
tests_router = SimpleRouter()
tests_router.register('tests', viewsets.TestsViewSet, base_name='tests')
questions_router = NestedSimpleRouter(tests_router, 'tests', lookup='test')
questions_router.register('questions',
viewsets.QuestionsViewSet,
base_name='questions')
answers_router = NestedSimpleRouter(questions_router,
'questions',
lookup='question')
answers_router.register('answers',
viewsets.AnswersViewSet,
base_name='answers')
urlpatterns = [
path('', include(tests_router.get_urls())),
path('', include(questions_router.get_urls())),
path('', include(answers_router.get_urls())),
]
from django.conf.urls import url
from django.urls import include
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from api.controls.views.element import ElementViewSet, ElementWithPermissionsViewSet
from api.controls.views.system import SystemViewSet, SystemControlsViewSet, SystemAssessmentViewSet, SystemPoamViewSet
router = routers.DefaultRouter()
router.register(r'elements', ElementViewSet)
router.register(r'element_permissions', ElementWithPermissionsViewSet)
router.register(r'systems', SystemViewSet)
systems_router = NestedSimpleRouter(router, r'systems', lookup='systems')
systems_router.register(r'controls',
SystemControlsViewSet,
basename='systems-controls')
systems_router.register(r'assessments',
SystemAssessmentViewSet,
basename='systems-assessments')
systems_router.register(r'poams', SystemPoamViewSet, basename='systems-poams')
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(systems_router.urls))
]
from rest_framework_nested.routers import NestedSimpleRouter
from commons.views import csrf_token
from users.views import UserViewSet
from users.views import signin
from users.views import signout
from tasks.views import TaskViewSet
from tasks.views import PomodoroViewSet
router = DefaultRouter()
router.register(r'users', UserViewSet, base_name='user')
router.register(r'tasks', TaskViewSet, base_name='task')
tasks_router = NestedSimpleRouter(router, r'tasks', lookup='task')
tasks_router.register(r'pomodoros', PomodoroViewSet, base_name='pomodoro')
urlpatterns = [
url(r'^admin/', admin.site.urls),
# get csrf token
url(r'^csrf_token', csrf_token, name='csrf_token'),
# login/logout
url(r'^auth/signin', signin, name='signin'),
url(r'^auth/signout', signout, name='signout'),
# test auth from django-rest-framework
url(r'^test/auth/', include('rest_framework.urls', namespace='rest_framework')),
from django.conf.urls import patterns, url, include
from django.views.generic.base import TemplateView
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from authentication.views import AccountViewSet, LoginView, LogoutView
from posts.views import AccountPostsViewSet, PostViewSet
router = routers.SimpleRouter()
router.register(r'accounts', AccountViewSet)
router.register(r'posts', PostViewSet)
accounts_router = NestedSimpleRouter(
router, r'accounts', lookup='account'
)
accounts_router.register(r'posts', AccountPostsViewSet)
urlpatterns = patterns(
'',
url(r'^api/v1/auth/login/$', LoginView.as_view(), name="login"),
url(r'^api/v1/auth/logout/$', LogoutView.as_view(), name="logout"),
url(r'^api/v1/', include(router.urls)),
url(r'^api/v1/', include(accounts_router.urls)),
url(r'^', TemplateView.as_view(template_name='index.html'), name='index'),
)
from django.conf.urls import patterns, url, include
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
router = routers.DefaultRouter()
router.register(r'category', views.CategoryViewSet)
router.register(r'eligibility_check', views.EligibilityCheckViewSet, base_name='eligibility_check')
router.register(r'case', views.CaseViewSet)
eligibility_check_router = \
NestedSimpleRouter(router,
'eligibility_check',
lookup='eligibility_check_')
eligibility_check_router.register(r'property',
views.PropertyViewSet,
base_name='property',
)
urlpatterns = patterns('',
url(r'^', include(router.urls)),
url(r'^', include(eligibility_check_router.urls)),
)
import sitestatistics.views
from authviews.views import FacebookLogin, GoogleLogin
router = SimpleRouter()
router.register(r'comments/compressors', comments.views.CompressorCommentViewSet)
router.register(r'comments/divesites', comments.views.DivesiteCommentViewSet)
router.register(r'comments/slipways', comments.views.SlipwayCommentViewSet)
router.register(r'compressors', divesites.views.CompressorViewSet, base_name='compressor')
router.register(r'divesites', divesites.views.DivesiteViewSet, base_name='divesite')
router.register(r'dives', divesites.views.DiveViewSet)
router.register(r'slipways', divesites.views.SlipwayViewSet, base_name='slipway')
router.register(r'users', profiles.views.ProfileViewSet, base_name='profile')
compressors_router = NestedSimpleRouter(router, r'compressors', lookup='compressor')
compressors_router.register(r'images', images.views.ImageViewSet, base_name='compressor-image')
divesites_router = NestedSimpleRouter(router, r'divesites', lookup='divesite')
divesites_router.register(r'images', images.views.ImageViewSet, base_name='divesite-image')
slipways_router = NestedSimpleRouter(router, r'slipways', lookup='slipway')
slipways_router.register(r'images', images.views.ImageViewSet, base_name='slipway-image')
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^', include(router.urls)),
url(r'^', include(compressors_router.urls)),
url(r'^', include(divesites_router.urls)),
url(r'^', include(slipways_router.urls)),
url(r'^auth/', include('rest_auth.urls')),
url(r'^auth/facebook/$', FacebookLogin.as_view(), name='fb_login'),
from django.urls import path, include
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from auth.viewsets import ObtainTokenViewSet, LogoutViewSet, RegisterViewSet
from event.viewsets import EventViewSet
from user.viewsets import UserViewSet
from comment.viewsets import CommentViewSet
router = SimpleRouter()
# Auth
router.register(r'logout', LogoutViewSet, basename='auth-logout')
router.register(r'account', RegisterViewSet, basename='auth-login')
router.register(r'auth', ObtainTokenViewSet, basename='auth-token')
# user
router.register(r'user', UserViewSet, basename='user')
# event
router.register(r'event', EventViewSet, basename='event')
event_router = NestedSimpleRouter(router, r'event', lookup='event')
event_router.register(r'comment', CommentViewSet, basename='event-comment')
urlpatterns = [
path(r'v1/', include(router.urls + event_router.urls)),
]
AddonRecommendationView,
AddonSearchView,
AddonVersionViewSet,
AddonViewSet,
CompatOverrideView,
LanguageToolsView,
ReplacementAddonView,
StaticCategoryView,
)
addons = SimpleRouter()
addons.register(r'addon', AddonViewSet, basename='addon')
# Router for children of /addons/addon/{addon_pk}/.
sub_addons = NestedSimpleRouter(addons, r'addon', lookup='addon')
sub_addons.register('versions', AddonVersionViewSet, basename='addon-version')
sub_versions = NestedSimpleRouter(sub_addons, r'versions', lookup='version')
sub_versions.register(r'reviewnotes',
VersionReviewNotesViewSet,
basename='version-reviewnotes')
uploads = SimpleRouter()
uploads.register(r'upload', FileUploadViewSet, basename='addon-upload')
urls = [
re_path(r'', include(addons.urls)),
re_path(r'', include(sub_addons.urls)),
re_path(r'', include(sub_versions.urls)),
re_path(
r'^autocomplete/$',
AddonAutoCompleteSearchView.as_view(),
from django.conf.urls import url, include
from rest_framework_nested.routers import SimpleRouter, DefaultRouter, NestedSimpleRouter
from score.views import ScoreViewSet, ScoreDataViewSet
root_router = DefaultRouter()
root_router.register('score', ScoreViewSet, 'score')
root_router.register('score-data', ScoreDataViewSet, 'score-data')
score_router = SimpleRouter()
score_router.register('score', ScoreViewSet, base_name='list-score')
score_data_router = NestedSimpleRouter(score_router, 'score', lookup='score')
score_data_router.register('data', ScoreDataViewSet, base_name='list-score-data')
urlpatterns = [
url(r'', include(root_router.urls)),
url(r'list/', include(score_router.urls)),
url(r'list/', include(score_data_router.urls)),
]