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 rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from backend.api.token_resource import TokenResource
from backend.api.user.todo_resource import TodoResource
from backend.api.user_resource import UserResource
router = SimpleRouter(trailing_slash=False)
router.register(r'tokens', TokenResource, base_name='token')
router.register(r'users', UserResource, base_name='user')
user_router = NestedSimpleRouter(router, r'users', lookup='user', trailing_slash=False)
user_router.register(r'todos', TodoResource, base_name='todo')
urlpatterns = [
url(r'^api/v1/', include(
router.urls
+ user_router.urls
)),
]
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from olympia.activity.views import VersionReviewNotesViewSet
from .views import (AddonAutoCompleteSearchView, AddonFeaturedView,
AddonSearchView, AddonVersionViewSet, AddonViewSet,
CompatOverrideView, LanguageToolsView,
ReplacementAddonView, StaticCategoryView)
addons = SimpleRouter()
addons.register(r'addon', AddonViewSet, base_name='addon')
# 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_versions = NestedSimpleRouter(sub_addons, r'versions', lookup='version')
sub_versions.register(r'reviewnotes',
VersionReviewNotesViewSet,
base_name='version-reviewnotes')
urlpatterns = [
url(r'', include(addons.urls)),
url(r'', include(sub_addons.urls)),
url(r'', include(sub_versions.urls)),
url(r'^autocomplete/$',
AddonAutoCompleteSearchView.as_view(),
name='addon-autocomplete'),
url(r'^search/$', AddonSearchView.as_view(), name='addon-search'),
url(r'^featured/$', AddonFeaturedView.as_view(), name='addon-featured'),
router.register("mentor", MentorViewSet)
router.register("teacher", TeacherViewSet)
router.register("programDirector", ProgramDirectorViewSet)
router.register("programManager", ProgramManagerViewSet)
router.register("headmaster", HeadmasterViewSet)
router.register("parent", ParentViewSet)
router.register("executive", ExecutiveViewSet)
if not settings.IS_PRODUCTION:
router.register("mentorNoAuth", MentorNoAuthViewSet)
router.register("session", SessionViewSet)
session_nested_router = NestedSimpleRouter(router,
r"session",
lookup="session")
session_nested_router.register("mentor", MentorSessionViewSet)
session_nested_router.register("student", StudentSessionViewSet)
router.register("slot", SlotViewSet)
slot_nested_router = NestedSimpleRouter(router, r"slot", lookup="slot")
slot_nested_router.register(r"student", StudentSlotViewSet)
slot_nested_router.register(r"mentor", MentorSlotViewSet)
router.register("program", ProgramViewSet)
from vbb_backend.program.api.viewsets.computer import ComputerViewSet
from vbb_backend.program.api.viewsets.program import ProgramViewSet
from vbb_backend.program.api.viewsets.school import SchoolViewSet
from vbb_backend.program.api.viewsets.slot import SlotViewSet
from vbb_backend.program.api.viewsets.student_slot import StudentSlotViewSet
from vbb_backend.users.api.viewsets.student import StudentViewSet
if settings.DEBUG:
router = DefaultRouter()
else:
router = SimpleRouter()
router.register("program", ProgramViewSet)
program_nested_router = NestedSimpleRouter(router, r"program", lookup="program")
program_nested_router.register(r"school", SchoolViewSet)
program_nested_router.register(r"computer", ComputerViewSet)
computer_nested_router = NestedSimpleRouter(
program_nested_router, r"computer", lookup="computer"
)
computer_nested_router.register(r"slot", SlotViewSet)
slot_nested_router = NestedSimpleRouter(computer_nested_router, r"slot", lookup="slot")
from django.conf.urls import patterns, url, include
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from thinkster_django_angular_boilerplate.views import IndexView
from authentication.views import AccountViewSet, LoginView, LogoutView
from posts.views import AccountPostViewSet, PostViewSet
router = SimpleRouter()
router.register(r'accounts', AccountViewSet)
router.register(r'posts', PostViewSet)
accounts_router = NestedSimpleRouter(router, r'accounts', lookup='account')
accounts_router.register(r'posts', AccountPostViewSet)
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('^.*$', IndexView.as_view(), name='index'),
)
UserViewSets.UserList.UserAdminViewSet,
base_name='admin-user')
admin_router.register(r'users',
UserViewSets.UserInstance.UserAdminViewSet,
base_name='admin-user')
admin_router.register(
r'organizations',
OrganizationViewSets.OrganizationList.OrganizationAdminViewSet,
base_name='admin-organization')
admin_router.register(
r'organizations',
OrganizationViewSets.OrganizationInstance.OrganizationAdminViewSet,
base_name='admin-organization')
# --------
admin_organization_router = NestedSimpleRouter(admin_router,
r'organizations',
lookup='admin_organization')
admin_organization_router.register(
r'categories',
CategoryViewSet.CategoryList.CategoryOrgAdminViewSet,
base_name='admin-organization-categories')
admin_organization_router.register(
r'categories',
CategoryViewSet.CategoryInstance.CategoryOrgAdminViewSet,
base_name='admin-organization-categories')
admin_organization_router.register(
r'available-categories',
CategoryViewSet.CategoryList.CategoryAvailableOrgAdminViewSet,
base_name='admin-organization-available-categories')
admin_organization_router.register(r'admins',
UserViewSets.UserList.EduAdminViewSet,
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)),
]
# posts/urls.py
from django.urls import path, include
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from posts.views import UserViewSet, PostViewSet, CommentViewSet, ImageViewSet, UserPostViewSet
router = SimpleRouter()
router.register('users', UserViewSet, base_name='user')
router.register('posts', PostViewSet, base_name='post')
users_router = NestedSimpleRouter(router, 'users', lookup='user')
users_router.register('posts', UserPostViewSet, base_name='user-post')
posts_router = NestedSimpleRouter(router, 'posts', lookup='post')
posts_router.register('comments', CommentViewSet, base_name='comment')
posts_router.register('images', ImageViewSet, base_name='image')
urlpatterns = [
path('', include(router.urls)),
path('', include(users_router.urls)),
path('', include(posts_router.urls)),
]
-> config
-> config
/measurement-types/
/alerts
"""
router = SimpleRouter()
router.register(r'companies', views.CompanyViewSet)
router.register(r'installations', views.InstallationViewSet)
router.register(r'gateways', views.GatewayViewSet)
router.register(r'measurement-types', views.MeasurementTypeViewSet)
router.register(r'user', views.UserViewSet)
router.register(r'alerts', views.AlertViewSet)
gateways_router = NestedSimpleRouter(router, r'gateways', lookup='gateway')
gateways_router.register(r'sensors', views.SensorViewSet)
gateways_router.register(r'config', views.GatewayConfigurationViewSet)
sensors_router = NestedSimpleRouter(gateways_router,
r'sensors',
lookup='sensor')
sensors_router.register(r'measurements', views.MeasurementViewSet)
sensors_router.register(r'config', views.SensorConfigurationViewSet)
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(gateways_router.urls)),
url(r'^', include(sensors_router.urls)),
url(r'^api-auth/',
include('rest_framework.urls', namespace='rest_framework')),
from django.conf.urls import url, include
from rest_framework import routers
from rest_framework_nested.routers import NestedSimpleRouter
from api.views import FrontMatterViewSet, BackMatterViewSet, CaseProofViewSet
from . import views
router = routers.DefaultRouter()
router.register(r'volumes', views.VolumeViewSet, 'volumes')
router.register(r'cases', views.CaseViewSet, 'cases')
nested_routers = []
nested_routers.append(NestedSimpleRouter(router, r'volumes', lookup='parent'))
nested_routers[-1].register(r'front_matter_proofs', FrontMatterViewSet)
nested_routers.append(NestedSimpleRouter(router, r'volumes', lookup='parent'))
nested_routers[-1].register(r'back_matter_proofs', BackMatterViewSet)
nested_routers.append(NestedSimpleRouter(router, r'cases', lookup='parent'))
nested_routers[-1].register(r'proofs', CaseProofViewSet)
# Wire up our API using automatic URL routing.
urlpatterns = [
url(r'^', include(router.urls)),
] + [url(r'^', include(router.urls)) for router in nested_routers]
# Additionally, we include login URLs for the browsable API.
# urlpatterns += [
# url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework'))
# ]
from django.conf import settings
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.conf.urls import include, url
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from olympia.reviews.views import ReviewViewSet
from . import views
accounts = SimpleRouter()
accounts.register(r'account', views.AccountViewSet, base_name='account')
# Router for children of /accounts/account/{account_pk}/.
sub_accounts = NestedSimpleRouter(accounts, r'account', lookup='account')
sub_accounts.register('reviews', ReviewViewSet, base_name='account-review')
urlpatterns = [
url(r'', include(accounts.urls)),
url(r'', include(sub_accounts.urls)),
url(r'^authenticate/$', views.AuthenticateView.as_view(),
name='accounts.authenticate'),
url(r'^login/$', views.LoginView.as_view(), name='accounts.login'),
url(r'^login/start/$',
views.LoginStartView.as_view(),
name='accounts.login_start'),
url(r'^profile/$', views.ProfileView.as_view(), name='accounts.profile'),
url(r'^register/$', views.RegisterView.as_view(),
name='accounts.register'),
url(r'^super-create/$', views.AccountSuperCreate.as_view(),
name='accounts.super-create'),
from django.conf.urls import url, include
from rest_framework_nested.routers import SimpleRouter, NestedSimpleRouter
from accounts.views import UserViewSet, UserProfileViewSet, UserContactViewSet
user_router = SimpleRouter()
user_router.register('user', UserViewSet, base_name='user')
user_profile_router = NestedSimpleRouter(user_router, 'user', lookup='user')
user_profile_router.register('profile', UserProfileViewSet, base_name='user-profile')
user_contact_router = NestedSimpleRouter(user_router, 'user', lookup='user')
user_contact_router.register('contact', UserContactViewSet, base_name='user-contact')
urlpatterns = [
url(r'', include(user_router.urls)),
url(r'', include(user_profile_router.urls)),
url(r'', include(user_contact_router.urls)),
]
from django.conf.urls import url, include
from rest_framework.permissions import AllowAny
from twitter.users.views import UserViewSet, UserTweetsViewSet
from twitter.tweets.views import TweetViewSet
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView, TokenVerifyView
from drf_yasg.views import get_schema_view
from drf_yasg import openapi
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
router = SimpleRouter(trailing_slash=False)
router.register(r'users', UserViewSet)
router.register(r'tweets', TweetViewSet)
users_router = NestedSimpleRouter(router, r'users', lookup='user')
users_router.register(r'tweets', UserTweetsViewSet, base_name='user-tweets')
schema_view = get_schema_view(
openapi.Info(
title="Twitter Clone API",
default_version='v1',
description="RESTful API for a simple Twitter clone",
terms_of_service=
"https://developer.twitter.com/en/developer-terms/agreement-and-policy.html",
contact=openapi.Contact(email="*****@*****.**"),
license=openapi.License(name="BSD License"),
),
validators=['flex', 'ssv'],
public=True,
permission_classes=(AllowAny, ),
)
)
from care.facility.api.viewsets.facility import FacilityViewSet
from care.facility.api.viewsets.facility_capacity import FacilityCapacityViewSet
from care.facility.api.viewsets.hospital_doctor import HospitalDoctorViewSet
from care.facility.api.viewsets.patient import PatientViewSet
from care.users.api.views import UserViewSet
if settings.DEBUG:
router = DefaultRouter()
else:
router = SimpleRouter()
router.register("users", UserViewSet)
router.register("facility", FacilityViewSet)
router.register("ambulance", AmbulanceViewSet)
router.register("ambulance/create", AmbulanceCreateViewSet)
router.register("patient", PatientViewSet)
# 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)
app_name = "api"
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(facility_nested_router.urls)),
]
from django.urls import include
from django.conf.urls import url
from rest_framework_nested.routers import DefaultRouter, NestedSimpleRouter
from .views import VotingCreatingViewSet, QuestionCreatingViewSet, ChoiceCreatingViewSet, VoterCreatingViewSet
router = DefaultRouter()
router.register(r'api/constructor', VotingCreatingViewSet, basename='votings')
vote_router = NestedSimpleRouter(router, r'api/constructor', lookup='voting')
vote_router.register(r'questions',
QuestionCreatingViewSet,
basename='questions')
choice_router = NestedSimpleRouter(vote_router, r'questions', lookup='choice')
choice_router.register(r'choices', ChoiceCreatingViewSet, basename='choices')
voters_router = NestedSimpleRouter(router, r'api/constructor', lookup='voter')
voters_router.register(r'voters', VoterCreatingViewSet, basename='voters')
constructor_urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(voters_router.urls)),
url(r'^', include(vote_router.urls)),
url(r'^', include(choice_router.urls)),
]
from approval.views import SketchVoteViewSet, SketchDecisionViewSet, WallPhotoWrapperDecisionViewSet
from django.urls import path, include
from rest_framework_nested.routers import NestedSimpleRouter
from rest_framework import routers
from workload.views import WorkloadViewSet, SketchViewSet, WallPhotoWrapperViewSet
router = routers.SimpleRouter()
router.register('workloads', WorkloadViewSet, basename='aworkload')
router.register('sketches', SketchViewSet, basename='sketch')
router.register('wall_photo_wrappers', WallPhotoWrapperViewSet, basename='wall_photo_wrapper')
router.register('wall_photo_wrapper_decisions', WallPhotoWrapperDecisionViewSet,
basename='wall_photo_wrapper_decision')
router.register('sketch_decisions', SketchDecisionViewSet, basename='sketch_decision')
sketch_base_router = NestedSimpleRouter(router, 'sketches', lookup='sketch')
sketch_base_router.register('votes', SketchVoteViewSet, basename='sketch_base_vote')
workload_router = NestedSimpleRouter(router, 'workloads', lookup='aworkload')
workload_router.register('sketches', SketchViewSet, basename='aworkload-sketch')
workload_router.register('wall_photo_wrappers', WallPhotoWrapperViewSet, basename='wall_photo_wrapper')
sketch_router = NestedSimpleRouter(workload_router, 'sketches', lookup='sketch')
sketch_router.register('votes', SketchVoteViewSet, basename='sketch_vote')
sketch_router.register('sketch_decisions', SketchDecisionViewSet, basename='workload-sketch_decision')
wall_photo_wrapper_router = NestedSimpleRouter(workload_router, 'wall_photo_wrappers', lookup='wall_photo_wrapper')
wall_photo_wrapper_router.register('wall_photo_wrapper_decisions', WallPhotoWrapperDecisionViewSet,
basename='nested-wall_photo_wrapper_decision')
urlpatterns = [
path('', include(router.urls)),
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
from .views import OrderViewSet, OrderedProductViewSet
router = DefaultRouter()
router.register(r'order', OrderViewSet)
ordered_product_router = NestedSimpleRouter(router, r'order', lookup='order')
ordered_product_router.register(r'ordered',
OrderedProductViewSet,
basename='ordered_product')
basename="scm-pipeline-runs")
router.register("queued-scm-pipeline-runs",
views.QueuedSCMPipelineRunViewSet,
basename="queued-scm-pipeline-runs")
router.register("scm-step-runs",
views.SCMStepRunViewSet,
basename="scm-step-runs")
router.register("scm-releases",
views.SCMReleaseViewSet,
basename="scm-releases")
router.register("update-scm-step-run",
views.SCMStepRunUpdateStatusView,
basename="update-scm-step-run")
secrets_router = NestedSimpleRouter(router,
"credentials",
lookup="credentials")
secrets_router.register("secrets",
views.CredentialSecretsViewSet,
basename="secrets")
app_metadata_router = NestedSimpleRouter(router,
"applications",
lookup="applications")
app_metadata_router.register("metadata",
views.ApplicationMetadataViewSet,
basename="metadata")
urlpatterns = [
path("admin/", admin.site.urls),
path("", include(router.urls)),
from django.conf.urls import include, patterns, url
from rest_framework.routers import SimpleRouter
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
addons = SimpleRouter()
addons.register(r'addon', views.AddonViewSet)
# Router for children of /addons/addon/{addon_pk}/.
sub_addons = NestedSimpleRouter(addons, r'addon', lookup='addon')
sub_addons.register(r'versions',
views.AddonVersionViewSet,
base_name='addon-version')
urlpatterns = patterns(
'',
url(r'', include(addons.urls)),
url(r'', include(sub_addons.urls)),
url(r'^search/$', views.AddonSearchView.as_view(), name='addon-search'),
url(r'^featured/$',
views.AddonFeaturedView.as_view(),
name='addon-featured'),
)
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 blog.views import BlogpostViewSet, CommentViewSet, NestedCommentViewSet
from users.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 rest_framework_nested.routers import NestedSimpleRouter
from rest_framework.routers import DefaultRouter
from .views import MetaProblemViewSets, ProblemViewSets, CategoryViewSets, SubmissionViewSets
from .views import EnvironmentViewSets, UserViewSets
from .views import ClientViewSets
admin_router = DefaultRouter()
# == Meta Problem ======================================================================================================
admin_router.register(
r'meta-problems', MetaProblemViewSets.MetaAdminViewSet, base_name='admin-meta-problems'
)
admin_meta_router = NestedSimpleRouter(admin_router, r'meta-problems', lookup='meta_problem')
# -- Components --------------------------------------------------------------------------------------------------------
admin_meta_router.register(
r'descriptions', MetaProblemViewSets.Description.List.DescriptionAdminViewSet, base_name='admin-meta-descriptions'
)
admin_meta_router.register(
r'descriptions',
MetaProblemViewSets.Description.Instance.DescriptionAdminViewSet, base_name='admin-meta-descriptions'
)
admin_meta_router.register(
r'samples', MetaProblemViewSets.Sample.List.SampleAdminViewSet, base_name='admin-meta-samples'
)
admin_meta_router.register(
r'samples', MetaProblemViewSets.Sample.Instance.SampleAdminViewSet, base_name='admin-meta-samples'
)
admin_meta_router.register(
r'test-data', MetaProblemViewSets.TestData.List.TestDataAdminViewSet, base_name='admin-meta-tests'
)
from django.urls import path, include
from rest_framework.routers import DefaultRouter, APIRootView
from rest_framework_nested.routers import NestedSimpleRouter
from . import views
router = DefaultRouter()
router.APIRootView = APIRootView
router.register('tweets', views.TweetViewSet, basename='tweet')
tweet_router = NestedSimpleRouter(router, "tweets", lookup="tweet")
tweet_router.register('tags', views.TweetTagViewSet, basename='tweet-tags')
app_name = 'tweet'
urlpatterns = [
path('api/', include(router.urls)),
path('api/', include(tweet_router.urls)),
]
class ChildViewSet(ModelViewSet):
serializer_class = ChildSerializer
queryset = Child.objects.all()
class ChildWithNestedMixinViewSet(NestedViewSetMixin, ModelViewSet):
"""Identical to `ChildViewSet` but with the mixin."""
serializer_class = ChildSerializer
queryset = Child.objects.all()
router = SimpleRouter()
router.register('root', RootViewSet, base_name='root')
root_router = NestedSimpleRouter(router, r'root', lookup='parent')
root_router.register(r'child', ChildViewSet, base_name='child')
root_router.register(r'child-with-nested-mixin', ChildWithNestedMixinViewSet, base_name='child-with-nested-mixin')
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(root_router.urls)),
]
@override_settings(ROOT_URLCONF=__name__)
class TestNestedSimpleRouter(TestCase):
def setUp(self):
"""
We look at the same data but with different `ViewSet`s. One regular
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)
from django.conf.urls import patterns, include, url
from django.contrib import admin
from rest_framework.routers import DefaultRouter
from rest_framework_nested.routers import NestedSimpleRouter
from authentication.views import AccountViewSet
from pods.views import PodViewSet, PermissionsViewSet
from songs.views import SongViewSet
router = DefaultRouter()
router.register(r'accounts', AccountViewSet)
router.register(r'pods', PodViewSet)
router.register(r'songs', SongViewSet)
accounts_router = NestedSimpleRouter(router, r'accounts', lookup='account')
accounts_router.register('songs', SongViewSet)
pods_router = NestedSimpleRouter(router, r'pods', lookup='pod')
pods_router.register(r'songs', SongViewSet)
pods_router.register(r'accounts', AccountViewSet, base_name='accounts')
permissions_router = NestedSimpleRouter(pods_router,
r'accounts',
lookup='account')
permissions_router.register(r'permissions', PermissionsViewSet)
urlpatterns = patterns(
'',
url(r'^admin', include(admin.site.urls)),
router.register("ambulance", AmbulanceViewSet)
router.register("patient/search", PatientSearchViewSet)
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)),
from django.urls import include, 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'),
re_path(r'^session/$',
from .views import ProjectViewset, TasksViewset, UserViewset, get_image_data
from rest_framework_nested.routers import NestedSimpleRouter, SimpleRouter
from django.urls import path, include
parent_router = SimpleRouter()
user_router = SimpleRouter()
parent_router.register('project', ProjectViewset)
user_router.register('user', UserViewset)
prj_router = NestedSimpleRouter(parent_router, r'project', lookup='project')
prj_router.register('task', TasksViewset, basename='project-tasks')
urlpatterns = [
path('', include(parent_router.urls)),
path('', include(prj_router.urls)),
path('', include(user_router.urls)),
path('image/', get_image_data),
]
from rest_framework.routers import SimpleRouter from rest_framework_nested.routers import NestedSimpleRouter from news.v1.views import CommentViewSet, NewsViewSet router = SimpleRouter() router.register(r"news", NewsViewSet, basename="news") news_router = NestedSimpleRouter(router, r"news", lookup="news") news_router.register(r"comments", CommentViewSet, basename="comments") urlpatterns = router.urls + news_router.urls
