def build_urls(self):
router = routers.DefaultRouter()
router.register(r'repositories', self.RepositoryViewSet, base_name='{0}_repository'.format(self.view_prefix))
router.register(r'external_dependencies', self.ExternalDependencyViewSet, base_name='{0}_externaldependency'.format(self.view_prefix))
router.register(r'sources', self.PackageSourceViewSet, base_name='{0}_packagesource'.format(self.view_prefix))
router.register(r'builds', self.BuildViewSet, base_name='{0}_buildrecord'.format(self.view_prefix))
router.register(r'mirrors', self.MirrorViewSet, base_name='{0}_mirror'.format(self.view_prefix))
router.register(r'mirror_sets', self.MirrorSetViewSet, base_name='{0}_mirrorset'.format(self.view_prefix))
router.register(r'snapshots', self.SnapshotViewSet, base_name='{0}_snapshot'.format(self.view_prefix))
source_router = routers.NestedSimpleRouter(router, r'sources', lookup='source')
source_router.register(r'builds', self.BuildViewSet, base_name='{0}_build'.format(self.view_prefix))
repository_router = routers.NestedSimpleRouter(router, r'repositories', lookup='repository')
repository_router.register(r'sources', self.PackageSourceViewSet, base_name='{0}_packagesource'.format(self.view_prefix))
repository_router.register(r'external_dependencies', self.ExternalDependencyViewSet, base_name='{0}_externaldependency'.format(self.view_prefix))
repository_router.register(r'builds', self.BuildViewSet, base_name='{0}_build'.format(self.view_prefix))
urls = [url(r'^', include(router.urls)),
url(r'^', include(repository_router.urls)),
url(r'^', include(source_router.urls)),
url(r'^auth/', include('rest_auth.urls')),
url(r'^auth/github/$', GithubLogin.as_view(), name='github_login')]
if getattr(settings, 'SIGNUP_OPEN', False):
urls += [url(r'^auth/registration/', include('rest_auth.registration.urls'))]
return urls
from django.urls import include, path
from rest_framework_nested import routers
from . import viewsets
ROUTER = routers.DefaultRouter()
ROUTER.register(r"customers", viewsets.CustomerViewSet)
ROUTER.register(r"boxes", viewsets.BoxViewSet)
ROUTER.register(r"box-types", viewsets.BoxTypeViewSet)
ROUTER.register(r"products", viewsets.ProductViewSet)
ROUTER.register(r"subscriptions", viewsets.SubscriptionViewSet)
ROUTER.register(r"users", viewsets.UserViewSet)
BOX_ITEMS_ROUTER = routers.NestedSimpleRouter(ROUTER, r"boxes", lookup="box")
BOX_ITEMS_ROUTER.register(r"items", viewsets.BoxItemViewSet, basename="items")
urlpatterns = [
path("", include(ROUTER.urls)),
path("", include(BOX_ITEMS_ROUTER.urls)),
path("api-auth/", include("rest_framework.urls", namespace="rest_framework")),
]
from django.urls import path, include
from rest_framework_nested import routers
from .views import (SongViewSet,
SongCommentViewSet,
SongRequestManager,
SongRequestViewSet,
SongRequestCommentViewSet,
HistoryViewSst,
StatisticViewSet,)
song_router = routers.DefaultRouter()
song_router.register(r'songs', SongViewSet)
song_comment_router = routers.NestedDefaultRouter(song_router, r'songs', lookup='song')
song_comment_router.register(r'comments', SongCommentViewSet, basename='song-comments')
song_request_router = routers.DefaultRouter()
song_request_router.register(r'songs', SongRequestViewSet, basename='playlist-songs')
song_request_router.register(r'history', HistoryViewSst)
song_request_router.register(r'', SongRequestManager)
song_request_comment_router = routers.NestedDefaultRouter(song_request_router, r'songs', lookup='playlist_song')
song_request_comment_router.register(r'comments', SongRequestCommentViewSet, basename='playlist-song-comments')
statistic_router = routers.DefaultRouter()
statistic_router.register(r'', StatisticViewSet, basename='stats')
def generate_urls(*model_sets):
router = nested_routers.DefaultRouter()
nested_router_instances = []
model_viewsets = {}
for models in model_sets:
for model_name in dir(models):
model_class = getattr(models, model_name)
if isinstance(model_class, ModelBase) and "Mixin" not in model_name:
class Serializer(serializers.HyperlinkedModelSerializer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for field in self.Meta.model._meta.local_fields:
if isinstance(field, JSONModelField):
self.fields[field.name] = JSONSerializerField()
elif field.choices:
self.fields[field.name] = ChoicesSerializerField()
for field in self.Meta.model._meta.get_fields():
if field not in self.Meta.model._meta.local_fields:
field_kwargs = {
"view_name": prep(
self.Meta.model._meta.verbose_name,
field.related_query_name().replace("_", "-") if field.related_query_name else field.related_model._meta.verbose_name_plural,
"list",
),
"lookup_url_kwarg": field.remote_field.name.replace("_rel_+", "") + "_pk", # TODO: This feels hacky. What's the proper approach?
}
self.fields[field.name] = serializers.HyperlinkedIdentityField(**field_kwargs)
class Meta:
model = model_class
fields = ["url"] + [
field.name
for field in model_class._meta.local_fields
]
class Filter(django_filters.FilterSet):
class Meta:
model = model_class
fields = {
field.name: get_field_lookups(field)
for field in model_class._meta.local_fields
if not isinstance(field, fields.related.RelatedField) and not isinstance(field, fields.files.FileField)
}
# ViewSets define the view behavior.
class ViewSet(viewsets.ModelViewSet):
queryset = model_class.objects.all()
serializer_class = Serializer
filter_backends = (filters.SearchFilter, filters.DjangoFilterBackend)
filter_class = Filter
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.search_fields = [
field.name
for field in self.queryset.model._meta.local_fields
if isinstance(field, fields.CharField)
]
def filter_queryset(self, *args, **kwargs):
queryset = super().filter_queryset(*args, **kwargs)
queryset = queryset.filter(**{
k.replace("_pk", ""): v # TODO: This feels hacky. What's the proper approach?
for k, v in self.kwargs.items()
})
return queryset
model_viewsets[model_name] = ViewSet
router.register(str(slugify(model_class._meta.verbose_name_plural)), ViewSet)
for models in model_sets:
for model_name in dir(models):
model_class = getattr(models, model_name)
if isinstance(model_class, ModelBase) and "Mixin" not in model_name:
for field in model_class._meta.get_fields():
if field not in model_class._meta.local_fields:
nested_router_kwargs = {
"parent_router": router,
"parent_prefix": prep(model_class._meta.verbose_name_plural),
"lookup": prep(field.remote_field.name),
}
prefix = prep(field.related_query_name() if field.related_query_name else field.related_model._meta.verbose_name_plural).replace("_", "-")
register_kwargs = {
"prefix": prefix,
"viewset": model_viewsets[field.related_model._meta.object_name],
"base_name": prep(model_class._meta.verbose_name, prefix),
}
nested_router = nested_routers.NestedSimpleRouter(**nested_router_kwargs)
nested_router.register(**register_kwargs)
nested_router_instances.append(nested_router)
return [
url(r"^", include(router.urls)),
*[
url(r"^", include(nested_router.urls))
for nested_router in nested_router_instances
]
]
from rest_framework_nested import routers
from printerIO import views as printerIOViews
from queues import views as queueViews
from models.views import *
from printers.views import PrinterViewSet
router = routers.DefaultRouter(trailing_slash="")
router.register("models", PrintingModelViewSet)
router.register("printers", PrinterViewSet)
router.register("results", printerIOViews.QualityViewSet)
router.register("filaments", printerIOViews.FilamentViewSet)
router.register("categories", printerIOViews.CategoryViewSet)
router.register("tasks", printerIOViews.TaskViewSet)
router.register("problems", printerIOViews.ProblemViewSet)
queue_router = routers.NestedDefaultRouter(router, r"printers", lookup="printers")
queue_router.register("queue", queueViews.QueueViewset)
from django.contrib import admin
from rest_framework_nested import routers
from rest_framework.authtoken.views import obtain_auth_token
import views
from api.views.core import UserViewSet, SwitchDocumentViewSet, SwitchDocumentTypeViewSet, NotificationViewSet, \
SwitchArtifactViewSet, SwitchRepositoryViewSet, SwitchDataTypeViewSet, SwitchDataTypePropertyViewSet
from api.views.application import ApplicationViewSet, ApplicationGraphView
from api.views.instance import ApplicationInstanceViewSet, ApplicationInstanceGraphView
from api.views.component import ComponentViewSet, ComponentTypeViewSet, ComponentGraphView, ComponentClassViewSet, \
ComponentTypePropertyViewSet
from api.views.graph import GraphViewSet, InstanceViewSet, PortViewSet, ServiceLinkViewSet, DependencyLinkViewSet
from api.views.knowledgebase import providers_list, providers_detail, ProviderViewSet
from rest_framework_swagger.views import get_swagger_view
router = routers.DefaultRouter(trailing_slash=False)
router.register("users", UserViewSet, base_name="user")
router.register("switchapps", ApplicationViewSet, base_name="switchapps")
router.register("switchappinstances",
ApplicationInstanceViewSet,
base_name="switchappinstances")
router.register("switchcomponents",
ComponentViewSet,
base_name="switchcomponents")
router.register("switchcomponenttypes",
ComponentTypeViewSet,
base_name="switchcomponenttypes")
router.register("switchcomponenttypeproperties",
ComponentTypePropertyViewSet,
base_name="switchcomponenttypeproperties")
router.register("switchdatatypes",
from django.urls import path, include
from rest_framework_nested import routers
from . import viewsets
user_router = routers.DefaultRouter()
user_router.register('user-profile', viewsets.UserViewSet)
profile_router = routers.NestedSimpleRouter(user_router, 'user-profile', lookup='user')
profile_router.register('profile', viewsets.UserProfileViewSet)
follower_router = routers.NestedSimpleRouter(
user_router, 'user-profile', lookup='followee')
follower_router.register(
'follower', viewsets.FollowerViewSet, base_name='follower')
following_router = routers.NestedSimpleRouter(
user_router, 'user-profile', lookup='follower')
following_router.register(
'following', viewsets.FollowingViewSet, base_name='followee')
search_router = routers.DefaultRouter()
search_router.register('search', viewsets.SearchViewSet, base_name="search")
urlpatterns = [
path('', include(user_router.urls)),
path('', include(profile_router.urls)),
path('', include(follower_router.urls)),
path('', include(following_router.urls)),
path('', include(search_router.urls)),
]
from rest_framework_nested import routers
from . import views
embedding_router = routers.DefaultRouter()
embedding_router.register('embeddings',
views.EmbeddingViewSet,
basename='embedding')
from django.urls import path, include
from rest_framework_nested import routers
from .views import PollViewSet, QuestionViewSet, UserPollAnswerViewSet
api_v1 = routers.DefaultRouter()
api_v1.register('poll', PollViewSet)
api_v1.register('answer', UserPollAnswerViewSet, basename='answer')
question_router = routers.NestedDefaultRouter(api_v1, 'poll', lookup='poll')
question_router.register('question', QuestionViewSet, basename='poll-question')
urlpatterns = [
path('v1/', include(api_v1.urls)),
path('v1/', include(question_router.urls)),
path('auth/', include('oauth2_provider.urls',
namespace='oauth2_provider')),
]
from django.conf.urls import include, url
from rest_framework_nested import routers
from insights.views import HitProductViewSet, StillInFittingRoom_ViewSet
from .views import *
app_name = 'fitalgorithms'
predict_router = routers.DefaultRouter()
'''
here predict process is profile ignostic, we just need height and weight
with its coressponding metrics cm/inch , kg/lb respectively
'''
predict_router.register(r'predict', PredictViewSet, base_name='predict')
fit_product_router = routers.DefaultRouter()
'''
here we have different api for authenticated and non authenticated profiles
we need profile data such as height,weight,bust,hips,etc... and the product_id
'''
fit_product_router.register(r'fit_product',
FitNonAuthenticatedViewSet,
base_name='fit_product')
hit_product_router = routers.DefaultRouter()
# its solely used for insightsm we record time spent on fitting room
hit_product_router.register(r'hit_product',
HitProductViewSet,
base_name='hit_product')
stillInFittingRoom_router = routers.DefaultRouter()
'''
UserViewSet,
)
SchemaView = get_schema_view(
openapi.Info(
title="Squarelet API",
default_version="v1",
description="API for Muckrock Accounts and PressPass",
terms_of_service="https://www.muckrock.com/tos/",
contact=openapi.Contact(email="*****@*****.**"),
),
public=True,
permission_classes=(permissions.AllowAny,),
)
router = routers.DefaultRouter()
router.register("users", UserViewSet)
router.register("url_auth_tokens", UrlAuthTokenViewSet, base_name="url_auth_token")
router.register("organizations", OrganizationViewSet)
router.register("charges", ChargeViewSet)
presspass_router = routers.DefaultRouter()
presspass_router.register("clients", ClientViewSet)
presspass_router.register("users", PressPassUserViewSet)
presspass_router.register("organizations", PressPassOrganizationViewSet)
presspass_router.register("invitations", PressPassInvitationViewSet)
presspass_router.register("plans", PressPassPlanViewSet)
presspass_router.register("entitlements", PressPassEntitlementViewSet)
presspass_router.register("emails", PressPassEmailAddressViewSet)
organization_router = routers.NestedDefaultRouter(
qs = FreelanceProfile.objects.filter(contributor__in=contributor_ids)
if "staff" in self.request.QUERY_PARAMS:
staff = self.request.QUERY_PARAMS.get("staff")
if staff == "freelance":
qs = qs.filter(is_freelance=True)
elif staff == "staff":
qs = qs.filter(is_freelance=False)
return qs
api_v1_router = routers.DefaultRouter()
api_v1_router.register(r"line-items", LineItemViewSet, base_name="line-items")
# Nested routes for roles
api_v1_role_router = nested_routers.DefaultRouter()
api_v1_role_router.register(r"role",
ContributorRoleViewSet,
base_name="contributorrole")
nested_role_router = nested_routers.NestedSimpleRouter(api_v1_role_router,
"role",
lookup="role")
nested_role_router.register("flat_rates",
FlatRateViewSet,
base_name="flat-rate")
nested_role_router.register("hourly_rates",
HourlyRateViewSet,
base_name="hourly-rate")
nested_role_router.register("feature_type_rates",
FeatureTypeRateViewSet,
base_name="feature-type-rate")
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.urls import path, include
from rest_framework_nested import routers
from rest_framework_simplejwt import views as jwt_views
from .views import PersonViewSet, PetViewSet
app_name = 'backend_challenge'
person_router = routers.DefaultRouter(trailing_slash=False)
person_router.register(r'person', PersonViewSet)
pet_router = routers.DefaultRouter(trailing_slash=False)
pet_router.register(r'pet', PetViewSet)
urlpatterns = [
path('', include(person_router.urls)),
path('', include(pet_router.urls)),
path('auth', jwt_views.TokenObtainPairView.as_view(), name='token_obtain_pair'),
]
from django.conf.urls import url
from django.urls import include, path
from rest_framework.schemas import get_schema_view
from rest_framework_nested import routers
from .views import WalletsViewSet, TransactionsViewSet, AllTransactionsViewSet
from django.views.generic import TemplateView
wallets_router = routers.DefaultRouter()
wallets_router.register(r'wallets', WalletsViewSet, basename='wallets')
wallets_router.register(r'transactions', AllTransactionsViewSet)
transaction_router = routers.NestedDefaultRouter(wallets_router,
r'wallets',
lookup='wallets')
transaction_router.register(r'transactions',
TransactionsViewSet,
basename='transactions')
urlpatterns = [
url(r'^api/', include(wallets_router.urls)),
url(r'^api/', include(transaction_router.urls)),
path('openapi',
get_schema_view(title="Wallet App", ),
name='openapi-schema'),
path('api-docs/',
TemplateView.as_view(template_name='swagger-ui.html',
extra_context={'schema_url': 'openapi-schema'}),
name='swagger-ui'),
]
from app.api.presets import PresetViewSet
from app.plugins.views import api_view_handler
from .projects import ProjectViewSet
from .tasks import TaskViewSet, TaskDownloads, TaskAssets, TaskAssetsImport
from .imageuploads import Thumbnail, ImageDownload
from .processingnodes import ProcessingNodeViewSet, ProcessingNodeOptionsView
from .admin import AdminUserViewSet, AdminGroupViewSet
from rest_framework_nested import routers
from rest_framework_jwt.views import obtain_jwt_token
from .tiler import TileJson, Bounds, Metadata, Tiles, Export
from .potree import Scene, CameraView
from .workers import CheckTask, GetTaskResult
from .users import UsersList
from webodm import settings
router = routers.DefaultRouter()
router.register(r'projects', ProjectViewSet)
router.register(r'processingnodes', ProcessingNodeViewSet)
router.register(r'presets', PresetViewSet, base_name='presets')
tasks_router = routers.NestedSimpleRouter(router,
r'projects',
lookup='project')
tasks_router.register(r'tasks', TaskViewSet, base_name='projects-tasks')
admin_router = routers.DefaultRouter()
admin_router.register(r'admin/users',
AdminUserViewSet,
base_name='admin-users')
admin_router.register(r'admin/groups',
AdminGroupViewSet,
from django.urls import path
from . import views
from django.conf.urls import url, include
from rest_framework_nested import routers
resposta_router = routers.DefaultRouter()
resposta_router.register(r'resposta', views.RespostaViewSet)
# ENDPOINTs partindo de 'resposta'
resposta_nested_router = routers.NestedSimpleRouter(resposta_router,
r'resposta',
lookup='resposta')
resposta_nested_router.register(r'voto',
views.VotoViewSet,
base_name='resposta-voto')
enquete_router = routers.DefaultRouter()
enquete_router.register(r'enquete', views.EnqueteViewSet)
# ENDPOINTs partindo de 'enquete'
enquete_nested_router = routers.NestedSimpleRouter(enquete_router,
r'enquete',
lookup='enquete')
enquete_nested_router.register(r'respostas',
views.RespostasViewSet,
base_name='enquete-respostas')
app_name = 'enquetes'
urlpatterns = [
#!/usr/bin/env python
# coding=utf-8
from django.urls import re_path
from rest_framework.urlpatterns import include
from rest_framework_nested import routers
from users import views
__all__ = [
'users_urlpatterns',
'auth_urlpatterns',
]
app_name = 'users'
auth_router = routers.DefaultRouter()
auth_router.register(r'', views.users.AuthViewSet, base_name='api-auth')
users_router = routers.DefaultRouter()
users_router.register(r'', views.users.UsersViewSet, base_name='api-users')
users_urlpatterns = [
re_path(r'^', include(users_router.urls)),
]
auth_urlpatterns = [
re_path(r'^', include(auth_router.urls)),
]
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.urls import path, include
from rest_framework_nested import routers
from .views import CallStartRecordView, CallEndRecordView, PhoneBillView
app_name = 'work_at_olist'
call_start_record_router = routers.DefaultRouter(trailing_slash=False)
call_start_record_router.register(r'call-start-record', CallStartRecordView)
call_end_record_router = routers.DefaultRouter(trailing_slash=False)
call_end_record_router.register(r'call-end-record', CallEndRecordView)
phone_bill_router = routers.DefaultRouter(trailing_slash=False)
phone_bill_router.register(r'phone-bill', PhoneBillView)
urlpatterns = [
path('', include(call_start_record_router.urls)),
path('', include(call_end_record_router.urls)),
path('', include(phone_bill_router.urls))
]
from rest_framework_nested import routers
from . import views
snowball_router = routers.DefaultRouter()
snowball_router.register('apply_analyzers', views.ApplyEsAnalyzerOnIndices, basename='apply_analyzers')
from django.conf.urls import url, include
from django.urls import path
# from rest_framework import routers
from rest_framework_nested import routers as nested_routers
from . import views
router = nested_routers.DefaultRouter()
router.register(r'clients', views.ClientsViewSet, base_name="clients")
router.register(r'repositories', views.RepositoriesViewSet, base_name="repositories")
router.register(r'environments', views.EnvironmentsViewSet, base_name="environments")
router.register(r'tags', views.TagsViewSet, base_name="tags")
urlpatterns = [
url(r'^', include((router.urls, 'version_control'), namespace='version_control'))
]
from .views import TopicViewSet
from rest_framework_nested import routers
from django.conf.urls import url, include
topic_router = routers.DefaultRouter()
topic_router.register(r'topics', TopicViewSet, basename='topics')
## generates:
# /topics/
# /topics/{urlname}/
urlpatterns = [url(r'', include(topic_router.urls))]
from django.urls import path
from spells import views
from rest_framework_nested import routers
router = routers.DefaultRouter()
router.register(r'spells', views.SpellView, base_name='spells')
router.register(r'spellbooks', views.SpellbookView, base_name='spellbooks')
spellbooks_router = routers.NestedDefaultRouter(router,
r'spellbooks',
lookup='spellbook')
spellbooks_router.register(r'spells',
views.NestedSpellView,
base_name='spellbook-spells')
urls = [path('spellbook/<int:id>/pdf', views.SpellbookSpellPdf.as_view())]
urlpatterns = router.urls + spellbooks_router.urls + urls
from django.conf.urls import include, url
from team_maker.api import views
from rest_framework_jwt.views import obtain_jwt_token
from rest_framework import renderers
from rest_framework_nested import routers
router = routers.DefaultRouter(
trailing_slash=False,
root_renderers=(renderers.JSONRenderer, renderers.BrowsableAPIRenderer, )
)
router.register(r'users', views.UserView)
router.register(r'players', views.PlayersView)
players_router = routers.NestedSimpleRouter(router, r'players', lookup='player')
players_router.register(r'teams', views.PlayerTeamsView, basename='player-teams')
router.register(r'team-players', views.TeamPlayerView)
router.register(r'teams', views.TeamView)
teams_router = routers.NestedSimpleRouter(router, r'teams', lookup='team')
teams_router.register(r'current-team-player', views.CurrentTeamPlayerView, basename='team-player')
teams_router.register(r'games', views.TeamGamesView, basename='team-games')
teams_router.register(r'rules', views.TeamRulesView, basename='team-rules')
games_router = routers.NestedSimpleRouter(teams_router, r'games', lookup='game')
games_router.register(r'available-players', views.AvailablePlayersView, basename='available-players')
games_router.register(r'group-players', views.TeamGroupPlayerView, basename='team-group-players')
games_router.register(r'goals', views.GameGoalsView, basename='goals')
router.register(r'teams/token', views.TeamByTokenView)
urlpatterns = [
url(r'^', include(router.urls)),
