コード例 #1
0
        return generate_image_url(obj, 'width-{}'.format(width))

    def get_url_400(self, obj):
        return self._get_url_x(obj, 400)

    def get_url_640(self, obj):
        return self._get_url_x(obj, 640)

    def get_url_800(self, obj):
        return self._get_url_x(obj, 800)

    def get_url_1280(self, obj):
        return self._get_url_x(obj, 1280)

    url_400 = serializers.SerializerMethodField()
    url_640 = serializers.SerializerMethodField()
    url_800 = serializers.SerializerMethodField()
    url_1280 = serializers.SerializerMethodField()


class ImagesAPIEndpoint(WagtailImagesAPIEndpoint):
    base_serializer_class = ImageSerializer
    meta_fields = WagtailImagesAPIEndpoint.meta_fields + [
        'url_400', 'url_640', 'url_800', 'url_1280'
    ]


api_router.register_endpoint('pages', PagesAPIEndpoint)
api_router.register_endpoint('images', ImagesAPIEndpoint)
api_router.register_endpoint('documents', DocumentsAPIEndpoint)
コード例 #2
0
    known_query_parameters = PagesAPIViewSet.known_query_parameters.union(
        ["content_type", "token"]
    )

    def listing_view(self, request):
        page = self.get_object()
        serializer = self.get_serializer(page)
        return Response(serializer.data)

    def detail_view(self, request, pk):
        page = self.get_object()
        serializer = self.get_serializer(page)
        return Response(serializer.data)

    def get_object(self):
        app_label, model = self.request.GET["content_type"].split(".")
        content_type = ContentType.objects.get(app_label=app_label, model=model)

        page_preview = PagePreview.objects.get(
            content_type=content_type, token=self.request.GET["token"]
        )
        page = page_preview.as_page()
        if not page.pk:
            # fake primary key to stop API URL routing from complaining
            page.pk = 0

        return page


