get_media_url() - Code Metrics - Inspection of "Media manager, with Image edition in the basic Ric..." - batiste/django-page-cms - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#169)

by Batiste

created 2017-01-20 12:58 UTC

get_media_url() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	5
rs	9.4285
cc	1

# -*- coding: utf-8 -*-
"""Pages admin views"""
from pages import settings
from django.conf import settings as django_settings
from pages.models import Page, Content, Media
from pages.utils import get_placeholders
from pages.phttp import get_language_from_request

from django.shortcuts import get_object_or_404, render
from django.http import HttpResponse, Http404, HttpResponseRedirect
from django.contrib.admin.views.decorators import staff_member_required
from django.template import RequestContext
from django import template
from django.views.decorators.csrf import csrf_exempt
from django.core.urlresolvers import reverse
from django import forms
from pages.managers import fake_page


@staff_member_required
@csrf_exempt
def change_status(request, page_id):
    """
    Switch the status of a page.
    """
    perm = request.user.has_perm('pages.change_page')
    if perm and request.method == 'POST':
        page = Page.objects.get(pk=page_id)
        page.status = int(request.POST['status'])
        page.invalidate()
        page.save()
        return HttpResponse(str(page.status))
    raise Http404


@staff_member_required
def list_pages_ajax(request, invalid_move=False):
    """Render pages table for ajax function."""
    language = get_language_from_request(request)
    pages = Page.objects.root()
    context = {
        'can_publish': request.user.has_perm('pages.can_publish'),
        'invalid_move': invalid_move,
        'language': language,
        'pages': pages,
    }
    return render(
        request, "admin/pages/page/change_list_table.html",
        context)


@staff_member_required
@csrf_exempt
def modify_content(request, page_id, content_type, language_id):
    """Modify the content of a page."""
    page = get_object_or_404(Page, pk=page_id)
    perm = request.user.has_perm('pages.change_page')
    if perm and request.method == 'POST':
        content = request.POST.get('content', False)
        if not content:
            raise Http404
        if settings.PAGE_CONTENT_REVISION:
            Content.objects.create_content_if_changed(page, language_id,
                                                      content_type, content)
        else:
            Content.objects.set_or_create_content(page, language_id,
                                                  content_type, content)
        if page:
            page.invalidate()
            # to update last modification date
            page.save()
        else:
            fake_page.invalidate(content_type)

        return HttpResponse('ok')
    raise Http404


@staff_member_required
@csrf_exempt
def modify_placeholder(request, page_id):
    """Modify the content of a page."""
    content_type = request.GET.get('content_type')
    language_id = request.GET.get('language_id')
    page = get_object_or_404(Page, pk=page_id)
    perm = request.user.has_perm('pages.change_page')
    if perm and request.method == 'POST':
        placeholders = get_placeholders(page.get_template())
        for placeholder in placeholders:
            if placeholder.name == content_type:
                initial = placeholder.get_content(
                    page, language_id, lang_fallback=False)
                form = forms.Form(request.POST, request.FILES)
                form.fields[content_type] = placeholder.get_field(
                    page, language_id, initial=initial)
                if not form.is_valid():
                    return HttpResponse(form.as_p())

                if placeholder.shared:
                    save_page = None
                else:
                    save_page = page

                extra_data = placeholder.get_extra_data(form.data)

                placeholder.save(
                    save_page, language_id,
                    form.cleaned_data[content_type], True, extra_data)
                if save_page:
                    page.invalidate()
                    # to update last modification date
                    page.save()
                else:
                    fake_page.invalidate(content_type)

                return HttpResponse('ok')
        raise Http404("Content type not found in placeholders")

    raise Http404


@staff_member_required
def get_last_content(request, page_id):
    """Get the latest content for a particular type"""
    content_type = request.GET.get('content_type')
    language_id = request.GET.get('language_id')
    page = get_object_or_404(Page, pk=page_id)
    placeholders = get_placeholders(page.get_template())
    _template = template.loader.get_template(page.get_template())
    for placeholder in placeholders:
        if placeholder.name == content_type:
            context = RequestContext(request, {
                'current_page': page,
                'lang': language_id
            })
            with context.bind_template(_template.template):
                content = placeholder.render(context)
                return HttpResponse(content)
    raise Http404


@staff_member_required
@csrf_exempt
def delete_content(request, page_id, language_id):
    page = get_object_or_404(Page, pk=page_id)
    perm = request.user.has_perm('pages.delete_page')
    if not perm:
        raise Http404

    for c in Content.objects.filter(page=page, language=language_id):
        c.delete()

    destination = request.POST.get(
        'next',
        request.META.get(
            'HTTP_REFERER',
            reverse("admin:pages_page_change", args=[page_id])
        )
    )
    return HttpResponseRedirect(destination)


