Example #1
0
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>[^/.]+)/$')
Example #2
0
 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)
Example #4
0
 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>[^/.]+)/$')
Example #8
0
 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 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>[^/.]+)/'
            )
Example #11
0
class TestBadLookupValue(TestCase):
    def setUp(self):
        self.router = SimpleRouter()
        self.router.register(r'parents', AViewSet, base_name='ui-parent_1')

    def test_bad_lookup(self):
        with self.assertRaises(ValueError):
            self.a_router = NestedSimpleRouter(self.router, r'parents', lookup='ui-parent_2')
            self.a_router.register(r'child', BViewSet, base_name='ui-parent-child')
class TestBadLookupValue(TestCase):
    def setUp(self):
        self.router = SimpleRouter()
        self.router.register(r'parents', AViewSet, base_name='ui-parent_1')

    def test_bad_lookup(self):
        with self.assertRaises(ValueError):
            self.a_router = NestedSimpleRouter(self.router, r'parents', lookup='ui-parent_2')
            self.a_router.register(r'child', BViewSet, base_name='ui-parent-child')
Example #13
0
    def test_explicit_no_trailing_slash(self):
        router = SimpleRouter(trailing_slash=True)
        router.register('a', AViewSet)
        a_router = NestedSimpleRouter(router,
                                      'a',
                                      lookup='a',
                                      trailing_slash=False)
        a_router.register('b', BViewSet)

        self._assertDoesNotHaveTrailingSlash(a_router)
 def 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)
Example #17
0
    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)
Example #18
0
class TestEmptyPrefix(TestCase):
    def setUp(self):
        self.router = SimpleRouter()
        self.router.register(r'', AViewSet)
        self.a_router = NestedSimpleRouter(self.router, r'', lookup='a')
        self.a_router.register(r'b', BViewSet)

    def test_empty_prefix(self):
        urls = self.router.urls
        urls = self.a_router.urls
        self.assertEquals(len(urls), 2)
        self.assertEquals(get_regex_pattern(urls[0]), u'^(?P<a_pk>[0-9a-f]{32})/b/$')
        self.assertEquals(get_regex_pattern(urls[1]), u'^(?P<a_pk>[0-9a-f]{32})/b/(?P<pk>[^/.]+)/$')
class TestEmptyPrefix(TestCase):
    def setUp(self):
        self.router = SimpleRouter()
        self.router.register(r'', AViewSet)
        self.a_router = NestedSimpleRouter(self.router, r'', lookup='a')
        self.a_router.register(r'b', BViewSet)

    def test_empty_prefix(self):
        urls = self.router.urls
        urls = self.a_router.urls
        self.assertEquals(len(urls), 2)
        self.assertEquals(get_regex_pattern(urls[0]), u'^(?P<a_pk>[0-9a-f]{32})/b/$')
        self.assertEquals(get_regex_pattern(urls[1]), u'^(?P<a_pk>[0-9a-f]{32})/b/(?P<pk>[^/.]+)/$')
Example #20
0
    def test_explicit_trailing_slash(self):
        """
        Test whether the trailing_slash=False value is properly overridden when setting
        trailing_slash=True on the nested router.
        """
        router = SimpleRouter(trailing_slash=False)
        router.register('a', AViewSet)
        a_router = NestedSimpleRouter(router,
                                      'a',
                                      lookup='a',
                                      trailing_slash=True)
        a_router.register('b', BViewSet)

        self._assertHasTrailingSlash(a_router)
    def test_inherits_nonstandard_trailing_slash(self):
        """
        Test whether the trailing_slash attribute, when set with a custom value,
        is inherited by the nested routed.
        """
        router = SimpleRouter()
        router.trailing_slash = '/?'
        router.register('a', AViewSet)
        a_router = NestedSimpleRouter(router, 'a', lookup='a')
        a_router.register('b', BViewSet)

        self.assertEqual(a_router.trailing_slash, u'/?', "router does not have trailing slash when it should")
        self.assertTrue(pattern_from_url(a_router.urls[0]).endswith('/?$'),
                        "router created url without trailing slash when it should have")
Example #22
0
    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")
Example #23
0
    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
Example #26
0
    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)
Example #27
0
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)),
Example #28
0
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,
Example #29
0
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)),
Example #30
0
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'),
Example #31
0
    "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")
Example #32
0
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}),
]
Example #34
0
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)),
]
Example #35
0
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)),
]
Example #36
0
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'),
)
Example #37
0
    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
Example #38
0
File: urls.py Project: diox/olympia
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'),
Example #39
0
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)))
Example #40
0
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)),
]
Example #41
0
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
Example #42
0
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
Example #43
0
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
Example #44
0
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'),
)
Example #45
0
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')),
Example #46
0
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))
]
Example #47
0
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)),
)
Example #48
0
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)),
]
Example #49
0
# -*- 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')
Example #50
0
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'),
)
Example #51
0
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'),
Example #52
0
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))
]
Example #53
0
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'),
)
Example #55
0
#
"""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))
Example #56
0
File: urls.py Project: sdob/dsapi
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')),
Example #57
0
    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")
Example #58
0
    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/$',
Example #59
0
    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')),
]