api_router.register_endpoint("page_preview", PagePreviewAPIEndpoint)
コード例 #3
0
        """
        obj = super().get_object()

        revision_id = self.request.query_params.get('revision-id')
        if revision_id:
            revision = get_object_or_404(obj.revisions, id=revision_id)
        else:
            revision = obj.revisions.order_by('-created_at').first()

        # in case of no revisions, return the object (edge case)
        if not revision:
            return obj

        base = revision.as_page_object()
        return base.specific

    @classmethod
    def get_urlpatterns(cls):
        """
        Only get page by id allowed.
        """
        return [
            url(r'^(?P<pk>\d+)/$',
                cls.as_view({'get': 'detail_view'}),
                name='detail'),
        ]


api_router.register_endpoint('pages', PagesAPIEndpoint)
api_router.register_endpoint('preview-pages', PreviewPagesAPIEndpoint)
コード例 #4
0
ファイル: api.py プロジェクト: pseudobabble/cms-boilerplate
#!/usr/bin/env python

from wagtail.api.v2.views import PagesAPIViewSet
from wagtail.api.v2.router import WagtailAPIRouter
# from wagtail.exhibitions.api.v2.views import ImagesAPIViewSet
from wagtail.documents.api.v2.views import DocumentsAPIViewSet

# Create the router. "wagtailapi" is the URL namespace
from home.views import MediaAPIViewSet, ImagesAPIViewSet

api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, exhibitions). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIViewSet)
api_router.register_endpoint('documents', DocumentsAPIViewSet)
api_router.register_endpoint('exhibitions', ImagesAPIViewSet)
api_router.register_endpoint('media', MediaAPIViewSet)
api_router.register_endpoint('images', ImagesAPIViewSet)
コード例 #5
0
ファイル: urls.py プロジェクト: tomdyson/directory-cms
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.core import urls as wagtail_urls
from wagtail.documents import urls as wagtaildocs_urls

from django.conf.urls import include, url
from django.conf.urls.static import static
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import RedirectView

import core.views
import export_readiness.views

api_router = WagtailAPIRouter('api')
api_router.register_endpoint('pages', core.views.PagesOptionalDraftAPIEndpoint)

api_urls = [
    url(r'^', api_router.urls),
    url(r'^pages/lookup-by-slug/(?P<slug>[\w-]+)/',
        api_router.wrap_view(
            core.views.PageLookupBySlugAPIEndpoint.as_view(
                {'get': 'detail_view'})),
        name='lookup-by-slug'),
    url(r'^pages/lookup-by-full-path/$',
        api_router.wrap_view(
            core.views.PageLookupByFullPathAPIEndpoint.as_view(
                {'get': 'detail_view'})),
        name='lookup-by-full-path'),
    url(r'^pages/lookup-by-tag/(?P<slug>[\w-]+)/$',
        api_router.wrap_view(
コード例 #6
0
from wagtail.api.v2.views import PagesAPIViewSet
from wagtail.api.v2.router import WagtailAPIRouter

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIViewSet)
コード例 #7
0
        self.listing_default_fields += [
            "article_image",
            "article_image_thumbnail",
            "article_teaser",
            "article_date",
            "title",
            "slug",
            "first_published_at",
            "live"
        ]

        self.nested_default_fields += [
            "title",
        ]

    # https://github.com/wagtail/wagtail/blob/971bdc0799a800a373e7326d9e564813934c09c6/wagtail/api/v2/views.py
    def get_base_queryset(self):
        queryset = ContentPage.objects.all().public().live().order_by('-article_date')
        return queryset


class CustomImagesAPIViewset(ImagesAPIViewSet):
    def __init__(self):
        ImagesAPIViewSet.__init__(self)
        self.meta_fields += ["caption"]


api_router.register_endpoint("pages", ContentPagesAPIViewSet)
api_router.register_endpoint("images", CustomImagesAPIViewset)
コード例 #8
0
from wagtail.api.v2.router import WagtailAPIRouter

from hra.glossary.endpoints import GlossaryTermsAPIEndpoint

api_router = WagtailAPIRouter('wagtailapi')

api_router.register_endpoint('glossary_terms', GlossaryTermsAPIEndpoint)
コード例 #9
0
from django.urls import path

from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.core import hooks

from .views import PagesAdminAPIViewSet


admin_api = WagtailAPIRouter('wagtailadmin_api')
admin_api.register_endpoint('pages', PagesAdminAPIViewSet)

for fn in hooks.get_hooks('construct_admin_api'):
    fn(admin_api)

urlpatterns = [
    path('main/', admin_api.urls),
]
コード例 #10
0
from wagtail.api.v2.endpoints import PagesAPIEndpoint
from wagtail.api.v2.router import WagtailAPIRouter

from home.models import PersonAPIEndpoint

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIEndpoint)
api_router.register_endpoint('people', PersonAPIEndpoint)
コード例 #11
0
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail_spa_integration.views import SPAExtendedPagesAPIEndpoint, RedirectViewSet
from wagtail_spa_integration.headless_preview_api import PagePreviewAPIViewSet

api_router = WagtailAPIRouter('wagtailapi')
api_router.register_endpoint('pages', SPAExtendedPagesAPIEndpoint)
api_router.register_endpoint('page_preview', PagePreviewAPIViewSet)
api_router.register_endpoint('redirects', RedirectViewSet)
コード例 #12
0
from wagtail.images.api.v2.views import ImagesAPIViewSet
from wagtail.documents.api.v2.views import DocumentsAPIViewSet

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

from activity.endpoints import ActivitiesAPIEndpoint
from assets.endpoints import AssetsAPIEndpoint
from modules.endpoints import ModulesAPIEndpoint
from taxonomy.endpoints import StandardAPIEndpoint, StandardsBodyAPIEndpoint, ProgramsAPIEndpoint, AudienceAPIEndpoint, TagAPIEndpoint, TopicAPIEndpoint, AssetTypeAPIEndpoint, ActivityTypeAPIEndpoint, TimeEstimateAPIEndpoint, LearningSpaceAPIEndpoint

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIViewSet)
api_router.register_endpoint('images', ImagesAPIViewSet)
api_router.register_endpoint('documents', DocumentsAPIViewSet)

# Custom API Endpoints
api_router.register_endpoint('activities', ActivitiesAPIEndpoint)
api_router.register_endpoint('assets', AssetsAPIEndpoint)
api_router.register_endpoint('modules', ModulesAPIEndpoint)
api_router.register_endpoint('standards', StandardAPIEndpoint)
api_router.register_endpoint('standards-body', StandardsBodyAPIEndpoint)
api_router.register_endpoint('programs', ProgramsAPIEndpoint)
api_router.register_endpoint('audiences', AudienceAPIEndpoint)
api_router.register_endpoint('tags', TagAPIEndpoint)
api_router.register_endpoint('topics', TopicAPIEndpoint)
api_router.register_endpoint('asset-type', AssetTypeAPIEndpoint)
api_router.register_endpoint('activity-type', ActivityTypeAPIEndpoint)
コード例 #13
0
from wagtail.api.v2.router import WagtailAPIRouter

from .views import CustomPagesAPIEndpoint, CustomImagesAPIEndpoint, CustomDocumentsAPIEndpoint, PagePreviewAPIEndpoint

# Init the Wagtail Router
api_router = WagtailAPIRouter('wagtailapi')

api_router.register_endpoint('page_preview', PagePreviewAPIEndpoint)
api_router.register_endpoint('pages', CustomPagesAPIEndpoint)
api_router.register_endpoint('images', CustomImagesAPIEndpoint)
api_router.register_endpoint('documents', CustomDocumentsAPIEndpoint)
コード例 #14
0
ファイル: urls.py プロジェクト: jams2/wagtail
from django.urls import path

from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.core import hooks

from .views import PagesAdminAPIViewSet

admin_api = WagtailAPIRouter("wagtailadmin_api")
admin_api.register_endpoint("pages", PagesAdminAPIViewSet)

for fn in hooks.get_hooks("construct_admin_api"):
    fn(admin_api)

urlpatterns = [
    path("main/", admin_api.urls),
]
コード例 #15
0
from __future__ import absolute_import, unicode_literals

from django.conf.urls import url

from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.wagtailcore import hooks

from .endpoints import PagesAdminAPIEndpoint

admin_api = WagtailAPIRouter('wagtailadmin_api_v1')
admin_api.register_endpoint('pages', PagesAdminAPIEndpoint)

for fn in hooks.get_hooks('construct_admin_api'):
    fn(admin_api)

urlpatterns = [
    url(r'^v2beta/', admin_api.urls),
]
コード例 #16
0
ファイル: api.py プロジェクト: praekeltfoundation/contentrepo
    @method_decorator(cache_page(60 * 60 * 2))
    def list(self, request, *args, **kwargs):
        super(ContentPagesViewSet, self).list(self, request, *args, **kwargs)

    def get_queryset(self):
        queryset = super(ContentPagesViewSet, self).get_queryset()
        tag = self.request.query_params.get("tag")
        if tag is not None:
            ids = []
            for t in ContentPageTag.objects.all():
                if t.tag.name == tag:
                    ids.append(t.content_object_id)
            queryset = queryset.filter(id__in=ids)
        return queryset


class ContentPageIndexViewSet(PagesAPIViewSet):
    pagination_class = PageNumberPagination

    def get_queryset(self):
        return ContentPageIndex.objects.live()


api_router = WagtailAPIRouter("wagtailapi")

api_router.register_endpoint("pages", ContentPagesViewSet)
api_router.register_endpoint("indexes", ContentPageIndexViewSet)
api_router.register_endpoint("images", ImagesAPIViewSet)
api_router.register_endpoint("documents", DocumentsAPIViewSet)
コード例 #17
0
ファイル: api.py プロジェクト: knzm/headless_demo
        return self.get_paginated_response(serializer.data)

    def detail_view(self, request, pk):
        if not self.include_draft():
            return super(DraftPagesAPIViewSet, self).detail_view(request, pk)
        instance = self.get_object().get_latest_revision_as_page()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)


class DraftBlogPagesAPIViewSet(DraftPagesAPIViewSet):
    listing_default_fields = ['id', 'type', 'detail_url', 'body']

    def get_queryset(self):
        from backend_site.blog.models import BlogPage
        return BlogPage.objects.filter(
            id__in=self.get_base_queryset().values_list('id', flat=True))


# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', DraftPagesAPIViewSet)
api_router.register_endpoint('images', ImagesAPIViewSet)
api_router.register_endpoint('documents', DocumentsAPIViewSet)
api_router.register_endpoint('blogs', DraftBlogPagesAPIViewSet)
コード例 #18
0
from wagtail.images.api.v2.views import ImagesAPIViewSet
from wagtail.documents.api.v2.views import DocumentsAPIViewSet

from django.contrib.contenttypes.models import ContentType

from wagtail_headless_preview.models import PagePreview
from rest_framework.response import Response

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIViewSet)
api_router.register_endpoint('images', ImagesAPIViewSet)
api_router.register_endpoint('documents', DocumentsAPIViewSet)


class PagePreviewAPIViewSet(PagesAPIViewSet):
    known_query_parameters = PagesAPIViewSet.known_query_parameters.union(['content_type', 'token'])

    def listing_view(self, request):
        page = self.get_object()
        serializer = self.get_serializer(page)
        return Response(serializer.data)

    def detail_view(self, request, pk):
        page = self.get_object()
        serializer = self.get_serializer(page)
コード例 #19
0
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.wagtailcore.models import Page

from reactail.serializers import ReactPageSerializer


class ReactPagesAPIEndpoint(PagesAPIEndpoint):
    """Expose Pages as API endpoint."""
    base_serializer_class = ReactPageSerializer
    model = Page
    meta_fields = PagesAPIEndpoint.meta_fields + [
        'excerpt',
        'image',
        'published_at',
        'show_in_menus',
        'url_path',
    ]
    listing_default_fields = PagesAPIEndpoint.listing_default_fields + [
        'excerpt',
        'image',
        'parent',
        'published_at',
        'show_in_menus',
        'url_path',
    ]
    detail_only_fields = []  # hide parent field


api_router = WagtailAPIRouter('wagtailapi')
api_router.register_endpoint(settings.API_PAGES_PATH, ReactPagesAPIEndpoint)
コード例 #20
0
        if self.action == 'listing_view':
            show_details = False
            model = getattr(self, 'queryset', self.get_queryset()).model
        else:
            # Allow "detail_only" (eg parent) fields on detail view
            show_details = True
            model = type(self.get_object())

        # Fields
        try:
            fields_config = parse_fields_parameter(
                self.request.GET.get('fields', []))
        except ValueError as e:
            raise BadRequestError("fields error: %s" % str(e))

        return self._get_serializer_class(self.request.wagtailapi_router,
                                          model,
                                          fields_config,
                                          show_details=show_details)


admin_api = WagtailAPIRouter('gem_wagtailadmin_api_v1')
admin_api.register_endpoint('pages', GemPagesAdminApi)

for fn in hooks.get_hooks('construct_admin_api'):
    fn(admin_api)

urlpatterns = [
    url(r'^v2beta/', admin_api.urls),
]
コード例 #21
0
from wagtail.api.v2.endpoints import PagesAPIEndpoint
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.core.models import Page
from wagtail.documents.api.v2.endpoints import DocumentsAPIEndpoint
from wagtail.images.api.v2.endpoints import ImagesAPIEndpoint


class AltPagesEndpoint(PagesAPIEndpoint):
    def get_object(self):
        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
        page_id = self.kwargs[lookup_url_kwarg]
        base = Page.objects.get(id=page_id)
        return base.specific


# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the four endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests

# This is for internal use only
api_router.register_endpoint('release_pages', AltPagesEndpoint)

api_router.register_endpoint('images', ImagesAPIEndpoint)
api_router.register_endpoint('documents', DocumentsAPIEndpoint)
コード例 #22
0
# api.py

from wagtail.api.v2.endpoints import PagesAPIEndpoint
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.images.api.v2.endpoints import ImagesAPIEndpoint
from wagtail.documents.api.v2.endpoints import DocumentsAPIEndpoint
from home.app_view import AppPagesAPIEndpoint, TagsAPIEndpoint

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIEndpoint)
api_router.register_endpoint('images', ImagesAPIEndpoint)
api_router.register_endpoint('documents', DocumentsAPIEndpoint)
api_router.register_endpoint('app', AppPagesAPIEndpoint)
api_router.register_endpoint('tags', TagsAPIEndpoint)
コード例 #23
0
ファイル: api.py プロジェクト: dentemm/healthhouse
    meta_fields = BaseAPIViewSet.meta_fields + ['title']

    known_query_parameters = BaseAPIViewSet.known_query_parameters.union([
        'current_month',
    ])

    def get_queryset(self):

        current_month = self.request.query_params.get('current_month', None)

        if (current_month):
            try:
                reference = datetime.strptime(current_month, '%Y-%m-%d')

            except:
                reference = datetime.now()

        else:
            reference = datetime.now()

        reference = make_aware(reference)

        start = reference - relativedelta(months=3)
        end = reference + relativedelta(months=3)

        return self.model.objects.filter(date__gte=start, date__lte=end)


api_router.register_endpoint('images', CustomImagesAPIEndpoint)
api_router.register_endpoint('events', CalendarItemAPIEndpoint)
コード例 #24
0
from django.urls import path


class MyNavMenuViewSet(NavMenuViewSet):
    """
    Our custom Pages API endpoint that allows finding pages by pk or slug
    """
    @classmethod
    def get_urlpatterns(cls):
        """
        This returns a list of URL patterns for the endpoint
        """
        return [
            path('', cls.as_view({'get': 'list'}), name='listing'),
            path('<int:pk>/', cls.as_view({'get': 'retrieve'}), name='detail'),
        ]


# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', PagesAPIViewSet)
api_router.register_endpoint('images', ImagesAPIViewSet)
api_router.register_endpoint('documents', DocumentsAPIViewSet)
api_router.register_endpoint('users', UsersAPIViewSet)
api_router.register_endpoint('menus', MyNavMenuViewSet)
コード例 #25
0
ファイル: api.py プロジェクト: plantersclock/mysite
from wagtail.api.v2.views import PagesAPIViewSet
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.images.api.v2.views import ImagesAPIViewSet
from wagtail.documents.api.v2.views import DocumentsAPIViewSet

from rest_framework.routers import DefaultRouter

# from jobs.api import JobsViewSet

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter("wagtailapi")
# DRF router used for menu items
drf_router = DefaultRouter()

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint("pages", PagesAPIViewSet)
api_router.register_endpoint("images", ImagesAPIViewSet)
api_router.register_endpoint("documents", DocumentsAPIViewSet)

# Add DRF content here
# drf_router.register(r"jobs", JobsViewSet)
コード例 #26
0
ファイル: api.py プロジェクト: l-etabli/wagtail-debut
        }


class PageRelativeUrlListAPIViewSet(PagesAPIViewSet):
    """Return all pages and their relative url"""
    def get_serializer(self, qs, many=True):
        return PageRelativeUrlListSerializer(qs, many=many)

    @classmethod
    def get_urlpatterns(cls):
        return [
            path("", cls.as_view({"get": "listing_view"}), name="listing"),
        ]


api_router.register_endpoint("page_relative_urls",
                             PageRelativeUrlListAPIViewSet)


class PagePreviewAPIViewSet(BaseAPIViewSet):
    known_query_parameters = PagesAPIViewSet.known_query_parameters.union(
        ["content_type", "token"])

    def listing_view(self, request):
        page = self.get_object()
        return page.serve(request)

    def get_object(self):
        content_type = self.request.GET.get("content_type")
        if not content_type:
            raise ValidationError({"content_type": "Missing value"})
コード例 #27
0
            return redirect(
                reverse('wagtailapi:pages:listing') +
                f'?{self.lookup_field}={param}')

    @classmethod
    def get_urlpatterns(cls):
        """
        This returns a list of URL patterns for the endpoint
        """
        return [
            path('', cls.as_view({'get': 'listing_view'}), name='listing'),
            path('<int:pk>/',
                 cls.as_view({'get': 'detail_view'}),
                 name='detail'),
            path('<slug:slug>/',
                 cls.as_view({'get': 'detail_view'}),
                 name='detail'),
            path('find/', cls.as_view({'get': 'find_view'}), name='find'),
        ]


# Create the router. “wagtailapi” is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# Add the three endpoints using the "register_endpoint" method.
# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('pages', OpenstaxPagesAPIEndpoint)
api_router.register_endpoint('images', ImagesAPIViewSet)
api_router.register_endpoint('documents', DocumentsAPIViewSet)
コード例 #28
0
ファイル: api.py プロジェクト: kinaklub/next.filmfest.by
from wagtail.api.v2.endpoints import PagesAPIEndpoint
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.wagtailimages.api.v2.endpoints import ImagesAPIEndpoint


v2 = WagtailAPIRouter('wagtailapi_v2')
v2.register_endpoint('pages', PagesAPIEndpoint)
v2.register_endpoint('images', ImagesAPIEndpoint)
コード例 #29
0
ファイル: urls.py プロジェクト: morris-tech/wagtail
from wagtail.api.v2.endpoints import PagesAPIEndpoint
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.contrib.sitemaps import views as sitemaps_views
from wagtail.contrib.sitemaps import Sitemap
from wagtail.tests.testapp import urls as testapp_urls
from wagtail.admin import urls as wagtailadmin_urls
from wagtail.core import urls as wagtail_urls
from wagtail.documents import urls as wagtaildocs_urls
from wagtail.documents.api.v2.endpoints import DocumentsAPIEndpoint
from wagtail.images import urls as wagtailimages_urls
from wagtail.images.api.v2.endpoints import ImagesAPIEndpoint
from wagtail.images.tests import urls as wagtailimages_test_urls
from wagtail.search import urls as wagtailsearch_urls

api_router = WagtailAPIRouter('wagtailapi_v2')
api_router.register_endpoint('pages', PagesAPIEndpoint)
api_router.register_endpoint('images', ImagesAPIEndpoint)
api_router.register_endpoint('documents', DocumentsAPIEndpoint)


urlpatterns = [
    url(r'^admin/', include(wagtailadmin_urls)),
    url(r'^search/', include(wagtailsearch_urls)),
    url(r'^documents/', include(wagtaildocs_urls)),
    url(r'^testimages/', include(wagtailimages_test_urls)),
    url(r'^images/', include(wagtailimages_urls)),

    url(r'^api/v2beta/', api_router.urls),
    url(r'^sitemap\.xml$', sitemaps_views.sitemap),

    url(r'^sitemap-index\.xml$', sitemaps_views.index, {
コード例 #30
0
ファイル: api.py プロジェクト: the-gem-exchange/gemex-cms
from bot.api import BotCommandAPIEndpoint

from wagtail.api.v2.endpoints import BaseAPIEndpoint
from wagtail.api.v2.endpoints import PagesAPIEndpoint
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.images.api.v2.endpoints import ImagesAPIEndpoint
from wagtail.documents.api.v2.endpoints import DocumentsAPIEndpoint

# Create the router. "wagtailapi" is the URL namespace
api_router = WagtailAPIRouter('wagtailapi')

# The first parameter is the name of the endpoint (eg. pages, images). This
# is used in the URL of the endpoint
# The second parameter is the endpoint class that handles the requests
api_router.register_endpoint('commands', BotCommandAPIEndpoint)
コード例 #31
0
ファイル: api.py プロジェクト: codeshard/ofertas
# coding=utf-8
#!/usr/bin/env python

from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.api.v2.endpoints import PagesAPIEndpoint

api_router = WagtailAPIRouter('ofertasapi')

api_router.register_endpoint('pages', PagesAPIEndpoint)
コード例 #32
0
ファイル: urls.py プロジェクト: praekelt/molo
from wagtail.api.v2.router import WagtailAPIRouter
from wagtail.documents.api.v2.endpoints import DocumentsAPIEndpoint

from molo.core.api import admin_views
from molo.core.api.endpoints import (
    MoloImagesAPIEndpoint,
    MoloPagesEndpoint,
    LanguagesAPIEndpoint,
)

# Adding extended images endpoint to new router.
# For consistency, the "pages" and "documents"
# endpoints have also been added even though they were
# not modified.
api_router = WagtailAPIRouter("wagtailapi_v2")
api_router.register_endpoint("images", MoloImagesAPIEndpoint)
api_router.register_endpoint("pages", MoloPagesEndpoint)
api_router.register_endpoint("documents", DocumentsAPIEndpoint)
api_router.register_endpoint("languages", LanguagesAPIEndpoint)

urlpatterns = [
    url(
        r"^import-site/$",
        admin_views.SiteImportView.as_view(),
        name="site-import"
    ),
    url(
        r"^import-content/$",
        admin_views.MainImportView.as_view(),
        name="main-import"
    ),