10941406873

Committed 19 Sep 2024 12:55PM UTC coverage: 87.088% (-0.007%) from 87.095%

Build # 10941406873

Build Type

Pull #1294

github

Committed by

web-flow

Commit Message

Merge 0ca2fd0ed into b2c563a85

Pull Request Pull Request #1294: remove JSONPATCH setting

Run Details

6374 of 7319 relevant lines covered (87.09%)

4.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.05

fiduswriter/base/views.py

import json
import random
from httpx_ws import connect_ws

from django.conf import settings
from django.shortcuts import render
from django.views.decorators.csrf import ensure_csrf_cookie
from django.contrib.sites.shortcuts import get_current_site
from django.contrib.flatpages.models import FlatPage
from django.http import JsonResponse
from django.views.decorators.http import require_GET, require_POST
from django.contrib.admin.views.decorators import staff_member_required

from allauth.socialaccount.adapter import get_adapter

from user.helpers import Avatars
from .decorators import ajax_required
from . import get_version
from .helpers.host import get_host
from .models import Presence


@ensure_csrf_cookie
def app(request):
    """
    Load a page controlled by the JavaScript app.
    Used all user facing pages after login.
    """
    return render(request, "app.html", {"version": get_version()})


def api_404(request):
    """
    Show a 404 error within the API.
    """
    return render(request, "api_404.html", status=404)


@ajax_required
@require_POST
def configuration(request):
    """
    Load the configuration options of the page that are request dependent.
    """
    ws_host = get_host(
        request.headers["Origin"], random.choice(settings.WS_SERVERS)
    )
    socialaccount_providers = []
    for provider in get_adapter(request).list_providers(request):
        socialaccount_providers.append(
            {
                "id": provider.id,
                "name": provider.name,
                "login_url": provider.get_login_url(request),
            }
        )
    response = {
        "language": request.LANGUAGE_CODE,
        "socialaccount_providers": socialaccount_providers,
        "ws_host": ws_host,
    }
    if request.user.is_authenticated:
        avatars = Avatars()
        response["user"] = {
            "id": request.user.id,
            "username": request.user.username,
            "first_name": request.user.first_name,
            "name": request.user.readable_name,
            "last_name": request.user.last_name,
            "avatar": avatars.get_url(request.user),
            "emails": [],
            "socialaccounts": [],
            "is_authenticated": True,
        }

        for emailaddress in request.user.emailaddress_set.all():
            email = {
                "address": emailaddress.email,
            }
            if emailaddress.primary:
                email["primary"] = True
            if emailaddress.verified:
                email["verified"] = True
            response["user"]["emails"].append(email)
        for account in request.user.socialaccount_set.all():
            try:
                provider_account = account.get_provider_account()
                response["user"]["socialaccounts"].append(
                    {
                        "id": account.id,
                        "provider": account.provider,
                        "name": provider_account.to_str(),
                    }
                )
            except KeyError:
                # Social account provider has been removed.
                pass
        response["user"]["waiting_invites"] = request.user.invites_to.exists()

    else:
        response["user"] = {"is_authenticated": False}
    return JsonResponse(response, status=200)


def manifest_json(request):
    """
    Load the manifest.json.
    """
    return render(request, "manifest.json")


# view is shown only in admin interface, so authentication is taken care of
def admin_console(request):
    """
    Load the admin console page.
    """
    return render(request, "admin/console.html")


@ajax_required
@require_GET
@staff_member_required
def connection_info(request):
    """
    Return info about currently connected clients.
    """
    response = {}
    Presence.prune()
    response["sessions"] = Presence.objects.all().count()
    response["users"] = Presence.objects.values("user").distinct().count()
    return JsonResponse(response, status=200)


def send_to_server(server_url, message, headers):
    with connect_ws(
        server_url,
        headers={
            "Origin": headers["Origin"],
            "Cookie": headers["Cookie"],
            "User-Agent": "Fidus Writer",
        },
    ) as websocket:
        websocket.send_text(
            json.dumps({"type": "system_message", "message": message})
        )


@ajax_required
@require_POST
@staff_member_required
def send_system_message(request):
    """
    Send out a system message to all clients connected to the frontend.
    """
    response = {}
    message = request.POST["message"]

    servers = set(
        Presence.objects.values_list("server_url", flat=True).distinct()
    )

    for server in servers:
        send_to_server(server, message, dict(request.headers))

    return JsonResponse(response, status=200)


@ajax_required
@require_POST
def flatpage(request):
    """
    Models: `flatpages.flatpages`
    Context:
        flatpage
            `flatpages.flatpages` object
    """
    response = {}
    status = 404
    url = request.POST["url"]
    site_id = get_current_site(request).id
    flatpage = FlatPage.objects.filter(url=url, sites=site_id).first()
    if flatpage:
        status = 200
        response["title"] = flatpage.title
        response["content"] = flatpage.content
    return JsonResponse(response, status=status)

