def build_urls(self):
router = routers.DefaultRouter()
router.register(r'repositories', self.RepositoryViewSet, base_name='{0}_repository'.format(self.view_prefix))
router.register(r'external_dependencies', self.ExternalDependencyViewSet, base_name='{0}_externaldependency'.format(self.view_prefix))
router.register(r'sources', self.PackageSourceViewSet, base_name='{0}_packagesource'.format(self.view_prefix))
router.register(r'builds', self.BuildViewSet, base_name='{0}_buildrecord'.format(self.view_prefix))
router.register(r'mirrors', self.MirrorViewSet, base_name='{0}_mirror'.format(self.view_prefix))
router.register(r'mirror_sets', self.MirrorSetViewSet, base_name='{0}_mirrorset'.format(self.view_prefix))
router.register(r'snapshots', self.SnapshotViewSet, base_name='{0}_snapshot'.format(self.view_prefix))
source_router = routers.NestedSimpleRouter(router, r'sources', lookup='source')
source_router.register(r'builds', self.BuildViewSet, base_name='{0}_build'.format(self.view_prefix))
repository_router = routers.NestedSimpleRouter(router, r'repositories', lookup='repository')
repository_router.register(r'sources', self.PackageSourceViewSet, base_name='{0}_packagesource'.format(self.view_prefix))
repository_router.register(r'external_dependencies', self.ExternalDependencyViewSet, base_name='{0}_externaldependency'.format(self.view_prefix))
repository_router.register(r'builds', self.BuildViewSet, base_name='{0}_build'.format(self.view_prefix))
urls = [url(r'^', include(router.urls)),
url(r'^', include(repository_router.urls)),
url(r'^', include(source_router.urls)),
url(r'^auth/', include('rest_auth.urls')),
url(r'^auth/github/$', GithubLogin.as_view(), name='github_login')]
if getattr(settings, 'SIGNUP_OPEN', False):
urls += [url(r'^auth/registration/', include('rest_auth.registration.urls'))]
return urls
def register_nested_router(self, parent_router, parent_key, router_args):
nested, kwargs = self.handle_nested_args(router_args)
router = routers.NestedSimpleRouter(parent_router, parent_key,
**kwargs)
self.subrouters.append(router)
for key, value in nested.items():
self.register_router(router, name=key, router_args=value)
def add_sub_urls(endpoint, viewset, model_name):
router.register(endpoint, viewset, basename=model_name)
sub_router = routers.NestedSimpleRouter(router,
endpoint,
lookup=model_name)
sub_router.register(r'versions',
VersionViewSet,
basename='%s-version'.format(model_name))
urls.extend(sub_router.urls)
def register_device_urls(router):
"""
Add the user managed / related device endpoints
"""
devices_path = r'devices'
router.register(devices_path, DeviceViewSet)
# If it works, delete this
router.register(r'devices_heartbeat', DeviceHeartbeatViewSet)
devices_router = routers.NestedSimpleRouter(router,
devices_path,
lookup='device')
devices_router.register(r'heartbeats',
DeviceHeartbeatViewSet,
base_name='device-heartbeat')
devices_router.register(r'sprinkles',
ScheduleViewSet,
base_name='device-sprinkle')
return [url(r'^api/', include(devices_router.urls))]
from django.urls import path
from django.urls import include
from . import views
from rest_framework_nested import routers
router = routers.DefaultRouter()
router.register('students', views.StudentView, base_name='students')
router.register('schools', views.SchoolView, base_name='schools')
school_router = routers.NestedSimpleRouter(router, r'schools', lookup='school')
school_router.register(r'students', views.StudentView, base_name='students')
urlpatterns = [
path('', include(router.urls)),
path('', include(school_router.urls))
]
from rest_framework_nested import routers
from biohub.core.routes import register_api, register_default, url
from . import views
router = DefaultRouter()
router.register('step', views.StepViewSet, base_name='step')
router.register('subroutine', views.SubRoutineViewSet, base_name='subroutine')
router.register('report', views.ReportViewSet, base_name='report')
router.register('label', views.LabelViewSet, base_name='label')
router.register('archive', views.ArchiveViewSet, base_name='archive')
router.register('graph', views.PictureViewSet, base_name='graph')
router.register('vars', views.UserVariableViewSet, base_name='vars')
router.register('comment', views.CommentPostSingleViewSet, base_name='comment')
comment_router = routers.NestedSimpleRouter(router,
'comment',
lookup='comment')
# comment_router.register(r'nameservers', views.CommentPostSingleViewSet, base_name='domain-comment')
register_api(r'^editor/', router.urls)
register_api(r'^editor/', comment_router.urls)
register_api(r'^', [
url(r'^users/labels/(?P<user_id>[0-9]+)/$',
views.LabelViewSet.list_user_labels),
url(r'^users/popular-reports-list/?$',
views.ReportViewSet.get_popular_reports),
url(r'^reports-simple/(?P<report_id>[0-9]+)/?$',
views.ReportViewSet.get_report_simple),
url(r'^users/popular-reports-list/(?P<user_id>[0-9]+)/?$',
views.ReportViewSet.get_user_popular_reports),
url(r'^users/reports/archives/(?P<user_id>[0-9]+)/?$',
from django.conf.urls import url, include
from rest_framework_nested import routers
from django.urls import path
from . import views
router = routers.SimpleRouter()
router.register(r'games', views.GameViewSet)
games_router = routers.NestedSimpleRouter(router, r'games', lookup='game')
games_router.register(r'moves', views.MoveViewSet, base_name='game-moves')
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(games_router.urls)),
url(r'play', views.play_game)
]
from features.views import FeatureViewSet
from integrations.datadog.views import DataDogConfigurationViewSet
from integrations.new_relic.views import NewRelicConfigurationViewSet
from projects.tags.views import TagViewSet
from segments.views import SegmentViewSet
from . import views
from .views import (
UserPermissionGroupProjectPermissionsViewSet,
UserProjectPermissionsViewSet,
)
router = routers.DefaultRouter()
router.register(r"", views.ProjectViewSet, basename="project")
projects_router = routers.NestedSimpleRouter(router, r"", lookup="project")
projects_router.register(r"features",
FeatureViewSet,
basename="project-features")
projects_router.register(r"segments",
SegmentViewSet,
basename="project-segments")
projects_router.register(
r"user-permissions",
UserProjectPermissionsViewSet,
basename="project-user-permissions",
)
projects_router.register(
r"user-group-permissions",
UserPermissionGroupProjectPermissionsViewSet,
basename="project-user-group-permissions",
from django.conf.urls import url, include
from rest_framework_nested import routers
from features.views import FeatureStateViewSet
from .views import IdentityViewSet, EnvironmentViewSet, TraitViewSet, WebhookViewSet, UserEnvironmentPermissionsViewSet, \
UserPermissionGroupEnvironmentPermissionsViewSet
router = routers.DefaultRouter()
router.register(r'', EnvironmentViewSet, basename="environment")
environments_router = routers.NestedSimpleRouter(router,
r'',
lookup="environment")
environments_router.register(r'identities',
IdentityViewSet,
basename="environment-identities")
environments_router.register(r'webhooks',
WebhookViewSet,
basename='environment-webhooks')
environments_router.register(r'featurestates',
FeatureStateViewSet,
basename="environment-featurestates")
environments_router.register(r'user-permissions',
UserEnvironmentPermissionsViewSet,
basename='environment-user-permissions')
environments_router.register(r'user-group-permissions',
UserPermissionGroupEnvironmentPermissionsViewSet,
basename='environment-user-group-permissions')
identity_router = routers.NestedSimpleRouter(environments_router,
r'identities',
router.register(r'access_update', PartialUpdateView)
router.register(r'puds', PudViewSet)
router.register(r'notification_posts', NotificationPostView)
router.register(r'notification_response', NotificationResponseView)
router.register(r'post_update', PostUpdateView)
router.register(r'freetime', FreeTimeViewSet)
# Initially used APIView. Didn't make it to make, keep getting 405. Switched to
# ModelViewSet and worked at once. Experience:
router.register(r'signup', SignUpCreateAndListView)
# For creating Pref-based signup
router.register(r'signupPref', PrefSignUpCreatAndListView)
router.register(r'schedule', ScheduleViewSet)
# For return description of a specific signup post
signup_router = routers.NestedSimpleRouter(router, r'signup', lookup='post')
signup_router.register(r'get_description', SignUpCreateAndListView)
signup_router.register(r'request', SignUpView)
# Get the list of slot for a pref_based signup
signup_router.register(r'prefSlots', RequesterSignUpView)
signup_router.register(r'requestPref', RequesterSignUpView)
signup_router.register(r'get_suggestion', ResolveSignupView)
signup_router.register(r'resolve_schedule', ResolveSignupView)
# For other users to select signup slots
select_slot_router = routers.NestedSimpleRouter(signup_router,
r'get_description',
lookup='duration')
select_slot_router.register(r'request', SignUpView)
from django.urls import path, include
#from .views import LocationViewSet, ParameterViewSet
from rest_framework_nested import routers
from .views import LocationViewSet, ParameterViewSet
app_name = "weather"
router = routers.SimpleRouter()
router.register('locations', LocationViewSet)
locations_router = routers.NestedSimpleRouter(router,
'locations',
lookup='location')
locations_router.register('parameters',
ParameterViewSet,
basename='location-parameters')
urlpatterns = [
path("", include(router.urls)),
path("", include(locations_router.urls))
]
from rest_framework_swagger.views import get_swagger_view
from django.conf.urls import url, include
from gameservice import views
from rest_framework_nested import routers
router = routers.DefaultRouter()
router.register(r'games', views.GameViewSet)
router.register(r'contests', views.ContestViewSet)
router.register(r'players', views.PlayerViewSet)
router.register(r'submissions', views.SubmissionViewSet)
# router.register(r'contests/(?P<id>\d+)/history', views.ContestHistoryViewSet)
schema_view = get_swagger_view(title='GameServer ISOLA')
nested_router = routers.NestedSimpleRouter(router,
r'contests',
lookup='contest')
nested_router.register(r'history',
views.NestedContestHistoryViewSet,
base_name='contests')
urlpatterns = [
url(r'api/v1/swagger', schema_view),
url(r'api/v1/', include(nested_router.urls)),
url(r'api/v1/', include(router.urls))
]
from rest_framework_nested import routers
from democracy.views import (
CommentViewSet, ContactPersonViewSet, HearingViewSet, ImageViewSet, LabelViewSet, ProjectViewSet,
RootSectionViewSet, SectionCommentViewSet, SectionViewSet, UserDataViewSet, FileViewSet, ServeFileView
)
router = routers.DefaultRouter()
router.register(r'hearing', HearingViewSet, base_name='hearing')
router.register(r'users', UserDataViewSet, base_name='users')
router.register(r'comment', CommentViewSet, base_name='comment')
router.register(r'image', ImageViewSet, base_name='image')
router.register(r'section', RootSectionViewSet, base_name='section')
router.register(r'label', LabelViewSet, base_name='label')
router.register(r'contact_person', ContactPersonViewSet, base_name='contact_person')
router.register(r'project', ProjectViewSet, base_name='project')
router.register(r'file', FileViewSet, base_name='file')
hearing_child_router = routers.NestedSimpleRouter(router, r'hearing', lookup='hearing')
hearing_child_router.register(r'sections', SectionViewSet, base_name='sections')
section_comments_router = routers.NestedSimpleRouter(hearing_child_router, r'sections', lookup='comment_parent')
section_comments_router.register(r'comments', SectionCommentViewSet, base_name='comments')
urlpatterns = [
url(r'^', include(router.urls, namespace='v1')),
url(r'^', include(hearing_child_router.urls, namespace='v1')),
url(r'^', include(section_comments_router.urls, namespace='v1')),
url(r'^download/(?P<filetype>sectionfile|sectionimage)/(?P<pk>\d+)/$', ServeFileView.as_view(), name='serve_file'),
]
from django.urls import path, include
from rest_framework_nested import routers
from . import viewsets
user_router = routers.DefaultRouter()
user_router.register('user-profile', viewsets.UserViewSet)
profile_router = routers.NestedSimpleRouter(user_router, 'user-profile', lookup='user')
profile_router.register('profile', viewsets.UserProfileViewSet)
follower_router = routers.NestedSimpleRouter(
user_router, 'user-profile', lookup='followee')
follower_router.register(
'follower', viewsets.FollowerViewSet, base_name='follower')
following_router = routers.NestedSimpleRouter(
user_router, 'user-profile', lookup='follower')
following_router.register(
'following', viewsets.FollowingViewSet, base_name='followee')
search_router = routers.DefaultRouter()
search_router.register('search', viewsets.SearchViewSet, base_name="search")
urlpatterns = [
path('', include(user_router.urls)),
path('', include(profile_router.urls)),
path('', include(follower_router.urls)),
path('', include(following_router.urls)),
path('', include(search_router.urls)),
]
from django.conf.urls import url, include
from rest_framework_nested import routers
from organisations.views import InviteViewSet
from . import views
router = routers.DefaultRouter()
router.register(r'', views.OrganisationViewSet, base_name="organisation")
organisations_router = routers.NestedSimpleRouter(router,
r'',
lookup="organisation")
organisations_router.register(r'invites',
InviteViewSet,
base_name="organisation-invites")
app_name = "organisations"
urlpatterns = [
url(r'^', include(router.urls)),
url(r'^', include(organisations_router.urls))
]
from django.urls import path
from rest_framework_nested import routers
from .views import DriverTripViewset, DriverPassengerActionsViewset, SearchTripViewset, PassengerTripViewset, ThirdPartyTripSearchView
router = routers.DefaultRouter()
# Driver endpoints
router.register('driver', DriverTripViewset, base_name='driver-trips')
# Passenger endpoints
router.register('passenger', PassengerTripViewset, base_name='passenger-trips')
# Search endpoints
router.register('local', SearchTripViewset, base_name='search-trips')
# Extra driver actions on passengers
driver_actions = routers.NestedSimpleRouter(router, 'driver', lookup='trip')
driver_actions.register('passengers',
DriverPassengerActionsViewset,
base_name='driver-trips-passengers')
urlpatterns = router.urls
urlpatterns += [path('external/', ThirdPartyTripSearchView.as_view())]
urlpatterns += driver_actions.urls
# Libraries
###
from django.conf.urls import url, include
from django.contrib import admin
from rest_framework_nested import routers
from helpers.health_check_view import health_check
from topics.views import TopicViewSet
from posts.views import PostViewSet
from comments.views import CommentViewSet
router = routers.SimpleRouter()
router.register(r'topics', TopicViewSet)
posts_router = routers.NestedSimpleRouter(router, r'topics', lookup='topic')
posts_router.register(r'posts', PostViewSet, basename='topic-posts')
comments_router = routers.NestedSimpleRouter(posts_router,
r'posts',
lookup='post')
comments_router.register(r'comments', CommentViewSet, basename='post-comments')
###
# URLs
###
urlpatterns = [
# Admin
url(r'^admin/', admin.site.urls),
# Health Check
from elearning.views import \
UserViewSet, StudentViewSet, \
TeacherViewSet, CourseViewSet, LessonViewSet, \
QuestionViewSet, AnswerViewSet
# Routers provide an easy way of automatically determining the URL conf.
router = routers.DefaultRouter()
router.register(r'users', UserViewSet, base_name='users')
router.register(r'students', StudentViewSet, base_name='students')
router.register(r'teachers', TeacherViewSet, base_name='teachers')
router.register(r'courses', CourseViewSet, base_name='courses')
router.register(r'lessons', LessonViewSet, base_name='lessons')
router.register(r'questions', QuestionViewSet, base_name='questions')
router.register(r'answers', AnswerViewSet, base_name='answers')
course_router = routers.NestedSimpleRouter(router, r'courses', lookup='course')
course_router.register(r'lessons', LessonViewSet, base_name='lessons')
lesson_router = routers.NestedSimpleRouter(course_router,
r'lessons',
lookup='lesson')
lesson_router.register(r'questions', QuestionViewSet, base_name='questions')
question_router = routers.NestedSimpleRouter(lesson_router,
r'questions',
lookup='question')
question_router.register(r'answers', AnswerViewSet, base_name='answers')
# Wire up our API using automatic URL routing.
# Additionally, we include login URLs for the browsable API.
urlpatterns = [
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 include
from django.conf.urls import url
from journal import views
from rest_framework_nested import routers
router = routers.DefaultRouter()
router.register(r'journals', views.JournalViewSet)
router.register(r'journal/(?P<journal_uid>[^/]+)', views.EntryViewSet)
router.register(r'user', views.UserInfoViewSet)
journals_router = routers.NestedSimpleRouter(router,
r'journals',
lookup='journal')
journals_router.register(r'members',
views.MembersViewSet,
base_name='journal-members')
journals_router.register(r'entries',
views.EntryViewSet,
base_name='journal-entries')
urlpatterns = [
url(r'^api/v1/', include(router.urls)),
url(r'^api/v1/', include(journals_router.urls)),
]
# Adding this just for testing, this shouldn't be here normally
urlpatterns += url(r'^reset/$', views.reset, name='reset_debug'),
from django.urls import include, path
from rest_framework.routers import SimpleRouter
from rest_framework_nested import routers
from scenarios.api.urls import router
from platforms.api import views
from investments.api.views import InvestmentAASummaryViewset
app_name = "platforms"
scenario_router = routers.NestedSimpleRouter(router,
r'scenarios',
lookup='scenario')
scenario_router.register(r'platforms', views.PlatformViewSet, 'platforms')
platform_router = routers.NestedSimpleRouter(scenario_router,
r'platforms',
lookup='platform')
platform_router.register(r'platformfees', views.PlatformFeeViewSet,
'platformfees')
platform_fee_router = routers.NestedSimpleRouter(platform_router,
r'platformfees',
lookup='platformfee')
platform_fee_router.register(r'tier-thresholds',
views.PlatformTierThresholdViewSet,
"tier-thresholds")
from orochi.website.api.views import (
DumpViewSet,
ResultViewSet,
PluginViewSet,
ExtractedDumpViewSet,
)
if settings.DEBUG:
router = routers.DefaultRouter()
else:
router = routers.SimpleRouter()
router.register(r"users", UserViewSet)
router.register(r"dumps", DumpViewSet)
router.register(r"plugin", PluginViewSet)
dumps_router = routers.NestedSimpleRouter(router, r"dumps", lookup="dump")
dumps_router.register(r"results", ResultViewSet, basename="dump-plugins")
extdumps_router = routers.NestedSimpleRouter(dumps_router,
r"results",
lookup="result")
extdumps_router.register(r"ext-dumps",
ExtractedDumpViewSet,
basename="dump-plugins-ext")
app_name = "api"
urlpatterns = [
path(r"", include(router.urls)),
path(r"", include(dumps_router.urls)),
path(r"", include(extdumps_router.urls)),
]
base_rest_api_router.register(r"metadata_types",
views.MetadataTypeViewSet,
basename="metadata_type")
base_rest_api_router.register(r"metadata_groups", views.MetadataGroupViewSet)
base_rest_api_router.register(r"protocols", views.ProtocolViewSet)
base_rest_api_router.register(r"measurement_types",
views.MeasurementTypesViewSet,
basename="measurement_types")
base_rest_api_router.register(r"users", views.UsersViewSet, basename="users")
base_rest_api_router.register("export", views.ExportViewSet, basename="export")
base_rest_api_router.register("stream-export",
views.StreamingExportViewSet,
basename="stream-export")
###################################################################################################
# /rest/studies nested resources
###################################################################################################
study_router = nested_routers.NestedSimpleRouter(base_rest_api_router,
r"studies",
lookup="study")
study_router.register(r"lines", views.StudyLinesView, basename="study-lines")
study_router.register(r"assays",
views.StudyAssaysViewSet,
basename="study-assays")
study_router.register(r"measurements",
views.StudyMeasurementsViewSet,
basename="study-measurements")
study_router.register(r"values",
views.StudyValuesViewSet,
basename="study-values")
from django.conf import settings
from django.urls import path
from drf_yasg import openapi
from drf_yasg.views import get_schema_view
from rest_framework.permissions import AllowAny
from rest_framework.routers import SimpleRouter
from rest_framework.urlpatterns import format_suffix_patterns
# see https://github.com/alanjds/drf-nested-routers
from rest_framework_nested import routers
from icat_hooks.views import RegistrationCreateViewSet, RegistrationViewSet, SubscriptionViewSet
router = SimpleRouter(trailing_slash=False)
# hook management (registration, add/update/delete hooks)
router.register(r"register", RegistrationCreateViewSet, "Web Hook Registration")
router.register(r"registration", RegistrationViewSet, "Web Hook Registration")
registrations_router = routers.NestedSimpleRouter(
router, r"registration", lookup="registration"
)
registrations_router.register(
r"subscriptions", SubscriptionViewSet, basename="subscriptions"
)
urlpatterns = format_suffix_patterns(router.urls + registrations_router.urls)
"""
API V1: Posts Urls
"""
###
# Libraries
###
from django.conf.urls import url, include
from rest_framework_nested import routers
from topics.api.v1.urls import router
from .views import ListCreatePostViewSet,RetriveUpdateDeletePostViewSet
###
# Routers
###
""" Main router """
posts_router = routers.NestedSimpleRouter(router, r'topics', lookup='topic')
# router = routers.SimpleRouter()
posts_router.register(prefix="posts",viewset=ListCreatePostViewSet, basename='posts')
posts_router.register(prefix="posts",viewset=RetriveUpdateDeletePostViewSet, basename='posts')
###
# URLs
###
urlpatterns = [
url(r'^', include(posts_router.urls)),
]
from django.urls import path, include
from rest_framework_nested import routers
from .views import ListViewSet, ListItemViewSet
router = routers.SimpleRouter()
router.register(r'', ListViewSet)
lists_router = routers.NestedSimpleRouter(router, r'', lookup='list')
lists_router.register(r'list-items', ListItemViewSet)
urlpatterns = [
path(r'', include(router.urls)),
path(r'', include(lists_router.urls)),
]
from django.conf.urls import patterns, url, include
from rest_framework_nested import routers
from authentication.views import AccountViewSet,LoginView,LogoutView
from thinkster_django_angular_boilerplate.views import IndexView
from posts.views import AccountPostsViewSet, PostViewSet
router = routers.SimpleRouter()
router.register(r'accounts',AccountViewSet)
router.register(r'posts',PostViewSet)
accounts_router = routers.NestedSimpleRouter(
router,r'accounts',lookup='account'
)
accounts_router.register(r'posts',AccountPostsViewSet)
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'),
)
from organisation import viewsets as org_viewsets
from services import viewsets as services_viewsets
from calendars import viewsets as calendars_viewsets
from orders import viewsets as orders_viewsets
from feedback import viewsets as feedback_viewsets
router = routers.DefaultRouter()
router.register(r'users', viewsets.UserViewSet, 'user')
router.register(r'user-sites', viewsets.UserSiteViewSet, 'user-site')
router.register(r'logs', log_viewsets.LogEntryViewSet, 'log')
router.register(r'companies', org_viewsets.CompanyViewSet, 'company')
router.register(r'calendarentries', calendars_viewsets.CalendarEntryViewSet, 'calendarentries')
router.register(r'services', services_viewsets.ServicePackageViewSet, 'services')
router.register(r'feedback', feedback_viewsets.FeedbackViewSet, 'feedback')
companies_router = routers.NestedSimpleRouter(router, r'companies', lookup='company')
companies_router.register(r'pictures', org_viewsets.CompanyPictureViewSet, 'company-pictures')
companies_router.register(r'orders', orders_viewsets.CompanyOrderViewSet, 'company-orders')
companies_router.register(r'users', org_viewsets.CompanyUserViewSet, 'company-users')
user_router = routers.NestedSimpleRouter(router, r'users', lookup='user')
user_router.register(r'orders', orders_viewsets.UserOrderViewSet, 'user-orders')
user_router.register(r'rate-order', orders_viewsets.RateOrderViewSet, 'user-orders-rate')
urlpatterns = [
url(r'^verify-user/$', views.VerifyUserView.as_view(), name='user-verify'),
url(r'^login/$', views.LoginView.as_view(), name='login'),
url(r'^logout/$', views.LogoutView.as_view(), name='logout'),
url(r'^forgotten-password/$', views.PasswordResetRequestView.as_view(), name='forgotten-password'),
url(r'^reset-password/$', views.PasswordResetView.as_view(), name='reset-password'),
url(r'^ytr/', include('ytr.urls')),
from users.api import UserViewSet
from ledgers.api import (AccountViewSet, PayeeViewSet, TransactionViewSet,
LedgerViewSet, NestedAccountViewSet,
NestedPayeeViewSet, NestedTransactionViewSet)
app_name = "api"
router = routers.DefaultRouter(trailing_slash=False)
router.register(r'users', UserViewSet)
router.register(r'ledgers', LedgerViewSet)
router.register(r'accounts', AccountViewSet)
router.register(r'payees', PayeeViewSet)
router.register(r'transactions', TransactionViewSet)
ledger_router = routers.NestedSimpleRouter(router,
'ledgers',
lookup='ledger',
trailing_slash=False)
ledger_router.register(r'accounts', NestedAccountViewSet, base_name='accounts')
ledger_router.register(r'payees', NestedPayeeViewSet, base_name='payees')
ledger_router.register(r'transactions',
NestedTransactionViewSet,
base_name='transactions')
urlpatterns = [
url(r'^', include('authentication.urls')),
url(r'^', include(router.urls)),
url(r'^', include(ledger_router.urls)),
]
from django.urls import path, include
from api.v1.authentication import views as authentication_views
from api.v1.author import views as author_views
from api.v1.book import views as book_views
from api.v1.order import views as order_views
from rest_framework import routers
from rest_framework_nested import routers as nested_routers
router = routers.DefaultRouter()
router.register('authentication', authentication_views.CustomUserViewSet)
router.register('author', author_views.AuthorViewSet)
router.register('book', book_views.BookViewSet)
router.register('order', order_views.OrderViewSet)
order_router = nested_routers.NestedSimpleRouter(
router,
r'authentication',
lookup='user')
order_router.register(
r'order',
order_views.OrdersByUserViewSet,
basename='user-orders')
urlpatterns = [
path('', include(router.urls)),
path('', include(order_router.urls)),
]
MetadataItemApiViewset
)
from .views.quality import (
QualityCriterionApiViewset,
QualityLevelApiViewset,
QualityRulesetApiViewset
)
app_name = 'api'
# Register ViewSets
router = routers.DefaultRouter()
router.register('datasources', DataSourceApiViewset, base_name='datasource')
router.register('rulesets', QualityRulesetApiViewset, base_name='rulesets')
datasource_router = routers.NestedSimpleRouter(router, 'datasources', lookup='datasource')
datasource_router.register('metadata_items', MetadataItemApiViewset, base_name='metadata-item')
ruleset_router = routers.NestedSimpleRouter(router, 'rulesets', lookup='ruleset')
ruleset_router.register('levels', QualityLevelApiViewset, base_name='levels')
level_router = routers.NestedSimpleRouter(ruleset_router, 'levels', lookup='level')
level_router.register('criteria', QualityCriterionApiViewset, base_name='criteria')
urlpatterns = [
path('',
include(router.urls)),
path('',
include(datasource_router.urls)),