@staff_member_required
def traduction(request, page_id, language_id):
    """Traduction helper."""
    page = Page.objects.get(pk=page_id)
    lang = language_id
    placeholders = get_placeholders(page.get_template())
    language_error = (
        Content.objects.get_content(page, language_id, "title")
        is None
    )
    return render(request, 'pages/traduction_helper.html', {
        'page': page,
        'lang': lang,
        'language_error': language_error,
        'placeholders': placeholders,
    })


@staff_member_required
def get_content(request, page_id, content_id):
    """Get the content for a particular page"""
    content = Content.objects.get(pk=content_id)
    return HttpResponse(content.body)


@staff_member_required
@csrf_exempt
def move_page(request, page_id, extra_context=None):
    """Move the page to the requested target, at the given
    position."""
    page = Page.objects.get(pk=page_id)

    target = request.POST.get('target', None)
    position = request.POST.get('position', None)
    if target is not None and position is not None:
        try:
            target = Page.objects.get(pk=target)
        except Page.DoesNotExist:
            pass
            # TODO: should use the django message system
            # to display this message
            # _('Page could not been moved.')
        else:
            # move_to invalidates cache on a model level
            from mptt.exceptions import InvalidMove
            invalid_move = False
            try:
                page.move_to(target, position)
            except InvalidMove:
                invalid_move = True
            return list_pages_ajax(request, invalid_move)
    return HttpResponseRedirect('../../')


@staff_member_required
def sub_menu(request, page_id):
    """Render the children of the requested page with the sub_menu
    template."""
    page = Page.objects.get(id=page_id)
    pages = page.children.all()
    page_languages = settings.PAGE_LANGUAGES
    return render(request, "admin/pages/page/sub_menu.html", {
        'can_publish': request.user.has_perm('pages.can_publish'),
        'page': page,
        'pages': pages,
        'page_languages': page_languages,
    })

import os
@staff_member_required
def get_media_url(request, media_id):
    """Get media URL."""
    media = Media.objects.get(id=media_id)
    return HttpResponse(os.path.join(settings.PAGES_MEDIA_URL, media.url.name))