1	import json	13✔
2	import random	13✔
3	from httpx_ws import connect_ws	13✔
4
5	from django.conf import settings	13✔
6	from django.shortcuts import render	13✔
7	from django.views.decorators.csrf import ensure_csrf_cookie	13✔
8	from django.contrib.sites.shortcuts import get_current_site	13✔
9	from django.contrib.flatpages.models import FlatPage	13✔
10	from django.http import JsonResponse	13✔
11	from django.views.decorators.http import require_GET, require_POST	13✔
12	from django.contrib.admin.views.decorators import staff_member_required	13✔
13
14	from allauth.socialaccount.adapter import get_adapter	13✔
15
16	from user.helpers import Avatars	13✔
17	from .decorators import ajax_required	13✔
18	from . import get_version	13✔
19	from .helpers.host import get_host	13✔
20	from .models import Presence	13✔
21
22
23	@ensure_csrf_cookie	13✔
24	def app(request):	13✔
25	"""
26	Load a page controlled by the JavaScript app.
27	Used all user facing pages after login.
28	"""
29	return render(request, "app.html", {"version": get_version()})	13✔
30
31
32	def api_404(request):	13✔
33	"""
34	Show a 404 error within the API.
35	"""
36	return render(request, "api_404.html", status=404)	×
37
38
39	@ajax_required	13✔
40	@require_POST	13✔
41	def configuration(request):	13✔
42	"""
43	Load the configuration options of the page that are request dependent.
44	"""
45	ws_host = get_host(	13✔
46	request.headers["Origin"], random.choice(settings.WS_SERVERS)
47	)
48	socialaccount_providers = []	13✔
49	for provider in get_adapter(request).list_providers(request):	13✔
50	socialaccount_providers.append(	×
51	{
52	"id": provider.id,
53	"name": provider.name,
54	"login_url": provider.get_login_url(request),
55	}
56	)
57	response = {	13✔
58	"language": request.LANGUAGE_CODE,
59	"socialaccount_providers": socialaccount_providers,
60	"ws_host": ws_host,
61	}
62	if request.user.is_authenticated:	13✔
63	avatars = Avatars()	13✔
64	response["user"] = {	13✔
65	"id": request.user.id,
66	"username": request.user.username,
67	"first_name": request.user.first_name,
68	"name": request.user.readable_name,
69	"last_name": request.user.last_name,
70	"avatar": avatars.get_url(request.user),
71	"emails": [],
72	"socialaccounts": [],
73	"is_authenticated": True,
74	}
75
76	for emailaddress in request.user.emailaddress_set.all():	13✔
77	email = {	13✔
78	"address": emailaddress.email,
79	}
80	if emailaddress.primary:	13✔
81	email["primary"] = True	13✔
82	if emailaddress.verified:	13✔
83	email["verified"] = True	13✔
84	response["user"]["emails"].append(email)	13✔
85	for account in request.user.socialaccount_set.all():	13✔
86	try:	×
87	provider_account = account.get_provider_account()	×
88	response["user"]["socialaccounts"].append(	×
89	{
90	"id": account.id,
91	"provider": account.provider,
92	"name": provider_account.to_str(),
93	}
94	)
95	except KeyError:	×
96	# Social account provider has been removed.
97	pass	×
98	response["user"]["waiting_invites"] = request.user.invites_to.exists()	13✔
99
100	else:
101	response["user"] = {"is_authenticated": False}	13✔
102	return JsonResponse(response, status=200)	13✔
103
104
105	def manifest_json(request):	13✔
106	"""
107	Load the manifest.json.
108	"""
109	return render(request, "manifest.json")	13✔
110
111
112	# view is shown only in admin interface, so authentication is taken care of
113	def admin_console(request):	13✔
114	"""
115	Load the admin console page.
116	"""
117	return render(request, "admin/console.html")	1✔
118
119
120	@ajax_required	13✔
121	@require_GET	13✔
122	@staff_member_required	13✔
123	def connection_info(request):	13✔
124	"""
125	Return info about currently connected clients.
126	"""
127	response = {}	1✔
128	Presence.prune()	1✔
129	response["sessions"] = Presence.objects.all().count()	1✔
130	response["users"] = Presence.objects.values("user").distinct().count()	1✔
131	return JsonResponse(response, status=200)	1✔
132
133
134	def send_to_server(server_url, message, headers):	13✔
135	with connect_ws(	1✔
136	server_url,
137	headers={
138	"Origin": headers["Origin"],
139	"Cookie": headers["Cookie"],
140	"User-Agent": "Fidus Writer",
141	},
142	) as websocket:
143	websocket.send_text(	1✔
144	json.dumps({"type": "system_message", "message": message})
145	)
146
147
148	@ajax_required	13✔
149	@require_POST	13✔
150	@staff_member_required	13✔
151	def send_system_message(request):	13✔
152	"""
153	Send out a system message to all clients connected to the frontend.
154	"""
155	response = {}	1✔
156	message = request.POST["message"]	1✔
157
158	servers = set(	1✔
159	Presence.objects.values_list("server_url", flat=True).distinct()
160	)
161
162	for server in servers:	1✔
163	send_to_server(server, message, dict(request.headers))	1✔
164
165	return JsonResponse(response, status=200)	1✔
166
167
168	@ajax_required	13✔
169	@require_POST	13✔
170	def flatpage(request):	13✔
171	"""
172	Models: `flatpages.flatpages`
173	Context:
174	flatpage
175	`flatpages.flatpages` object
176	"""
177	response = {}	1✔
178	status = 404	1✔
179	url = request.POST["url"]	1✔
180	site_id = get_current_site(request).id	1✔
181	flatpage = FlatPage.objects.filter(url=url, sites=site_id).first()	1✔
182	if flatpage:	1✔
183	status = 200	1✔
184	response["title"] = flatpage.title	1✔
185	response["content"] = flatpage.content	1✔
186	return JsonResponse(response, status=status)	1✔

fiduswriter / fiduswriter / 10941406873

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous