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 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_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>[^/.]+)/$')
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, basename='ui-parent-child')
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')
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_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)
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_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 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_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
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)
router.register("ambulance/create", AmbulanceCreateViewSet) 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)),
cs_router.register(r'chartcategories', ChartCategoryViewSet) cs_router.register(r'keyflows', KeyflowInCasestudyViewSet) 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,
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)),
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'),
"district/patient_summary", DistrictPatientSummaryViewSet, 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")
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)) ]
from django.conf.urls import patterns, include, url from django.conf import settings 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.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)), ]
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)), ]
from rest_framework.routers import SimpleRouter 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'), )
SimpleUserViewSet, 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
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 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)))
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)), ]
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 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 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
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.routers import DefaultRouter 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.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 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)), )
from api.siteapp.views.projects import ProjectViewSet from api.siteapp.views.support import SupportViewSet from api.siteapp.views.tags import TagViewSet from api.siteapp.views.users import UsersViewSet from api.siteapp.views.role import RoleViewSet from api.siteapp.views.party import PartyViewSet from api.siteapp.views.appointment import AppointmentViewSet from api.siteapp.views.request import RequestViewSet from api.siteapp.views.proposal import ProposalViewSet router = routers.DefaultRouter() router.register(r'organizations', OrganizationViewSet) router.register(r'projects', ProjectViewSet) router.register(r'portfolios', PortfolioViewSet) router.register(r'support', SupportViewSet) router.register(r'tags', TagViewSet) router.register(r'users', UsersViewSet) router.register(r'roles', RoleViewSet) router.register(r'parties', PartyViewSet) router.register(r'appointments', AppointmentViewSet) router.register(r'requests', RequestViewSet) router.register(r'proposals', ProposalViewSet) project_router = NestedSimpleRouter(router, r'projects', lookup='projects') urlpatterns = [ url(r'^', include(router.urls)), url(r'^', include(project_router.urls)), ]
# -*- 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.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'), )
from api.teams import views as api_teams_views 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 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)) ]
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')) ]
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'), )
# """Describes the urls and patterns for the API application.""" 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))
import profiles.views 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')),
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")
AddonFeaturedView, 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/$',
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')), ]