def test_nested_route(self):
router = ExtendedSimpleRouter()
(
router.register(r'users', UserViewSet, 'user')
.register(r'groups', GroupViewSet, 'users-group', parents_query_lookups=['user'])
)
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(router.urls[0]._regex, r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(router.urls[1]._regex, r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(router.urls[2]._regex, r'^users/{0}/groups/$'.format(
self.get_parent_lookup_regex('user')
)
)
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(router.urls[3]._regex, r'^users/{0}/groups/{1}/$'.format(
self.get_parent_lookup_regex('user'),
self.get_lookup_regex('pk')
),
)
def test_nested_route(self):
router = ExtendedSimpleRouter()
(router.register(r'users', UserViewSet,
'user').register(r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user']))
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]),
r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(
get_regex_pattern(router.urls[2]), r'^users/{0}/groups/$'.format(
self.get_parent_lookup_regex('user')))
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(
get_regex_pattern(router.urls[3]),
r'^users/{0}/groups/{1}/$'.format(
self.get_parent_lookup_regex('user'),
self.get_lookup_regex('pk')),
)
def test_nested_route_depth_3(self):
router = ExtendedSimpleRouter()
(router.register(r'users', UserViewSet, 'user').register(
r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user']).register(r'permissions',
PermissionViewSet,
'users-groups-permission',
parents_query_lookups=[
'group__user',
'group',
]))
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]),
r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(
get_regex_pattern(router.urls[2]), r'^users/{0}/groups/$'.format(
self.get_parent_lookup_regex('user')))
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(
get_regex_pattern(router.urls[3]),
r'^users/{0}/groups/{1}/$'.format(
self.get_parent_lookup_regex('user'),
self.get_lookup_regex('pk')),
)
# test users groups permission list
self.assertEqual(router.urls[4].name, 'users-groups-permission-list')
self.assertEqual(
get_regex_pattern(router.urls[4]),
r'^users/{0}/groups/{1}/permissions/$'.format(
self.get_parent_lookup_regex('group__user'),
self.get_parent_lookup_regex('group'),
))
# test users groups permission detail
self.assertEqual(router.urls[5].name, 'users-groups-permission-detail')
self.assertEqual(
get_regex_pattern(router.urls[5]),
r'^users/{0}/groups/{1}/permissions/{2}/$'.format(
self.get_parent_lookup_regex('group__user'),
self.get_parent_lookup_regex('group'),
self.get_lookup_regex('pk')),
)
def test_one_route(self):
router = ExtendedSimpleRouter()
router.register(r'users', UserViewSet, 'user')
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]), r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
def test_one_route(self):
router = ExtendedSimpleRouter()
router.register(r'users', UserViewSet, 'user')
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(router.urls[0]._regex, r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(router.urls[1]._regex, r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
def test_urls_have_trailing_slash_by_default(self):
router = ExtendedSimpleRouter()
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
for exp in ['^router-viewset/$',
'^router-viewset/(?P<pk>[^/.]+)/$',
'^router-viewset/list_controller/$',
'^router-viewset/(?P<pk>[^/.]+)/detail_controller/$']:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
def test_urls_have_trailing_slash_by_default(self):
router = ExtendedSimpleRouter()
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
lookup_allowed_symbols = get_lookup_allowed_symbols()
for exp in ['^router-viewset/$',
'^router-viewset/{0}/$'.format(lookup_allowed_symbols),
'^router-viewset/list_controller/$',
'^router-viewset/{0}/detail_controller/$'.format(lookup_allowed_symbols)]:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
def test_nested_route_depth_3(self):
router = ExtendedSimpleRouter()
(
router.register(r'users', UserViewSet, 'user')
.register(r'groups', GroupViewSet, 'users-group', parents_query_lookups=['user'])
.register(r'permissions', PermissionViewSet, 'users-groups-permission', parents_query_lookups=[
'group__user',
'group',
]
)
)
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(router.urls[0]._regex, r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(router.urls[1]._regex, r'^users/{0}/$'.format(self.get_lookup_regex('pk')))
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(router.urls[2]._regex, r'^users/{0}/groups/$'.format(
self.get_parent_lookup_regex('user')
)
)
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(router.urls[3]._regex, r'^users/{0}/groups/{1}/$'.format(
self.get_parent_lookup_regex('user'),
self.get_lookup_regex('pk')
),
)
# test users groups permission list
self.assertEqual(router.urls[4].name, 'users-groups-permission-list')
self.assertEqual(router.urls[4]._regex, r'^users/{0}/groups/{1}/permissions/$'.format(
self.get_parent_lookup_regex('group__user'),
self.get_parent_lookup_regex('group'),
)
)
# test users groups permission detail
self.assertEqual(router.urls[5].name, 'users-groups-permission-detail')
self.assertEqual(router.urls[5]._regex, r'^users/{0}/groups/{1}/permissions/{2}/$'.format(
self.get_parent_lookup_regex('group__user'),
self.get_parent_lookup_regex('group'),
self.get_lookup_regex('pk')
),
)
def test_urls_can_have_trailing_slash_removed(self):
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
lookup_allowed_symbols = get_lookup_allowed_symbols(
force_dot=get_rest_framework_features()['allow_dot_in_lookup_regex_without_trailing_slash']
)
for exp in ['^router-viewset$',
'^router-viewset/{0}$'.format(lookup_allowed_symbols),
'^router-viewset/list_controller$',
'^router-viewset/{0}/detail_controller$'.format(lookup_allowed_symbols)]:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
def test_urls_can_have_trailing_slash_removed(self):
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'router-viewset', RouterViewSet)
urls = router.urls
if get_rest_framework_features()['allow_dot_in_lookup_regex_without_trailing_slash']:
lookup_allowed_symbols = '(?P<pk>[^/.]+)'
else:
lookup_allowed_symbols = '(?P<pk>[^/]+)'
for exp in ['^router-viewset$',
'^router-viewset/' + lookup_allowed_symbols + r'$',
'^router-viewset/list_controller$',
'^router-viewset/' + lookup_allowed_symbols + '/detail_controller$']:
msg = 'Should find url pattern with regexp %s' % exp
self.assertIsNotNone(get_url_pattern_by_regex_pattern(urls, exp), msg=msg)
# -*- coding: utf-8 -*-
from django.conf.urls import url
from rest_framework_extensions.routers import ExtendedSimpleRouter
from . import views
router = ExtendedSimpleRouter()
(
router.register(r'processos', views.ProcessoViewSet, base_name='processo')
.register(
r'eventos', views.EventoViewSet, base_name='processos-evento',
parents_query_lookups=['processo']),
)
urlpatterns = router.urls
urlpatterns += [
url(r'^processos/(?P<parent_lookup_processo>[^/.]+)/partes/$', views.ParteListAPIView.as_view(), name='processos-partes-list')
]
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (ChartStyleViewSet, PartViewSet, NestedSheetViewSet,
SheetViewSet, NestedOperationViewSet,
OperationMethodViewSet, OperationTypeViewSet,
OperationViewSet)
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'chart_styles',
ChartStyleViewSet,
base_name='chartstyle')
router.register(r'operation_methods',
OperationMethodViewSet,
base_name='operationmethod')
router.register(r'operation_types',
OperationTypeViewSet,
base_name='operationtype')
router.register(r'operations',
OperationViewSet,
base_name='operation')
(router.register(r'parts', PartViewSet, base_name='part')
.register(r'sheets',
NestedSheetViewSet,
'parts-sheet',
parents_query_lookups=['part']))
from rest_framework_extensions.routers import ExtendedSimpleRouter
from dandi.publish.views import (
AssetViewSet,
DandisetViewSet,
VersionViewSet,
draft_lock_view,
draft_owners_view,
draft_publish_view,
draft_unlock_view,
draft_view,
search_view,
stats_view,
)
router = ExtendedSimpleRouter()
(router.register(r'dandisets', DandisetViewSet, basename='dandiset').register(
r'versions',
VersionViewSet,
basename='version',
parents_query_lookups=[f'dandiset__{DandisetViewSet.lookup_field}'],
).register(
r'assets',
AssetViewSet,
basename='asset',
parents_query_lookups=[
f'version__dandiset__{DandisetViewSet.lookup_field}',
f'version__{VersionViewSet.lookup_field}',
],
))
def test_nested_route_depth_3_custom_regex(self):
"""
Nested routes with over two level of depth should respect all parents'
`lookup_value_regex` attribute.
"""
router = ExtendedSimpleRouter()
(
router.register(r'users', CustomRegexUserViewSet, 'user')
.register(r'groups', CustomRegexGroupViewSet, 'users-group',
parents_query_lookups=['user'])
.register(r'permissions', CustomRegexPermissionViewSet,
'users-groups-permission', parents_query_lookups=[
'group__user',
'group',
]
)
)
# custom regex configuration
user_viewset_regex = CustomRegexUserViewSet.lookup_value_regex
group_viewset_regex = CustomRegexGroupViewSet.lookup_value_regex
perm_viewset_regex = CustomRegexPermissionViewSet.lookup_value_regex
# test user list
self.assertEqual(router.urls[0].name, 'user-list')
self.assertEqual(get_regex_pattern(router.urls[0]), r'^users/$')
# test user detail
self.assertEqual(router.urls[1].name, 'user-detail')
self.assertEqual(get_regex_pattern(router.urls[1]), r'^users/{0}/$'.format(
self.get_custom_regex_lookup('pk', user_viewset_regex))
)
# test users group list
self.assertEqual(router.urls[2].name, 'users-group-list')
self.assertEqual(get_regex_pattern(router.urls[2]), r'^users/{0}/groups/$'.format(
self.get_custom_regex_parent_lookup('user', user_viewset_regex)
)
)
# test users group detail
self.assertEqual(router.urls[3].name, 'users-group-detail')
self.assertEqual(get_regex_pattern(router.urls[3]), r'^users/{0}/groups/{1}/$'.format(
self.get_custom_regex_parent_lookup('user', user_viewset_regex),
self.get_custom_regex_lookup('pk', group_viewset_regex)
),
)
# test users groups permission list
self.assertEqual(router.urls[4].name, 'users-groups-permission-list')
self.assertEqual(get_regex_pattern(router.urls[4]), r'^users/{0}/groups/{1}/permissions/$'.format(
self.get_custom_regex_parent_lookup('group__user', user_viewset_regex),
self.get_custom_regex_parent_lookup('group', group_viewset_regex),
)
)
# test users groups permission detail
self.assertEqual(router.urls[5].name, 'users-groups-permission-detail')
self.assertEqual(get_regex_pattern(router.urls[5]), r'^users/{0}/groups/{1}/permissions/{2}/$'.format(
self.get_custom_regex_parent_lookup('group__user', user_viewset_regex),
self.get_custom_regex_parent_lookup('group', group_viewset_regex),
self.get_custom_regex_lookup('pk', perm_viewset_regex)
),
)
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import TeamViewSet, ProfileViewSet, TeamMemberViewSet
router = ExtendedSimpleRouter()
router.register(r'team', TeamViewSet, basename='team').\
register(r'member', TeamMemberViewSet, basename='member', parents_query_lookups=['team'])
router.register(r'profile', ProfileViewSet, basename='profile')
urlpatterns = router.urls
__author__ = 'liucaiyun'
from django.conf.urls import patterns, include, url
from django.contrib import admin
from rest_framework_extensions.routers import ExtendedSimpleRouter
from viewsets import *
router = ExtendedSimpleRouter()
shipment = router.register(r'shipments',
ShipmentOrderViewSet,
base_name="api_shipments")
shipment.register(r'items',
ShipmentOrderItemViewSet,
base_name="api_shipment_items",
parents_query_lookups=['order'])
shipment.register(r'boxs',
ShipmentBoxViewSet,
base_name="api_shipment_boxs",
parents_query_lookups=['order'])
urlpatterns = patterns(
'',
url(r'^api/', include(router.urls)),
)
PAYMENT_URLS = [
url(r"^processors/$", cache_page(60 * 30)(views.PaymentProcessorListView.as_view()), name="list_processors")
]
REFUND_URLS = [
url(r"^$", views.RefundCreateView.as_view(), name="create"),
url(r"^(?P<pk>[\d]+)/process/$", views.RefundProcessView.as_view(), name="process"),
]
ATOMIC_PUBLICATION_URLS = [
url(r"^$", views.AtomicPublicationView.as_view(), name="create"),
url(r"^{course_id}$".format(course_id=COURSE_ID_PATTERN), views.AtomicPublicationView.as_view(), name="update"),
]
urlpatterns = [
url(r"^baskets/", include(BASKET_URLS, namespace="baskets")),
url(r"^orders/", include(ORDER_URLS, namespace="orders")),
url(r"^payment/", include(PAYMENT_URLS, namespace="payment")),
url(r"^refunds/", include(REFUND_URLS, namespace="refunds")),
url(r"^publication/", include(ATOMIC_PUBLICATION_URLS, namespace="publication")),
]
router = ExtendedSimpleRouter()
router.register(r"courses", views.CourseViewSet).register(
r"products", views.ProductViewSet, base_name="course-product", parents_query_lookups=["course_id"]
)
router.register(r"products", views.ProductViewSet)
urlpatterns += router.urls
url(
r"^{course_id}$".format(course_id=COURSE_ID_PATTERN),
publication_views.AtomicPublicationView.as_view(),
name="update",
),
]
urlpatterns = [
url(r"^baskets/", include(BASKET_URLS, namespace="baskets")),
url(r"^coupons/", include(COUPON_URLS, namespace="coupons")),
url(r"^payment/", include(PAYMENT_URLS, namespace="payment")),
url(r"^refunds/", include(REFUND_URLS, namespace="refunds")),
url(r"^publication/", include(ATOMIC_PUBLICATION_URLS, namespace="publication")),
]
router = ExtendedSimpleRouter()
router.register(r"courses", course_views.CourseViewSet).register(
r"products", product_views.ProductViewSet, base_name="course-product", parents_query_lookups=["course_id"]
)
router.register(r"partners", partner_views.PartnerViewSet).register(
r"products",
product_views.ProductViewSet,
base_name="partner-product",
parents_query_lookups=["stockrecords__partner_id"],
)
router.register(r"partners", partner_views.PartnerViewSet).register(
r"catalogs", catalog_views.CatalogViewSet, base_name="partner-catalogs", parents_query_lookups=["partner_id"]
)
router.register(r"products", product_views.ProductViewSet)
router.register(r"stockrecords", stockrecords_views.StockRecordViewSet, base_name="stockrecords")
page = self.paginate_queryset(queryset)
if page is not None:
serializer = PostListSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = NewsListSerializer(queryset, many=True)
return Response(serializer.data)
def retrieve(self, request, *args, **kwargs):
instance = self.get_object()
instance.add_view()
serializer = self.get_serializer(instance)
return Response(serializer.data)
router = ExtendedSimpleRouter()
router.register(r'^news', NewsViewset, 'news')
router.register(r'^stats', PostViewset, 'posts')
def news_list(request):
news = News.objects.all()[:10]
return render_to_response('ajax_templates/blog/news_list.html', {'news': news},
context_instance=RequestContext(request))
def news_retrieve(request, slug):
news = get_object_or_404(News, slug=slug)
return render_to_response('ajax_templates/blog/news_retrieve.html', {'data': news},
context_instance=RequestContext(request))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from django.conf.urls import include
from django.conf.urls import url
from django.contrib import admin
from rest_framework_extensions.routers import (
ExtendedSimpleRouter as SimpleRouter
)
from project.applications.users.views import UserViewSet
from project.applications.authentication.views import AuthenticationViewSet
api_router = SimpleRouter()
api_router.register(r'users', UserViewSet)
api_router.register(r'auth', AuthenticationViewSet)
urlpatterns = [
url(r'^api/', include(api_router.urls)),
url(r'^admin/', admin.site.urls),
]
return Response(serializer.data)
return Response(Archive.objects.all().values_list('year', flat=True))
class CalendarViewset(ReadOnlyModelViewSet):
queryset = Calendar.objects.future_courses()
serializer_class = CalendarSerializer
lookup_field = 'slug'
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
if page is not None:
serializer = CalendarListSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = CalendarListSerializer(queryset, many=True)
return Response(serializer.data)
class PortfolioViewset(ModelViewSet):
queryset = Portfolio.objects.all()
serializer_class = PortfolioSerializer
router = ExtendedSimpleRouter()
router.register(r'^training-calendar', CalendarViewset, 'calendar')
router.register(r'^arhive(/(?P<year>\d{4}))?', ArchiveViewset, 'arhive')
router.register(r'^acts', PortfolioViewset, 'only-acts')
from django.conf.urls import patterns, include, url
from django.contrib import admin
from rest_framework_extensions.routers import ExtendedSimpleRouter
from app.views import *
admin.site.site_header = 'Nectere Administration'
admin.site.site_title = 'Nectere Admin'
admin.site.index_title = 'Nectere Matchmaking System'
router = ExtendedSimpleRouter()
users_routes = router.register(
r'user',
UserViewSet,
base_name='user'
)
users_routes.register(
r'self',
UserSelfMetaViewSet,
base_name='user-self',
parents_query_lookups=['user']
)
users_routes.register(
r'meta',
UserMatchMetaViewSet,
base_name='user-meta',
parents_query_lookups=['user']
)
filter_route = router.register(
r'filter',
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.conf import settings
from django.conf.urls import patterns, include, url
from django.conf.urls.static import static
from etsy_convos.convos.views import *
from rest_framework import routers, serializers, viewsets
from rest_framework_extensions.routers import ExtendedSimpleRouter
# Comment the next two lines to disable the admin:
from django.contrib import admin
admin.autodiscover()
router = ExtendedSimpleRouter()
router.register(r'messages', ConvoMessageViewSet)
threads_routes = router.register(
r'threads',
ConvoThreadViewSet,
base_name='thread'
)
threads_routes.register(
r'messages',
ConvoMessageNestedViewSet,
base_name='thread-message',
parents_query_lookups=['thread']
)
urlpatterns = patterns('', # noqa
# Django Admin (Comment the next line to disable the admin)
from django.conf.urls import url, include
from rest_framework.routers import DefaultRouter
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import BucketListViewSet, UserView, BucketListItemViewSet
from .template_views import index, signedin, bucketlist_list
router = ExtendedSimpleRouter()
router.register(r'bucketlist', BucketListViewSet, base_name='bucketlist')\
.register(r'items', BucketListItemViewSet, base_name='items',
parents_query_lookups=['bucketlist'])
urlpatterns = router.urls
urlpatterns += [
url(r'^$', index, name='index'),
url(r'^signedin$', signedin, name='signedin'),
url(r'^bucketlist$', bucketlist_list, name='bucketlist_list'),
url(r'users/(?P<pk>[0-9]+)/$', UserView.as_view(), name='user-detail'),
]
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.urls import include
from rest_framework_extensions.routers import ExtendedSimpleRouter
from course_catalog import views
from course_catalog.views import WebhookOCWView
router = ExtendedSimpleRouter()
router.register(r"courses", views.CourseViewSet, basename="courses")
router.register(r"bootcamps", views.BootcampViewSet, basename="bootcamps")
router.register(r"programs", views.ProgramViewSet, basename="programs")
router.register(r"userlists", views.UserListViewSet,
basename="userlists").register(
r"items",
views.UserListItemViewSet,
basename="userlistitems",
parents_query_lookups=["user_list_id"],
)
router.register(r"videos", views.VideoViewSet, basename="videos")
router.register(r"favorites", views.FavoriteItemViewSet, basename="favorites")
router.register(r"topics", views.TopicViewSet, basename="topics")
router.register(r"podcasts", views.PodcastViewSet, basename="podcasts")
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 import routers
from portfolio import views
from rest_framework_extensions.routers import ExtendedSimpleRouter
#router = routers.DefaultRouter()
#router.register(r'users', views.UserViewSet)
#router.register(r'groups', views.GroupViewSet)
#router.register(r'portfolios', views.PortfolioViewSet)
#router.register(r'positions', views.PositionViewSet)
#router.register(r'transactions', views.TransactionViewSet)
router = ExtendedSimpleRouter()
(
router.register(r'portfolios', views.PortfolioViewSet)
.register(r'positions', views.PositionViewSet, base_name='positions-portfolios', parents_query_lookups=['portfolio_id'])
#.register(r'transactions', views.PositionViewSet, base_name='transactions-portfolios', parents_query_lookups=['portfolio_id'])
)
router2 = ExtendedSimpleRouter()
(
router.register(r'portfolios', views.PortfolioViewSet)
# .register(r'positions', views.PositionViewSet, base_name='positions-portfolios', parents_query_lookups=['portfolio_id'])
.register(r'transactions', views.TransactionViewSet, base_name='transactions-portfolios', parents_query_lookups=['portfolio_id'])
)
#router.register(r'users', views.UserViewSet)
#router.register(r'groups', views.GroupViewSet)
from .serializers import expandable_fields
import core.models
@api_view(['GET'])
@docstring(rest_docs['api_root'])
def api_root(request, format=None):
response_object = {}
for view_name in sorted(rest_exposed_url_views):
name = camel_case(view_name)
response_object[name] = reverse(
name+'-list', request=request, format=format)
return Response(response_object)
router = ExtendedSimpleRouter()
rest_urlpatterns = [
path('api/', api_root, name='api_root'),
path('api/login', token_views.obtain_auth_token, name='api_login'),
path('api/download/<uuid:uuid>/',
viewsets.download_blob, name='edoc_download'),
]
registered = router.register('experimenttemplate', viewsets.ExperimentTemplateViewSet, basename='experimenttemplate')
name = 'experimenttemplate'
registered.register('notes', viewsets.NoteViewSet,
basename=f'{name}-note', parents_query_lookups=['ref_note_uuid'])
registered.register('tags', viewsets.TagAssignViewSet,
basename=f'{name}-tag', parents_query_lookups=['ref_tag'])
from django.conf.urls import include, url
from rest_framework.routers import DefaultRouter
from rest_framework.schemas import get_schema_view
from rest_framework_jwt.views import verify_jwt_token, refresh_jwt_token, obtain_jwt_token
from rest_framework_extensions.routers import ExtendedSimpleRouter
from cq import views
router = ExtendedSimpleRouter()
users_router = router.register(r'users', views.UserViewSet, base_name='user')
users_router.register(r'profiles',
views.ProfileViewSet,
base_name='users-profile',
parents_query_lookups=['user'])
researches_router = router.register(r'researches',
views.ResearchViewSet,
base_name='research')
researches_router.register(r'articles',
views.ArticleViewSet,
base_name='researches-article',
parents_query_lookups=['research'])
researches_router.register(r'questions',
views.QuestionViewSet,
base_name='researches-question',
parents_query_lookups=['research'])
articles_router = router.register(r'articles',
views.ArticleViewSet,
base_name='article')
from .. import views
from ..authentication import EmployeeAuthentication, StaffAuthentication
from ..models import Employee, EmployeeToken, Staff, StaffToken
from ..serializers import EmployeePasswordSerializer, StaffPasswordSerializer
app_name = 'business'
router = SimpleRouter()
router.register(r'store', views.StoreViewSet, base_name='store')
router.register(r'food', views.FoodViewSet, base_name='food')
router.register(r'menu', views.MenuViewSet, base_name='menu')
router.register(r'ingredient', views.IngredientViewSet, base_name='ingredient')
router.register(r'orderedfood',
views.OrderedFoodViewSet,
base_name='orderedfood')
router_extended = ExtendedSimpleRouter()
router_extended.register(r'store', views.StoreViewSet,
base_name='store').register(
r'openingperiods',
views.StoreOpeningPeriodViewSet,
base_name='store-openingperiods',
parents_query_lookups=['pk'])
router_extended.register(r'store', views.StoreViewSet,
base_name='store').register(
r'holidayperiods',
views.StoreHolidayPeriodViewSet,
base_name='store-holidayperiods',
parents_query_lookups=['pk'])
router_extended.register(r'store', views.StoreViewSet,
base_name='store').register(
r'periods',
from django.conf.urls import url
from django.conf.urls import include
from rest_framework_extensions.routers import ExtendedSimpleRouter
from friendship import views
router = ExtendedSimpleRouter()
channel_router = router.register(r'',
views.FriendshipViewSet,
base_name='friendship')
urlpatterns = [
url(r'^', include(router.urls)),
]
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (TaskViewSet, TaskCommentViewSet, BookViewSet,
BookCommentViewSet)
router = ExtendedSimpleRouter()
# tasks route
(router.register(r'tasks',
TaskViewSet).register(r'comments',
TaskCommentViewSet,
'tasks-comment',
parents_query_lookups=['object_id']))
# books route
(router.register(r'books',
BookViewSet).register(r'comments',
BookCommentViewSet,
'books-comment',
parents_query_lookups=['object_id']))
urlpatterns = router.urls
url(r'^{course_id}$'.format(course_id=COURSE_ID_PATTERN),
publication_views.AtomicPublicationView.as_view(),
name='update'),
]
urlpatterns = [
url(r'^baskets/', include(BASKET_URLS, namespace='baskets')),
url(r'^checkout/$', include(CHECKOUT_URLS, namespace='checkout')),
url(r'^coupons/', include(COUPON_URLS, namespace='coupons')),
url(r'^payment/', include(PAYMENT_URLS, namespace='payment')),
url(r'^refunds/', include(REFUND_URLS, namespace='refunds')),
url(r'^publication/',
include(ATOMIC_PUBLICATION_URLS, namespace='publication')),
]
router = ExtendedSimpleRouter()
router.register(r'courses', course_views.CourseViewSet) \
.register(r'products', product_views.ProductViewSet,
base_name='course-product', parents_query_lookups=['course_id'])
router.register(r'partners', partner_views.PartnerViewSet) \
.register(r'products', product_views.ProductViewSet,
base_name='partner-product', parents_query_lookups=['stockrecords__partner_id'])
router.register(r'partners', partner_views.PartnerViewSet) \
.register(r'catalogs', catalog_views.CatalogViewSet,
base_name='partner-catalogs', parents_query_lookups=['partner_id'])
router.register(r'products', product_views.ProductViewSet)
router.register(r'stockrecords',
stockrecords_views.StockRecordViewSet,
base_name='stockrecords')
router.register(r'catalogs', catalog_views.CatalogViewSet) \
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from django.conf.urls import include
from django.conf.urls import url
from django.contrib import admin
from rest_framework_extensions.routers import (
ExtendedSimpleRouter as SimpleRouter
)
from project.applications.users.views import UserViewSet
from project.applications.authentication.views import AuthenticationViewSet
from project.applications.questions.views import QuestionViewSet, AnswerViewSet
api_router = SimpleRouter()
api_router.register(r'users', UserViewSet)
api_router.register(r'auth', AuthenticationViewSet)
qa_router = api_router.register(r'questions', QuestionViewSet)
qa_router.register(r'answers',
AnswerViewSet,
'question-answers',
parents_query_lookups=['id'])
urlpatterns = [
url(r'^api/', include(api_router.urls)),
url(r'^admin/', admin.site.urls),
]
https://docs.djangoproject.com/en/1.11/topics/http/urls/
"""
# Django imports
from django.conf.urls import include, url
from django.contrib import admin
from rest_framework_extensions.routers import ExtendedSimpleRouter
from zconnect.views import CeleryMQTTTestViewSet, StackSamplerView
from .views import DemoDeviceViewSet
##############################
# For this app
##############################
router = ExtendedSimpleRouter()
device_router = router.register(r'devices',
DemoDeviceViewSet,
base_name="devices")
##############################
# All
##############################
urlpatterns = [
# enable the admin interface
url(r'^admin/', admin.site.urls),
url(r'^stats/stacksampler', StackSamplerView.as_view()),
# Rest Auth requires auth urls. If we remove this, then we'll get an error
r'^{course_id}$'.format(course_id=COURSE_ID_PATTERN),
publication_views.AtomicPublicationView.as_view(),
name='update'
),
]
urlpatterns = [
url(r'^baskets/', include(BASKET_URLS, namespace='baskets')),
url(r'^checkout/$', include(CHECKOUT_URLS, namespace='checkout')),
url(r'^coupons/', include(COUPON_URLS, namespace='coupons')),
url(r'^payment/', include(PAYMENT_URLS, namespace='payment')),
url(r'^refunds/', include(REFUND_URLS, namespace='refunds')),
url(r'^publication/', include(ATOMIC_PUBLICATION_URLS, namespace='publication')),
]
router = ExtendedSimpleRouter()
router.register(r'courses', course_views.CourseViewSet) \
.register(r'products', product_views.ProductViewSet,
base_name='course-product', parents_query_lookups=['course_id'])
router.register(r'partners', partner_views.PartnerViewSet) \
.register(r'products', product_views.ProductViewSet,
base_name='partner-product', parents_query_lookups=['stockrecords__partner_id'])
router.register(r'partners', partner_views.PartnerViewSet) \
.register(r'catalogs', catalog_views.CatalogViewSet,
base_name='partner-catalogs', parents_query_lookups=['partner_id'])
router.register(r'products', product_views.ProductViewSet)
router.register(r'stockrecords', stockrecords_views.StockRecordViewSet, base_name='stockrecords')
router.register(r'catalogs', catalog_views.CatalogViewSet) \
.register(r'products', product_views.ProductViewSet, base_name='catalog-product',
parents_query_lookups=['stockrecords__catalogs'])
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include
from .views import TicketViewSet, ApproverViewSet
from rest_framework_extensions.routers import ExtendedSimpleRouter
from rest_framework.authtoken import views
from django_tickets.views import IndexView
router = ExtendedSimpleRouter()
router.register('api/tickets', TicketViewSet).register(
'approvers',
ApproverViewSet,
basename='tickets-approvers',
parents_query_lookups=['tickets_for_approval'])
urlpatterns = [
path('', include(router.urls)),
path('admin/', admin.site.urls),
path('api-auth/', include('rest_framework.urls')),
path('api/auth/', views.obtain_auth_token),
path('', IndexView.as_view(), name='index'),
]
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (
TaskViewSet,
TaskCommentViewSet,
BookViewSet,
BookCommentViewSet
)
router = ExtendedSimpleRouter()
# tasks route
(
router.register(r'tasks', TaskViewSet)
.register(r'comments', TaskCommentViewSet, 'tasks-comment', parents_query_lookups=['object_id'])
)
# books route
(
router.register(r'books', BookViewSet)
.register(r'comments', BookCommentViewSet, 'books-comment', parents_query_lookups=['object_id'])
)
urlpatterns = router.urls
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import ListViewSet, TaskViewSet
router = ExtendedSimpleRouter()
(
router.register(r'', ListViewSet, basename='list')
.register(r'todo', TaskViewSet, basename='list-task', parents_query_lookups=['list'])
)
urlpatterns = router.urls
# -*- coding: utf-8 -*-
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (
UserViewSet,
GroupViewSet,
PermissionViewSet,
)
router = ExtendedSimpleRouter()
# main routes
(
router.register(r'users', UserViewSet)
.register(r'groups', GroupViewSet, 'users-group', parents_query_lookups=['user_groups'])
.register(r'permissions', PermissionViewSet, 'users-groups-permission', parents_query_lookups=['group__user', 'group'])
)
# register on one depth
permissions_routes = router.register(r'permissions', PermissionViewSet)
permissions_routes.register(r'groups', GroupViewSet, 'permissions-group', parents_query_lookups=['permissions'])
permissions_routes.register(r'users', UserViewSet, 'permissions-user', parents_query_lookups=['groups__permissions'])
# simple routes
router.register(r'groups', GroupViewSet, 'group')
router.register(r'permissions', PermissionViewSet, 'permission')
urlpatterns = router.urls
from rest_framework import routers
from rest_framework_extensions.routers import ExtendedSimpleRouter
from surveys.views import surveys_views, survey_responses_views
survey_responses_router = ExtendedSimpleRouter()
survey_responses_router.register(
r'surveys', surveys_views.SurveysViewSet,
basename='surveys').register(r'survey-responses',
survey_responses_views.SurveyResponsesViewSet,
basename='survey-responses',
parents_query_lookups=['survey_id'])
slashless_survey_responses_router = routers.DefaultRouter(trailing_slash=False)
slashless_survey_responses_router.registry = survey_responses_router.registry[:]
from django.conf.urls import include, url
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .viewsets import BucketlistViewSet, UserViewSet, ItemViewSet
from api.views import api_root
router = ExtendedSimpleRouter()
(
router.register(r'bucketlists', BucketlistViewSet)
.register(r'items',
ItemViewSet,
base_name='bucketlist-items',
parents_query_lookups=['bucketlist']
)
)
router.register(r'users', UserViewSet)
router.register(r'items', ItemViewSet)
urlpatterns = [
url(r'^$', api_root),
url(r'^', include(router.urls)),
url(r'^auth/', include('rest_framework.urls', namespace='rest_framework')),
url(r'^docs/', include('rest_framework_swagger.urls')),
url(r'^token-auth/', 'rest_framework_jwt.views.obtain_jwt_token'),
]
from django.conf.urls import url, include
from django.contrib import admin
from rest_framework_extensions.routers import ExtendedSimpleRouter
from restapi import views
router = ExtendedSimpleRouter()
router.register(r'users', views.UserViewSet)
team_router = router.register(r'teams', views.TeamViewSet)
team_router.register(r'notes', views.NoteViewSet, base_name='team-notes', parents_query_lookups=['team_id'])
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
url(r'^o/', include('oauth2_provider.urls', namespace='oauth2_provider')),
url(r'^', include(router.urls))
]
from django.conf.urls import url, include
from rest_framework_extensions.routers import ExtendedSimpleRouter
from api import viewsets
from api.views import root_route, landing, dashboard, logout
router = ExtendedSimpleRouter()
(
router.register(r'bucketlists', viewsets.BucketlistViewset)
.register(
r'items',
viewsets.ItemViewset,
base_name='bucketlists-item',
parents_query_lookups=['parent_bucketlist']
)
)
urlpatterns = [
url(r'^$', landing),
url(r'^dashboard/', dashboard),
url(r'^logout/$', logout),
url(r'^api/', include(router.urls)),
url(r'^api/$', root_route),
url(r'^auth/login/', 'rest_framework_jwt.views.obtain_jwt_token'),
url(r'^blst/', include('rest_framework.urls', namespace='rest_framework')),
url(r'^docs/', include('rest_framework_swagger.urls')),
]
url.handler404 = 'api.views.custom_404'
from drf_yasg import openapi
from drf_yasg.views import get_schema_view
from rest_framework import permissions
from rest_framework_extensions.routers import ExtendedSimpleRouter
from multinet.api.views import (
AqlQueryViewSet,
NetworkViewSet,
TableViewSet,
UploadViewSet,
WorkspaceViewSet,
users_me_view,
users_search_view,
)
router = ExtendedSimpleRouter()
workspaces_routes = router.register('workspaces', WorkspaceViewSet)
workspaces_routes.register(
'tables',
TableViewSet,
basename='table',
parents_query_lookups=[f'workspace__{WorkspaceViewSet.lookup_field}'],
)
workspaces_routes.register(
'networks',
NetworkViewSet,
basename='network',
parents_query_lookups=[f'workspace__{WorkspaceViewSet.lookup_field}'],
)
workspaces_routes.register(
'uploads',
views.OrderFulfillView.as_view(),
name='fulfill'
),
)
PAYMENT_URLS = patterns(
'',
url(r'^processors/$', cache_page(60 * 30)(views.PaymentProcessorListView.as_view()), name='list_processors'),
)
REFUND_URLS = patterns(
'',
url(r'^$', views.RefundCreateView.as_view(), name='create'),
url(r'^(?P<pk>[\d]+)/process/$', views.RefundProcessView.as_view(), name='process'),
)
urlpatterns = patterns(
'',
url(r'^baskets/', include(BASKET_URLS, namespace='baskets')),
url(r'^orders/', include(ORDER_URLS, namespace='orders')),
url(r'^payment/', include(PAYMENT_URLS, namespace='payment')),
url(r'^refunds/', include(REFUND_URLS, namespace='refunds')),
)
router = ExtendedSimpleRouter()
router.register(r'courses', views.CourseViewSet)\
.register(r'products', views.ProductViewSet, base_name='course-product', parents_query_lookups=['course_id'])
router.register(r'products', views.ProductViewSet)
urlpatterns += router.urls
# third party
import rest_framework_jwt.views
import djoser.views
from rest_framework_jwt.views import obtain_jwt_token, refresh_jwt_token, verify_jwt_token;
from rest_framework_extensions.routers import ExtendedSimpleRouter
from django.conf.urls import include, url
from graphene_django.views import GraphQLView
# resumapp
from exps.views import ProjectViewSet, ContributionViewSet #, ExpViewSet
from skills.views import SkillViewSet
from profiles.views import ProfileViewSet
router = ExtendedSimpleRouter()
# router.register(r'exps', ExpViewSet)
router.register(r'projects', ProjectViewSet)
router.register(r'contributions', ContributionViewSet)
router.register(r'skills', SkillViewSet)
(
router.register(r'profiles', ProfileViewSet)
.register(r'projects', ProjectViewSet, parents_query_lookups=['profile_id'], base_name='profiles-contributions')
)
(
router.register(r'profiles', ProfileViewSet)
.register(r'contributions', ContributionViewSet, parents_query_lookups=['profile_id'], base_name='profiles-projects')
)
# graphql token view
# http://stackoverflow.com/questions/39026831/how-to-use-graphene-graphql-framework-with-django-rest-framework-authentication
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (
UserViewSetWithEmailLookup,
GroupViewSet,
)
router = ExtendedSimpleRouter()
# main routes
(router.register(r'users', UserViewSetWithEmailLookup).register(
r'groups',
GroupViewSet,
'users-group',
parents_query_lookups=['user_groups__email']))
urlpatterns = router.urls
from rest_framework.routers import DefaultRouter
from api.views import AuthorViewSet, PostViewSet
from api.models import Author, Post
from rest_framework_extensions.routers import (ExtendedSimpleRouter as
SimpleRouter)
from rest_framework_extensions.routers import NestedRouterMixin
#router = DefaultRouter()
router = SimpleRouter()
router.register('authors', AuthorViewSet)
router.register('posts', PostViewSet)
class NestedDefaultRouter(NestedRouterMixin, DefaultRouter):
pass
router = NestedDefaultRouter()
posts_router = router.register('posts', PostViewSet)
authors_router = router.register('authors', AuthorViewSet)
authors_router.register('posts',
PostViewSet,
basename='posts',
parents_query_lookups=['author'])
from django.conf.urls import url, include
from django.contrib import admin
from django.contrib.auth.models import User
from rest_framework import routers, serializers, viewsets, permissions
from rest_framework_extensions.routers import ExtendedSimpleRouter
from app.views import *
from app import models
router = ExtendedSimpleRouter()
(
router.register(r'events', EventViewSet, base_name='events')
.register(r'attractions',
AttractionViewSet,
base_name='events-attractions',
parents_query_lookups=['event_id'])
)
router.register(r'categories', create_model_view_set(Category), base_name='categories')
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
url(r'^reactions/', ReactionView.as_view()),
url(r'^', include(router.urls)),
]
#from rest_framework_extensions.routers import DefaultRouter
from rest_framework_extensions.routers import (
ExtendedSimpleRouter as SimpleRouter
)
from srv.applications.users.views import UserViewSet
from srv.applications.authentication.views import AuthenticationViewSet
from srv.applications.game.views import *
from srv.applications.game import urls as gameurls
from srv.applications.profiles import urls as profileurls
#import srv.applications.symbolic_math
#from .settings import MEDIA_ROOT
api_router = SimpleRouter()
api_router.register(r'users', UserViewSet)
api_router.register(r'auth', AuthenticationViewSet)
api_router.register(r'categories', CategoryViewSet)
api_router.register(r'categories-with-apps', CategoryAppsViewSet)
api_router.register(r'apps', AppViewSet)
api_router.register(r'apps-minimal', AppMinimalViewSet)
api_router.register(r'instances', InstanceViewSet)
api_router.register(r'snapshots', SnapshotViewSet)
api_router.register(r'code_modules', CodeModuleViewSet)
api_router.register(r'instances-ordered', OrderedInstancesViewSet)
urlpatterns = [
url(r'^api/', include(api_router.urls)),
url(r'^admin/', admin.site.urls),
from django.urls import path, include
from rest_framework import routers
import items.urls
import orders.urls
from items.views import ItemViewSet, CategoryViewSet, FavouriteViewSet, FavouriteItemViewSet
from orders.views import (Order_itemViewSet, OrderViewSet, Order_detailViewSet,
updateStock, PosSystems, BalanceCheckAPIView,
BalanceCheckDetail, PosCheckAPIView)
# TodoViewSet
from actors.views import UserViewSet, CustomerViewSet, login
import actors.urls
from rest_framework_extensions.routers import ExtendedSimpleRouter
from django.conf import settings
from django.conf.urls.static import static
category_item_router = ExtendedSimpleRouter()
(category_item_router.register(r'categories',
UserViewSet,
basename='categories').register(
r'items',
ItemViewSet,
'categories_item',
parents_query_lookups=['category']))
user_favourite_router = ExtendedSimpleRouter()
(user_favourite_router.register(r'users', UserViewSet,
basename='users').register(
r'favourite',
FavouriteViewSet,
'users_favourite',
parents_query_lookups=['user']))
favourite_item_router = ExtendedSimpleRouter()
# -*- coding: utf-8 -*-
from rest_framework_extensions.routers import ExtendedSimpleRouter
from .views import (
UserViewSetWithEmailLookup,
GroupViewSet,
)
router = ExtendedSimpleRouter()
# main routes
(
router.register(r'users', UserViewSetWithEmailLookup)
.register(r'groups', GroupViewSet, 'users-group', parents_query_lookups=['user_groups__email'])
)
urlpatterns = router.urls
AssessmentsImagesView, AssessmentSyncView, RespondentTypeList,
ShareYourStoryAPIView, SurveyUserSummary,
SurveyBoundaryNeighbourInfoAPIView, AnswerViewSet,
SurveyBoundaryNeighbourDetailAPIView, SurveyDetailEBoundaryAPIView,
SurveyUsersCountAPIView, SurveyBoundaryAPIView, SurveyInstitutionAPIView,
BoundaryQuestionGroupMapping, SurveyAssociateBoundaryAPIView,
SurveyAssociateInstitutionAPIView, SurveyPartnersViewSet,
SurveySourceViewSet, SurveyTypeListView,
SurveyQuestionGroupQDetailsAPIView, SurveyInstitutionLocationAPIView,
SurveyGPAPIView, SurveyQuestionGroupQuestionKeyYearComparisonAPIView)
from schools.api_view import (InstitutionViewSet, StudentViewSet,
StudentGroupViewSet)
from rest_framework import routers
from rest_framework_extensions.routers import ExtendedSimpleRouter
nested_router = ExtendedSimpleRouter()
simple_router = routers.DefaultRouter()
simple_router.register(r'surveys/questions',
QuestionViewSet,
basename='survey-questions')
#survey/partner URL
simple_router.register(r'surveys/partners',
SurveyPartnersViewSet,
basename='survey-partners')
simple_router.register(r'surveys/sources',
SurveySourceViewSet,
basename='survey-sources')
# surveys -> questiongroup -> questions
from rest_framework_extensions.routers import ExtendedSimpleRouter, DefaultRouter router = ExtendedSimpleRouter() urlpatterns = router.urls
from django.conf.urls import patterns, include, url
from django.contrib import admin
from rest_framework_nested import routers
from base.views import MyUserViewSet, IndexView, HomeView
from tournoi.views import TournamentViewSet, TeamsViewSet, TPostViewSet, APostViewSet, ipn, ipn_test
from post.views import PostViewSet
from match.views import MatchViewSet
from rest_framework_extensions.routers import ExtendedSimpleRouter
router = ExtendedSimpleRouter(trailing_slash=False)
router.register(r'accounts', MyUserViewSet)
router.register(r'tournoi', TournamentViewSet).register(r'posts', TPostViewSet, base_name="TPost", parents_query_lookups=['tournoi'])
router.register(r'tournoi', TournamentViewSet).register(r'article', APostViewSet, base_name="APost", parents_query_lookups=['tournoi'])
router.register(r'tournoi', TournamentViewSet).register(r'team', TeamsViewSet, base_name="team", parents_query_lookups=['tournoi']).register(r'match', MatchViewSet, base_name='Match', parents_query_lookups=['tournoi', 'phase'])
router.register(r'posts', PostViewSet)
urlpatterns = patterns('',
url(r'^api/v1/', include(router.urls)),
url(r'^api/ret/ipn', view = ipn),
url(r'^api/v1/', include('base.urls')),
url(r'^home$', HomeView.as_view()),
url(r'^.*$', IndexView.as_view())
)