1			# -- coding: utf-8 --
2			"""Pages admin views"""
3			from pages import settings
4			from django.conf import settings as django_settings
5			from pages.models import Page, Content, Media
6			from pages.utils import get_placeholders
7			from pages.phttp import get_language_from_request
8
9			from django.shortcuts import get_object_or_404, render
10			from django.http import HttpResponse, Http404, HttpResponseRedirect
11			from django.contrib.admin.views.decorators import staff_member_required
12			from django.template import RequestContext
13			from django import template
14			from django.views.decorators.csrf import csrf_exempt
15			from django.core.urlresolvers import reverse
16			from django import forms
17			from pages.managers import fake_page
18
19
20			@staff_member_required
21			@csrf_exempt
22			def change_status(request, page_id):
23			"""
24			Switch the status of a page.
25			"""
26			perm = request.user.has_perm('pages.change_page')
27			if perm and request.method == 'POST':
28			page = Page.objects.get(pk=page_id)
29			page.status = int(request.POST['status'])
30			page.invalidate()
31			page.save()
32			return HttpResponse(str(page.status))
33			raise Http404
34
35
36			@staff_member_required
37			def list_pages_ajax(request, invalid_move=False):
38			"""Render pages table for ajax function."""
39			language = get_language_from_request(request)
40			pages = Page.objects.root()
41			context = {
42			'can_publish': request.user.has_perm('pages.can_publish'),
43			'invalid_move': invalid_move,
44			'language': language,
45			'pages': pages,
46			}
47			return render(
48			request, "admin/pages/page/change_list_table.html",
49			context)
50
51
52			@staff_member_required
53			@csrf_exempt
54			def modify_content(request, page_id, content_type, language_id):
55			"""Modify the content of a page."""
56			page = get_object_or_404(Page, pk=page_id)
57			perm = request.user.has_perm('pages.change_page')
58			if perm and request.method == 'POST':
59			content = request.POST.get('content', False)
60			if not content:
61			raise Http404
62			if settings.PAGE_CONTENT_REVISION:
63			Content.objects.create_content_if_changed(page, language_id,
64			content_type, content)
65			else:
66			Content.objects.set_or_create_content(page, language_id,
67			content_type, content)
68			if page:
69			page.invalidate()
70			# to update last modification date
71			page.save()
72			else:
73			fake_page.invalidate(content_type)
74
75			return HttpResponse('ok')
76			raise Http404
77
78
79			@staff_member_required
80			@csrf_exempt
81			def modify_placeholder(request, page_id):
82			"""Modify the content of a page."""
83			content_type = request.GET.get('content_type')
84			language_id = request.GET.get('language_id')
85			page = get_object_or_404(Page, pk=page_id)
86			perm = request.user.has_perm('pages.change_page')
87			if perm and request.method == 'POST':
88			placeholders = get_placeholders(page.get_template())
89			for placeholder in placeholders:
90			if placeholder.name == content_type:
91			initial = placeholder.get_content(
92			page, language_id, lang_fallback=False)
93			form = forms.Form(request.POST, request.FILES)
94			form.fields[content_type] = placeholder.get_field(
95			page, language_id, initial=initial)
96			if not form.is_valid():
97			return HttpResponse(form.as_p())
98
99			if placeholder.shared:
100			save_page = None
101			else:
102			save_page = page
103
104			extra_data = placeholder.get_extra_data(form.data)
105
106			placeholder.save(
107			save_page, language_id,
108			form.cleaned_data[content_type], True, extra_data)
109			if save_page:
110			page.invalidate()
111			# to update last modification date
112			page.save()
113			else:
114			fake_page.invalidate(content_type)
115
116			return HttpResponse('ok')
117			raise Http404("Content type not found in placeholders")
118
119			raise Http404
120
121
122			@staff_member_required
123			def get_last_content(request, page_id):
124			"""Get the latest content for a particular type"""
125			content_type = request.GET.get('content_type')
126			language_id = request.GET.get('language_id')
127			page = get_object_or_404(Page, pk=page_id)
128			placeholders = get_placeholders(page.get_template())
129			_template = template.loader.get_template(page.get_template())
130			for placeholder in placeholders:
131			if placeholder.name == content_type:
132			context = RequestContext(request, {
133			'current_page': page,
134			'lang': language_id
135			})
136			with context.bind_template(_template.template):
137			content = placeholder.render(context)
138			return HttpResponse(content)
139			raise Http404
140
141
142			@staff_member_required
143			@csrf_exempt
144			def delete_content(request, page_id, language_id):
145			page = get_object_or_404(Page, pk=page_id)
146			perm = request.user.has_perm('pages.delete_page')
147			if not perm:
148			raise Http404
149
150			for c in Content.objects.filter(page=page, language=language_id):
151			c.delete()
152
153			destination = request.POST.get(
154			'next',
155			request.META.get(
156			'HTTP_REFERER',
157			reverse("admin:pages_page_change", args=[page_id])
158			)
159			)
160			return HttpResponseRedirect(destination)
161
162
163			@staff_member_required
164			def traduction(request, page_id, language_id):
165			"""Traduction helper."""
166			page = Page.objects.get(pk=page_id)
167			lang = language_id
168			placeholders = get_placeholders(page.get_template())
169			language_error = (
170			Content.objects.get_content(page, language_id, "title")
171			is None
172			)
173			return render(request, 'pages/traduction_helper.html', {
174			'page': page,
175			'lang': lang,
176			'language_error': language_error,
177			'placeholders': placeholders,
178			})
179
180
181			@staff_member_required
182			def get_content(request, page_id, content_id):
183			"""Get the content for a particular page"""
184			content = Content.objects.get(pk=content_id)
185			return HttpResponse(content.body)
186
187
188			@staff_member_required
189			@csrf_exempt
190			def move_page(request, page_id, extra_context=None):
191			"""Move the page to the requested target, at the given
192			position."""
193			page = Page.objects.get(pk=page_id)
194
195			target = request.POST.get('target', None)
196			position = request.POST.get('position', None)
197			if target is not None and position is not None:
198			try:
199			target = Page.objects.get(pk=target)
200			except Page.DoesNotExist:
201			pass
202			# TODO: should use the django message system
203			# to display this message
204			# _('Page could not been moved.')
205			else:
206			# move_to invalidates cache on a model level
207			from mptt.exceptions import InvalidMove
208			invalid_move = False
209			try:
210			page.move_to(target, position)
211			except InvalidMove:
212			invalid_move = True
213			return list_pages_ajax(request, invalid_move)
214			return HttpResponseRedirect('../../')
215
216
217			@staff_member_required
218			def sub_menu(request, page_id):
219			"""Render the children of the requested page with the sub_menu
220			template."""
221			page = Page.objects.get(id=page_id)
222			pages = page.children.all()
223			page_languages = settings.PAGE_LANGUAGES
224			return render(request, "admin/pages/page/sub_menu.html", {
225			'can_publish': request.user.has_perm('pages.can_publish'),
226			'page': page,
227			'pages': pages,
228			'page_languages': page_languages,
229			})
230
231			import os
232			@staff_member_required
233			def get_media_url(request, media_id):
234			"""Get media URL."""
235			media = Media.objects.get(id=media_id)
236			return HttpResponse(os.path.join(settings.PAGES_MEDIA_URL, media.url.name))
237

batiste / django-page-cms

Pull Request — master (#169)

get_media_url() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like