yul/bookwyrm-mastodon
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

New version of black, new whitespace

Browse Source
This commit is contained in:
Mouse Reeve
2021-04-26 09:15:42 -07:00
parent ef83eb33b0
commit 3ade2d3bb1
152 changed files with 1289 additions and 1289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
bookwyrm/views/authentication.py
View File

@ -16,10 +16,10 @@ from bookwyrm.settings import DOMAIN
# pylint: disable= no-self-use
@method_decorator(csrf_exempt, name="dispatch")
class Login(View):
""" authenticate an existing user """
"""authenticate an existing user"""
def get(self, request):
""" login page """
"""login page"""
if request.user.is_authenticated:
return redirect("/")
# sene user to the login page
@ -30,7 +30,7 @@ class Login(View):
return TemplateResponse(request, "login.html", data)
def post(self, request):
""" authentication action """
"""authentication action"""
if request.user.is_authenticated:
return redirect("/")
login_form = forms.LoginForm(request.POST)
@ -61,10 +61,10 @@ class Login(View):
class Register(View):
""" register a user """
"""register a user"""
def post(self, request):
""" join the server """
"""join the server"""
if not models.SiteSettings.get().allow_registration:
invite_code = request.POST.get("invite_code")
@ -117,9 +117,9 @@ class Register(View):
@method_decorator(login_required, name="dispatch")
class Logout(View):
""" log out """
"""log out"""
def get(self, request):
""" done with this place! outa here! """
"""done with this place! outa here!"""
logout(request)
return redirect("/")

10
bookwyrm/views/author.py
View File

@ -13,10 +13,10 @@ from .helpers import is_api_request
# pylint: disable= no-self-use
class Author(View):
""" this person wrote a book """
"""this person wrote a book"""
def get(self, request, author_id):
""" landing page for an author """
"""landing page for an author"""
author = get_object_or_404(models.Author, id=author_id)
if is_api_request(request):
@ -37,16 +37,16 @@ class Author(View):
permission_required("bookwyrm.edit_book", raise_exception=True), name="dispatch"
)
class EditAuthor(View):
""" edit author info """
"""edit author info"""
def get(self, request, author_id):
""" info about a book """
"""info about a book"""
author = get_object_or_404(models.Author, id=author_id)
data = {"author": author, "form": forms.AuthorForm(instance=author)}
return TemplateResponse(request, "edit_author.html", data)
def post(self, request, author_id):
""" edit a author cool """
"""edit a author cool"""
author = get_object_or_404(models.Author, id=author_id)
form = forms.AuthorForm(request.POST, request.FILES, instance=author)

8
bookwyrm/views/block.py
View File

@ -12,14 +12,14 @@ from bookwyrm import models
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class Block(View):
""" blocking users """
"""blocking users"""
def get(self, request):
""" list of blocked users? """
"""list of blocked users?"""
return TemplateResponse(request, "preferences/blocks.html")
def post(self, request, user_id):
""" block a user """
"""block a user"""
to_block = get_object_or_404(models.User, id=user_id)
models.UserBlocks.objects.create(
user_subject=request.user, user_object=to_block
@ -30,7 +30,7 @@ class Block(View):
@require_POST
@login_required
def unblock(request, user_id):
""" undo a block """
"""undo a block"""
to_unblock = get_object_or_404(models.User, id=user_id)
try:
block = models.UserBlocks.objects.get(

28
bookwyrm/views/books.py
View File

@ -26,10 +26,10 @@ from .helpers import is_api_request, get_edition, privacy_filter
# pylint: disable= no-self-use
class Book(View):
""" a book! this is the stuff """
"""a book! this is the stuff"""
def get(self, request, book_id, user_statuses=False):
""" info about a book """
"""info about a book"""
try:
book = models.Book.objects.select_subclasses().get(id=book_id)
except models.Book.DoesNotExist:
@ -110,10 +110,10 @@ class Book(View):
permission_required("bookwyrm.edit_book", raise_exception=True), name="dispatch"
)
class EditBook(View):
""" edit a book """
"""edit a book"""
def get(self, request, book_id=None):
""" info about a book """
"""info about a book"""
book = None
if book_id:
book = get_edition(book_id)
@ -123,7 +123,7 @@ class EditBook(View):
return TemplateResponse(request, "book/edit_book.html", data)
def post(self, request, book_id=None):
""" edit a book cool """
"""edit a book cool"""
# returns None if no match is found
book = models.Edition.objects.filter(id=book_id).first()
form = forms.EditionForm(request.POST, request.FILES, instance=book)
@ -209,10 +209,10 @@ class EditBook(View):
permission_required("bookwyrm.edit_book", raise_exception=True), name="dispatch"
)
class ConfirmEditBook(View):
""" confirm edits to a book """
"""confirm edits to a book"""
def post(self, request, book_id=None):
""" edit a book cool """
"""edit a book cool"""
# returns None if no match is found
book = models.Edition.objects.filter(id=book_id).first()
form = forms.EditionForm(request.POST, request.FILES, instance=book)
@ -260,10 +260,10 @@ class ConfirmEditBook(View):
class Editions(View):
""" list of editions """
"""list of editions"""
def get(self, request, book_id):
""" list of editions of a book """
"""list of editions of a book"""
work = get_object_or_404(models.Work, id=book_id)
if is_api_request(request):
@ -293,7 +293,7 @@ class Editions(View):
@login_required
@require_POST
def upload_cover(request, book_id):
""" upload a new cover """
"""upload a new cover"""
book = get_object_or_404(models.Edition, id=book_id)
book.last_edited_by = request.user
@ -316,7 +316,7 @@ def upload_cover(request, book_id):
def set_cover_from_url(url):
""" load it from a url """
"""load it from a url"""
image_file = get_image(url)
if not image_file:
return None
@ -329,7 +329,7 @@ def set_cover_from_url(url):
@require_POST
@permission_required("bookwyrm.edit_book", raise_exception=True)
def add_description(request, book_id):
""" upload a new cover """
"""upload a new cover"""
if not request.method == "POST":
return redirect("/")
@ -346,7 +346,7 @@ def add_description(request, book_id):
@require_POST
def resolve_book(request):
""" figure out the local path to a book from a remote_id """
"""figure out the local path to a book from a remote_id"""
remote_id = request.POST.get("remote_id")
connector = connector_manager.get_or_create_connector(remote_id)
book = connector.get_or_create_book(remote_id)
@ -358,7 +358,7 @@ def resolve_book(request):
@require_POST
@transaction.atomic
def switch_edition(request):
""" switch your copy of a book to a different edition """
"""switch your copy of a book to a different edition"""
edition_id = request.POST.get("edition")
new_edition = get_object_or_404(models.Edition, id=edition_id)
shelfbooks = models.ShelfBook.objects.filter(

6
bookwyrm/views/directory.py
View File

@ -11,10 +11,10 @@ from .helpers import get_annotated_users
# pylint: disable=no-self-use
@method_decorator(login_required, name="dispatch")
class Directory(View):
""" display of known bookwyrm users """
"""display of known bookwyrm users"""
def get(self, request):
""" lets see your cute faces """
"""lets see your cute faces"""
filters = {}
software = request.GET.get("software")
if not software or software == "bookwyrm":
@ -38,7 +38,7 @@ class Directory(View):
return TemplateResponse(request, "directory/directory.html", data)
def post(self, request):
""" join the directory """
"""join the directory"""
request.user.discoverable = True
request.user.save()
return redirect("directory")

26
bookwyrm/views/federation.py
View File

@ -20,10 +20,10 @@ from bookwyrm.settings import PAGE_LENGTH
name="dispatch",
)
class Federation(View):
""" what servers do we federate with """
"""what servers do we federate with"""
def get(self, request):
""" list of servers """
"""list of servers"""
servers = models.FederatedServer.objects
sort = request.GET.get("sort")
@ -43,15 +43,15 @@ class Federation(View):
class AddFederatedServer(View):
""" manually add a server """
"""manually add a server"""
def get(self, request):
""" add server form """
"""add server form"""
data = {"form": forms.ServerForm()}
return TemplateResponse(request, "settings/edit_server.html", data)
def post(self, request):
""" add a server from the admin panel """
"""add a server from the admin panel"""
form = forms.ServerForm(request.POST)
if not form.is_valid():
data = {"form": form}
@ -66,14 +66,14 @@ class AddFederatedServer(View):
name="dispatch",
)
class ImportServerBlocklist(View):
""" manually add a server """
"""manually add a server"""
def get(self, request):
""" add server form """
"""add server form"""
return TemplateResponse(request, "settings/server_blocklist.html")
def post(self, request):
""" add a server from the admin panel """
"""add a server from the admin panel"""
json_data = json.load(request.FILES["json_file"])
failed = []
success_count = 0
@ -102,10 +102,10 @@ class ImportServerBlocklist(View):
name="dispatch",
)
class FederatedServer(View):
""" views for handling a specific federated server """
"""views for handling a specific federated server"""
def get(self, request, server):
""" load a server """
"""load a server"""
server = get_object_or_404(models.FederatedServer, id=server)
users = server.user_set
data = {
@ -121,7 +121,7 @@ class FederatedServer(View):
return TemplateResponse(request, "settings/federated_server.html", data)
def post(self, request, server): # pylint: disable=unused-argument
""" update note """
"""update note"""
server = get_object_or_404(models.FederatedServer, id=server)
server.notes = request.POST.get("notes")
server.save()
@ -133,7 +133,7 @@ class FederatedServer(View):
@permission_required("bookwyrm.control_federation", raise_exception=True)
# pylint: disable=unused-argument
def block_server(request, server):
""" block a server """
"""block a server"""
server = get_object_or_404(models.FederatedServer, id=server)
server.block()
return redirect("settings-federated-server", server.id)
@ -144,7 +144,7 @@ def block_server(request, server):
@permission_required("bookwyrm.control_federation", raise_exception=True)
# pylint: disable=unused-argument
def unblock_server(request, server):
""" unblock a server """
"""unblock a server"""
server = get_object_or_404(models.FederatedServer, id=server)
server.unblock()
return redirect("settings-federated-server", server.id)

20
bookwyrm/views/feed.py
View File

@ -18,10 +18,10 @@ from .helpers import is_api_request, is_bookwyrm_request
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class Feed(View):
""" activity stream """
"""activity stream"""
def get(self, request, tab):
""" user's homepage with activity feed """
"""user's homepage with activity feed"""
if not tab in STREAMS:
tab = "home"
@ -46,10 +46,10 @@ class Feed(View):
@method_decorator(login_required, name="dispatch")
class DirectMessage(View):
""" dm view """
"""dm view"""
def get(self, request, username=None):
""" like a feed but for dms only """
"""like a feed but for dms only"""
# remove fancy subclasses of status, keep just good ol' notes
queryset = models.Status.objects.filter(
review__isnull=True,
@ -85,10 +85,10 @@ class DirectMessage(View):
class Status(View):
""" get posting """
"""get posting"""
def get(self, request, username, status_id):
""" display a particular status (and replies, etc) """
"""display a particular status (and replies, etc)"""
try:
user = get_user_from_username(request.user, username)
status = models.Status.objects.select_subclasses().get(
@ -120,10 +120,10 @@ class Status(View):
class Replies(View):
""" replies page (a json view of status) """
"""replies page (a json view of status)"""
def get(self, request, username, status_id):
""" ordered collection of replies to a status """
"""ordered collection of replies to a status"""
# the html view is the same as Status
if not is_api_request(request):
status_view = Status.as_view()
@ -138,7 +138,7 @@ class Replies(View):
def feed_page_data(user):
""" info we need for every feed page """
"""info we need for every feed page"""
if not user.is_authenticated:
return {}
@ -151,7 +151,7 @@ def feed_page_data(user):
def get_suggested_books(user, max_books=5):
""" helper to get a user's recent books """
"""helper to get a user's recent books"""
book_count = 0
preset_shelves = [("reading", max_books), ("read", 2), ("to-read", max_books)]
suggested_books = []

8
bookwyrm/views/follow.py
View File

@ -12,7 +12,7 @@ from .helpers import get_user_from_username
@login_required
@require_POST
def follow(request):
""" follow another user, here or abroad """
"""follow another user, here or abroad"""
username = request.POST["user"]
try:
to_follow = get_user_from_username(request.user, username)
@ -33,7 +33,7 @@ def follow(request):
@login_required
@require_POST
def unfollow(request):
""" unfollow a user """
"""unfollow a user"""
username = request.POST["user"]
try:
to_unfollow = get_user_from_username(request.user, username)
@ -61,7 +61,7 @@ def unfollow(request):
@login_required
@require_POST
def accept_follow_request(request):
""" a user accepts a follow request """
"""a user accepts a follow request"""
username = request.POST["user"]
try:
requester = get_user_from_username(request.user, username)
@ -83,7 +83,7 @@ def accept_follow_request(request):
@login_required
@require_POST
def delete_follow_request(request):
""" a user rejects a follow request """
"""a user rejects a follow request"""
username = request.POST["user"]
try:
requester = get_user_from_username(request.user, username)

16
bookwyrm/views/get_started.py
View File

@ -20,12 +20,12 @@ from .user import save_user_form
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class GetStartedProfile(View):
""" tell us about yourself """
"""tell us about yourself"""
next_view = "get-started-books"
def get(self, request):
""" basic profile info """
"""basic profile info"""
data = {
"form": forms.LimitedEditUserForm(instance=request.user),
"next": self.next_view,
@ -33,7 +33,7 @@ class GetStartedProfile(View):
return TemplateResponse(request, "get_started/profile.html", data)
def post(self, request):
""" update your profile """
"""update your profile"""
form = forms.LimitedEditUserForm(
request.POST, request.FILES, instance=request.user
)
@ -46,12 +46,12 @@ class GetStartedProfile(View):
@method_decorator(login_required, name="dispatch")
class GetStartedBooks(View):
""" name a book, any book, we gotta start somewhere """
"""name a book, any book, we gotta start somewhere"""
next_view = "get-started-users"
def get(self, request):
""" info about a book """
"""info about a book"""
query = request.GET.get("query")
book_results = popular_books = []
if query:
@ -82,7 +82,7 @@ class GetStartedBooks(View):
return TemplateResponse(request, "get_started/books.html", data)
def post(self, request):
""" shelve some books """
"""shelve some books"""
shelve_actions = [
(k, v)
for k, v in request.POST.items()
@ -100,10 +100,10 @@ class GetStartedBooks(View):
@method_decorator(login_required, name="dispatch")
class GetStartedUsers(View):
""" find friends """
"""find friends"""
def get(self, request):
""" basic profile info """
"""basic profile info"""
query = request.GET.get("query")
user_results = (
models.User.viewer_aware_objects(request.user)

8
bookwyrm/views/goal.py
View File

@ -16,10 +16,10 @@ from .helpers import get_user_from_username
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class Goal(View):
""" track books for the year """
"""track books for the year"""
def get(self, request, username, year):
""" reading goal page """
"""reading goal page"""
user = get_user_from_username(request.user, username)
year = int(year)
goal = models.AnnualGoal.objects.filter(year=year, user=user).first()
@ -39,7 +39,7 @@ class Goal(View):
return TemplateResponse(request, "goal.html", data)
def post(self, request, username, year):
""" update or create an annual goal """
"""update or create an annual goal"""
user = get_user_from_username(request.user, username)
if user != request.user:
return HttpResponseNotFound()
@ -71,7 +71,7 @@ class Goal(View):
@require_POST
@login_required
def hide_goal(request):
""" don't keep bugging people to set a goal """
"""don't keep bugging people to set a goal"""
request.user.show_goal = False
request.user.save(broadcast=False)
return redirect(request.headers.get("Referer", "/"))

22
bookwyrm/views/helpers.py
View File

@ -11,7 +11,7 @@ from bookwyrm.utils import regex
def get_user_from_username(viewer, username):
""" helper function to resolve a localname or a username to a user """
"""helper function to resolve a localname or a username to a user"""
# raises DoesNotExist if user is now found
try:
return models.User.viewer_aware_objects(viewer).get(localname=username)
@ -20,12 +20,12 @@ def get_user_from_username(viewer, username):
def is_api_request(request):
""" check whether a request is asking for html or data """
"""check whether a request is asking for html or data"""
return "json" in request.headers.get("Accept", "") or request.path[-5:] == ".json"
def is_bookwyrm_request(request):
""" check if the request is coming from another bookwyrm instance """
"""check if the request is coming from another bookwyrm instance"""
user_agent = request.headers.get("User-Agent")
if user_agent is None or re.search(regex.bookwyrm_user_agent, user_agent) is None:
return False
@ -33,7 +33,7 @@ def is_bookwyrm_request(request):
def privacy_filter(viewer, queryset, privacy_levels=None, following_only=False):
""" filter objects that have "user" and "privacy" fields """
"""filter objects that have "user" and "privacy" fields"""
privacy_levels = privacy_levels or ["public", "unlisted", "followers", "direct"]
# if there'd a deleted field, exclude deleted items
try:
@ -84,7 +84,7 @@ def privacy_filter(viewer, queryset, privacy_levels=None, following_only=False):
def handle_remote_webfinger(query):
""" webfingerin' other servers """
"""webfingerin' other servers"""
user = None
# usernames could be @user@domain or user@domain
@ -120,7 +120,7 @@ def handle_remote_webfinger(query):
def get_edition(book_id):
""" look up a book in the db and return an edition """
"""look up a book in the db and return an edition"""
book = models.Book.objects.select_subclasses().get(id=book_id)
if isinstance(book, models.Work):
book = book.get_default_edition()
@ -128,7 +128,7 @@ def get_edition(book_id):
def handle_reading_status(user, shelf, book, privacy):
""" post about a user reading a book """
"""post about a user reading a book"""
# tell the world about this cool thing that happened
try:
message = {
@ -145,14 +145,14 @@ def handle_reading_status(user, shelf, book, privacy):
def is_blocked(viewer, user):
""" is this viewer blocked by the user? """
"""is this viewer blocked by the user?"""
if viewer.is_authenticated and viewer in user.blocks.all():
return True
return False
def get_discover_books():
""" list of books for the discover page """
"""list of books for the discover page"""
return list(
set(
models.Edition.objects.filter(
@ -169,7 +169,7 @@ def get_discover_books():
def get_suggested_users(user):
""" bookwyrm users you don't already know """
"""bookwyrm users you don't already know"""
return (
get_annotated_users(
user,
@ -184,7 +184,7 @@ def get_suggested_users(user):
def get_annotated_users(user, *args, **kwargs):
""" Users, annotated with things they have in common """
"""Users, annotated with things they have in common"""
return (
models.User.objects.filter(discoverable=True, is_active=True, *args, **kwargs)
.exclude(Q(id__in=user.blocks.all()) | Q(blocks=user))

12
bookwyrm/views/import_data.py
View File

@ -16,10 +16,10 @@ from bookwyrm.tasks import app
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class Import(View):
""" import view """
"""import view"""
def get(self, request):
""" load import page """
"""load import page"""
return TemplateResponse(
request,
"import.html",
@ -32,7 +32,7 @@ class Import(View):
)
def post(self, request):
""" ingest a goodreads csv """
"""ingest a goodreads csv"""
form = forms.ImportForm(request.POST, request.FILES)
if form.is_valid():
include_reviews = request.POST.get("include_reviews") == "on"
@ -66,10 +66,10 @@ class Import(View):
@method_decorator(login_required, name="dispatch")
class ImportStatus(View):
""" status of an existing import """
"""status of an existing import"""
def get(self, request, job_id):
""" status of an import job """
"""status of an import job"""
job = models.ImportJob.objects.get(id=job_id)
if job.user != request.user:
raise PermissionDenied
@ -84,7 +84,7 @@ class ImportStatus(View):
)
def post(self, request, job_id):
""" retry lines from an import """
"""retry lines from an import"""
job = get_object_or_404(models.ImportJob, id=job_id)
items = []
for item in request.POST.getlist("import_item"):

12
bookwyrm/views/inbox.py
View File

@ -19,10 +19,10 @@ from bookwyrm.utils import regex
@method_decorator(csrf_exempt, name="dispatch")
# pylint: disable=no-self-use
class Inbox(View):
""" requests sent by outside servers"""
"""requests sent by outside servers"""
def post(self, request, username=None):
""" only works as POST request """
"""only works as POST request"""
# first check if this server is on our shitlist
if is_blocked_user_agent(request):
return HttpResponseForbidden()
@ -65,7 +65,7 @@ class Inbox(View):
def is_blocked_user_agent(request):
""" check if a request is from a blocked server based on user agent """
"""check if a request is from a blocked server based on user agent"""
# check user agent
user_agent = request.headers.get("User-Agent")
if not user_agent:
@ -78,7 +78,7 @@ def is_blocked_user_agent(request):
def is_blocked_activity(activity_json):
""" get the sender out of activity json and check if it's blocked """
"""get the sender out of activity json and check if it's blocked"""
actor = activity_json.get("actor")
# check if the user is banned/deleted
@ -94,7 +94,7 @@ def is_blocked_activity(activity_json):
@app.task
def activity_task(activity_json):
""" do something with this json we think is legit """
"""do something with this json we think is legit"""
# lets see if the activitypub module can make sense of this json
activity = activitypub.parse(activity_json)
@ -104,7 +104,7 @@ def activity_task(activity_json):
def has_valid_signature(request, activity):
""" verify incoming signature """
"""verify incoming signature"""
try:
signature = Signature.parse(request)

16
bookwyrm/views/interaction.py
View File

@ -12,10 +12,10 @@ from bookwyrm import models
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class Favorite(View):
""" like a status """
"""like a status"""
def post(self, request, status_id):
""" create a like """
"""create a like"""
status = models.Status.objects.get(id=status_id)
try:
models.Favorite.objects.create(status=status, user=request.user)
@ -28,10 +28,10 @@ class Favorite(View):
@method_decorator(login_required, name="dispatch")
class Unfavorite(View):
""" take back a fav """
"""take back a fav"""
def post(self, request, status_id):
""" unlike a status """
"""unlike a status"""
status = models.Status.objects.get(id=status_id)
try:
favorite = models.Favorite.objects.get(status=status, user=request.user)
@ -45,10 +45,10 @@ class Unfavorite(View):
@method_decorator(login_required, name="dispatch")
class Boost(View):
""" boost a status """
"""boost a status"""
def post(self, request, status_id):
""" boost a status """
"""boost a status"""
status = models.Status.objects.get(id=status_id)
# is it boostable?
if not status.boostable:
@ -70,10 +70,10 @@ class Boost(View):
@method_decorator(login_required, name="dispatch")
class Unboost(View):
""" boost a status """
"""boost a status"""
def post(self, request, status_id):
""" boost a status """
"""boost a status"""
status = models.Status.objects.get(id=status_id)
boost = models.Boost.objects.filter(
boosted_status=status, user=request.user

22
bookwyrm/views/invite.py
View File

@ -26,10 +26,10 @@ from . import helpers
name="dispatch",
)
class ManageInvites(View):
""" create invites """
"""create invites"""
def get(self, request):
""" invite management page """
"""invite management page"""
paginated = Paginator(
models.SiteInvite.objects.filter(user=request.user).order_by(
"-created_date"
@ -44,7 +44,7 @@ class ManageInvites(View):
return TemplateResponse(request, "settings/manage_invites.html", data)
def post(self, request):
""" creates an invite database entry """
"""creates an invite database entry"""
form = forms.CreateInviteForm(request.POST)
if not form.is_valid():
return HttpResponseBadRequest("ERRORS : %s" % (form.errors,))
@ -64,10 +64,10 @@ class ManageInvites(View):
class Invite(View):
""" use an invite to register """
"""use an invite to register"""
def get(self, request, code):
""" endpoint for using an invites """
"""endpoint for using an invites"""
if request.user.is_authenticated:
return redirect("/")
invite = get_object_or_404(models.SiteInvite, code=code)
@ -83,10 +83,10 @@ class Invite(View):
class ManageInviteRequests(View):
""" grant invites like the benevolent lord you are """
"""grant invites like the benevolent lord you are"""
def get(self, request):
""" view a list of requests """
"""view a list of requests"""
ignored = request.GET.get("ignored", False)
sort = request.GET.get("sort")
sort_fields = [
@ -132,7 +132,7 @@ class ManageInviteRequests(View):
return TemplateResponse(request, "settings/manage_invite_requests.html", data)
def post(self, request):
""" send out an invite """
"""send out an invite"""
invite_request = get_object_or_404(
models.InviteRequest, id=request.POST.get("invite-request")
)
@ -152,10 +152,10 @@ class ManageInviteRequests(View):
class InviteRequest(View):
""" prospective users sign up here """
"""prospective users sign up here"""
def post(self, request):
""" create a request """
"""create a request"""
form = forms.InviteRequestForm(request.POST)
received = False
if form.is_valid():
@ -172,7 +172,7 @@ class InviteRequest(View):
@require_POST
def ignore_invite_request(request):
""" hide an invite request """
"""hide an invite request"""
invite_request = get_object_or_404(
models.InviteRequest, id=request.POST.get("invite-request")
)

4
bookwyrm/views/isbn.py
View File

@ -13,10 +13,10 @@ from .helpers import is_api_request
# pylint: disable= no-self-use
class Isbn(View):
""" search a book by isbn """
"""search a book by isbn"""
def get(self, request, isbn):
""" info about a book """
"""info about a book"""
book_results = connector_manager.isbn_local_search(isbn)
if is_api_request(request):

12
bookwyrm/views/landing.py
View File

@ -9,18 +9,18 @@ from . import helpers
# pylint: disable= no-self-use
class About(View):
""" create invites """
"""create invites"""
def get(self, request):
""" more information about the instance """
"""more information about the instance"""
return TemplateResponse(request, "discover/about.html")
class Home(View):
""" discover page or home feed depending on auth """
"""discover page or home feed depending on auth"""
def get(self, request):
""" this is the same as the feed on the home tab """
"""this is the same as the feed on the home tab"""
if request.user.is_authenticated:
feed_view = Feed.as_view()
return feed_view(request, "home")
@ -29,10 +29,10 @@ class Home(View):
class Discover(View):
""" preview of recently reviewed books """
"""preview of recently reviewed books"""
def get(self, request):
""" tiled book activity page """
"""tiled book activity page"""
data = {
"register_form": forms.RegisterForm(),
"request_form": forms.InviteRequestForm(),

32
bookwyrm/views/list.py
View File

@ -22,10 +22,10 @@ from .helpers import get_user_from_username
# pylint: disable=no-self-use
class Lists(View):
""" book list page """
"""book list page"""
def get(self, request):
""" display a book list """
"""display a book list"""
# hide lists with no approved books
lists = (
models.List.objects.annotate(
@ -51,7 +51,7 @@ class Lists(View):
@method_decorator(login_required, name="dispatch")
# pylint: disable=unused-argument
def post(self, request):
""" create a book_list """
"""create a book_list"""
form = forms.ListForm(request.POST)
if not form.is_valid():
return redirect("lists")
@ -61,10 +61,10 @@ class Lists(View):
class UserLists(View):
""" a user's book list page """
"""a user's book list page"""
def get(self, request, username):
""" display a book list """
"""display a book list"""
user = get_user_from_username(request.user, username)
lists = models.List.objects.filter(user=user)
lists = privacy_filter(request.user, lists)
@ -81,10 +81,10 @@ class UserLists(View):
class List(View):
""" book list page """
"""book list page"""
def get(self, request, list_id):
""" display a book list """
"""display a book list"""
book_list = get_object_or_404(models.List, id=list_id)
if not book_list.visible_to_user(request.user):
return HttpResponseNotFound()
@ -166,7 +166,7 @@ class List(View):
@method_decorator(login_required, name="dispatch")
# pylint: disable=unused-argument
def post(self, request, list_id):
""" edit a list """
"""edit a list"""
book_list = get_object_or_404(models.List, id=list_id)
form = forms.ListForm(request.POST, instance=book_list)
if not form.is_valid():
@ -176,11 +176,11 @@ class List(View):
class Curate(View):
""" approve or discard list suggestsions """
"""approve or discard list suggestsions"""
@method_decorator(login_required, name="dispatch")
def get(self, request, list_id):
""" display a pending list """
"""display a pending list"""
book_list = get_object_or_404(models.List, id=list_id)
if not book_list.user == request.user:
# only the creater can curate the list
@ -196,7 +196,7 @@ class Curate(View):
@method_decorator(login_required, name="dispatch")
# pylint: disable=unused-argument
def post(self, request, list_id):
""" edit a book_list """
"""edit a book_list"""
book_list = get_object_or_404(models.List, id=list_id)
suggestion = get_object_or_404(models.ListItem, id=request.POST.get("item"))
approved = request.POST.get("approved") == "true"
@ -222,7 +222,7 @@ class Curate(View):
@require_POST
def add_book(request):
""" put a book on a list """
"""put a book on a list"""
book_list = get_object_or_404(models.List, id=request.POST.get("list"))
if not book_list.visible_to_user(request.user):
return HttpResponseNotFound()
@ -268,7 +268,7 @@ def add_book(request):
@require_POST
def remove_book(request, list_id):
""" remove a book from a list """
"""remove a book from a list"""
with transaction.atomic():
book_list = get_object_or_404(models.List, id=list_id)
item = get_object_or_404(models.ListItem, id=request.POST.get("item"))
@ -336,7 +336,7 @@ def set_book_position(request, list_item_id):
def increment_order_in_reverse(
book_list_id: int, start: int, end: Optional[int] = None
):
""" increase the order nu,ber for every item in a list """
"""increase the order nu,ber for every item in a list"""
try:
book_list = models.List.objects.get(id=book_list_id)
except models.List.DoesNotExist:
@ -352,7 +352,7 @@ def increment_order_in_reverse(
@transaction.atomic
def decrement_order(book_list_id, start, end):
""" decrement the order value for every item in a list """
"""decrement the order value for every item in a list"""
try:
book_list = models.List.objects.get(id=book_list_id)
except models.List.DoesNotExist:
@ -367,7 +367,7 @@ def decrement_order(book_list_id, start, end):
@transaction.atomic
def normalize_book_list_ordering(book_list_id, start=0, add_offset=0):
""" gives each book in a list the proper sequential order number """
"""gives each book in a list the proper sequential order number"""
try:
book_list = models.List.objects.get(id=book_list_id)
except models.List.DoesNotExist:

6
bookwyrm/views/notifications.py
View File

@ -9,10 +9,10 @@ from django.views import View
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class Notifications(View):
""" notifications view """
"""notifications view"""
def get(self, request):
""" people are interacting with you, get hyped """
"""people are interacting with you, get hyped"""
notifications = request.user.notification_set.all().order_by("-created_date")
unread = [n.id for n in notifications.filter(read=False)]
data = {
@ -23,6 +23,6 @@ class Notifications(View):
return TemplateResponse(request, "notifications.html", data)
def post(self, request):
""" permanently delete notification for user """
"""permanently delete notification for user"""
request.user.notification_set.filter(read=True).delete()
return redirect("/notifications")

4
bookwyrm/views/outbox.py
View File

@ -9,10 +9,10 @@ from .helpers import is_bookwyrm_request
# pylint: disable= no-self-use
class Outbox(View):
""" outbox """
"""outbox"""
def get(self, request, username):
""" outbox for the requested user """
"""outbox for the requested user"""
user = get_object_or_404(models.User, localname=username)
filter_type = request.GET.get("type")
if filter_type not in models.status_models:

18
bookwyrm/views/password.py
View File

@ -14,17 +14,17 @@ from bookwyrm.emailing import password_reset_email
# pylint: disable= no-self-use
class PasswordResetRequest(View):
""" forgot password flow """
"""forgot password flow"""
def get(self, request):
""" password reset page """
"""password reset page"""
return TemplateResponse(
request,
"password_reset_request.html",
)
def post(self, request):
""" create a password reset token """
"""create a password reset token"""
email = request.POST.get("email")
try:
user = models.User.objects.get(email=email)
@ -43,10 +43,10 @@ class PasswordResetRequest(View):
class PasswordReset(View):
""" set new password """
"""set new password"""
def get(self, request, code):
""" endpoint for sending invites """
"""endpoint for sending invites"""
if request.user.is_authenticated:
return redirect("/")
try:
@ -59,7 +59,7 @@ class PasswordReset(View):
return TemplateResponse(request, "password_reset.html", {"code": code})
def post(self, request, code):
""" allow a user to change their password through an emailed token """
"""allow a user to change their password through an emailed token"""
try:
reset_code = models.PasswordReset.objects.get(code=code)
except models.PasswordReset.DoesNotExist:
@ -84,15 +84,15 @@ class PasswordReset(View):
@method_decorator(login_required, name="dispatch")
class ChangePassword(View):
""" change password as logged in user """
"""change password as logged in user"""
def get(self, request):
""" change password page """
"""change password page"""
data = {"user": request.user}
return TemplateResponse(request, "preferences/change_password.html", data)
def post(self, request):
""" allow a user to change their password """
"""allow a user to change their password"""
new_password = request.POST.get("password")
confirm_password = request.POST.get("confirm-password")

16
bookwyrm/views/reading.py
View File

@ -18,7 +18,7 @@ from .shelf import handle_unshelve
@login_required
@require_POST
def start_reading(request, book_id):
""" begin reading a book """
"""begin reading a book"""
book = get_edition(book_id)
reading_shelf = models.Shelf.objects.filter(
identifier=models.Shelf.READING, user=request.user
@ -60,7 +60,7 @@ def start_reading(request, book_id):
@login_required
@require_POST
def finish_reading(request, book_id):
""" a user completed a book, yay """
"""a user completed a book, yay"""
book = get_edition(book_id)
finished_read_shelf = models.Shelf.objects.filter(
identifier=models.Shelf.READ_FINISHED, user=request.user
@ -101,7 +101,7 @@ def finish_reading(request, book_id):
@login_required
@require_POST
def edit_readthrough(request):
""" can't use the form because the dates are too finnicky """
"""can't use the form because the dates are too finnicky"""
readthrough = update_readthrough(request, create=False)
if not readthrough:
return HttpResponseNotFound()
@ -121,7 +121,7 @@ def edit_readthrough(request):
@login_required
@require_POST
def delete_readthrough(request):
""" remove a readthrough """
"""remove a readthrough"""
readthrough = get_object_or_404(models.ReadThrough, id=request.POST.get("id"))
# don't let people edit other people's data
@ -135,7 +135,7 @@ def delete_readthrough(request):
@login_required
@require_POST
def create_readthrough(request):
""" can't use the form because the dates are too finnicky """
"""can't use the form because the dates are too finnicky"""
book = get_object_or_404(models.Edition, id=request.POST.get("book"))
readthrough = update_readthrough(request, create=True, book=book)
if not readthrough:
@ -145,14 +145,14 @@ def create_readthrough(request):
def load_date_in_user_tz_as_utc(date_str: str, user: models.User) -> datetime:
""" ensures that data is stored consistently in the UTC timezone """
"""ensures that data is stored consistently in the UTC timezone"""
user_tz = dateutil.tz.gettz(user.preferred_timezone)
start_date = dateutil.parser.parse(date_str, ignoretz=True)
return start_date.replace(tzinfo=user_tz).astimezone(dateutil.tz.UTC)
def update_readthrough(request, book=None, create=True):
""" updates but does not save dates on a readthrough """
"""updates but does not save dates on a readthrough"""
try:
read_id = request.POST.get("id")
if not read_id:
@ -209,7 +209,7 @@ def update_readthrough(request, book=None, create=True):
@login_required
@require_POST
def delete_progressupdate(request):
""" remove a progress update """
"""remove a progress update"""
update = get_object_or_404(models.ProgressUpdate, id=request.POST.get("id"))
# don't let people edit other people's data

16
bookwyrm/views/reports.py
View File

@ -20,10 +20,10 @@ from bookwyrm import forms, models
name="dispatch",
)
class Reports(View):
""" list of reports """
"""list of reports"""
def get(self, request):
""" view current reports """
"""view current reports"""
filters = {}
resolved = request.GET.get("resolved") == "true"
@ -52,17 +52,17 @@ class Reports(View):
name="dispatch",
)
class Report(View):
""" view a specific report """
"""view a specific report"""
def get(self, request, report_id):
""" load a report """
"""load a report"""
data = {
"report": get_object_or_404(models.Report, id=report_id),
}
return TemplateResponse(request, "moderation/report.html", data)
def post(self, request, report_id):
""" comment on a report """
"""comment on a report"""
report = get_object_or_404(models.Report, id=report_id)
models.ReportComment.objects.create(
user=request.user,
@ -75,7 +75,7 @@ class Report(View):
@login_required
@permission_required("bookwyrm_moderate_user")
def suspend_user(_, user_id):
""" mark an account as inactive """
"""mark an account as inactive"""
user = get_object_or_404(models.User, id=user_id)
user.is_active = not user.is_active
# this isn't a full deletion, so we don't want to tell the world
@ -86,7 +86,7 @@ def suspend_user(_, user_id):
@login_required
@permission_required("bookwyrm_moderate_post")
def resolve_report(_, report_id):
""" mark a report as (un)resolved """
"""mark a report as (un)resolved"""
report = get_object_or_404(models.Report, id=report_id)
report.resolved = not report.resolved
report.save()
@ -98,7 +98,7 @@ def resolve_report(_, report_id):
@login_required
@require_POST
def make_report(request):
""" a user reports something """
"""a user reports something"""
form = forms.ReportForm(request.POST)
if not form.is_valid():
raise ValueError(form.errors)

12
bookwyrm/views/rss_feed.py
View File

@ -5,25 +5,25 @@ from .helpers import get_user_from_username, privacy_filter
# pylint: disable=no-self-use, unused-argument
class RssFeed(Feed):
""" serialize user's posts in rss feed """
"""serialize user's posts in rss feed"""
description_template = "snippets/rss_content.html"
title_template = "snippets/rss_title.html"
def get_object(self, request, username):
""" the user who's posts get serialized """
"""the user who's posts get serialized"""
return get_user_from_username(request.user, username)
def link(self, obj):
""" link to the user's profile """
"""link to the user's profile"""
return obj.local_path
def title(self, obj):
""" title of the rss feed entry """
"""title of the rss feed entry"""
return f"Status updates from {obj.display_name}"
def items(self, obj):
""" the user's activity feed """
"""the user's activity feed"""
return privacy_filter(
obj,
obj.status_set.select_subclasses(),
@ -31,5 +31,5 @@ class RssFeed(Feed):
)
def item_link(self, item):
""" link to the status """
"""link to the status"""
return item.local_path

4
bookwyrm/views/search.py
View File

@ -16,10 +16,10 @@ from .helpers import handle_remote_webfinger
# pylint: disable= no-self-use
class Search(View):
""" search users or books """
"""search users or books"""
def get(self, request):
""" that search bar up top """
"""that search bar up top"""
query = request.GET.get("q")
min_confidence = request.GET.get("min_confidence", 0.1)

16
bookwyrm/views/shelf.py
View File

@ -21,10 +21,10 @@ from .helpers import handle_reading_status, privacy_filter
# pylint: disable= no-self-use
class Shelf(View):
""" shelf page """
"""shelf page"""
def get(self, request, username, shelf_identifier=None):
""" display a shelf """
"""display a shelf"""
try:
user = get_user_from_username(request.user, username)
except models.User.DoesNotExist:
@ -73,7 +73,7 @@ class Shelf(View):
@method_decorator(login_required, name="dispatch")
# pylint: disable=unused-argument
def post(self, request, username, shelf_identifier):
""" edit a shelf """
"""edit a shelf"""
try:
shelf = request.user.shelf_set.get(identifier=shelf_identifier)
except models.Shelf.DoesNotExist:
@ -94,7 +94,7 @@ class Shelf(View):
@login_required
@require_POST
def create_shelf(request):
""" user generated shelves """
"""user generated shelves"""
form = forms.ShelfForm(request.POST)
if not form.is_valid():
return redirect(request.headers.get("Referer", "/"))
@ -106,7 +106,7 @@ def create_shelf(request):
@login_required
@require_POST
def delete_shelf(request, shelf_id):
""" user generated shelves """
"""user generated shelves"""
shelf = get_object_or_404(models.Shelf, id=shelf_id)
if request.user != shelf.user or not shelf.editable:
return HttpResponseBadRequest()
@ -118,7 +118,7 @@ def delete_shelf(request, shelf_id):
@login_required
@require_POST
def shelve(request):
""" put a book on a user's shelf """
"""put a book on a user's shelf"""
book = get_edition(request.POST.get("book"))
desired_shelf = models.Shelf.objects.filter(
@ -177,7 +177,7 @@ def shelve(request):
@login_required
@require_POST
def unshelve(request):
""" put a on a user's shelf """
"""put a on a user's shelf"""
book = models.Edition.objects.get(id=request.POST["book"])
current_shelf = models.Shelf.objects.get(id=request.POST["shelf"])
@ -187,6 +187,6 @@ def unshelve(request):
# pylint: disable=unused-argument
def handle_unshelve(book, shelf):
""" unshelve a book """
"""unshelve a book"""
row = models.ShelfBook.objects.get(book=book, shelf=shelf)
row.delete()

8
bookwyrm/views/site.py
View File

@ -15,16 +15,16 @@ from bookwyrm import emailing, forms, models
name="dispatch",
)
class Site(View):
""" manage things like the instance name """
"""manage things like the instance name"""
def get(self, request):
""" edit form """
"""edit form"""
site = models.SiteSettings.objects.get()
data = {"site_form": forms.SiteForm(instance=site)}
return TemplateResponse(request, "settings/site.html", data)
def post(self, request):
""" edit the site settings """
"""edit the site settings"""
site = models.SiteSettings.objects.get()
form = forms.SiteForm(request.POST, request.FILES, instance=site)
if not form.is_valid():
@ -38,7 +38,7 @@ class Site(View):
@login_required
@permission_required("bookwyrm.edit_instance_settings", raise_exception=True)
def email_preview(request):
""" for development, renders and example email template """
"""for development, renders and example email template"""
template = request.GET.get("email")
data = emailing.email_data()
data["subject_path"] = "email/{}/subject.html".format(template)

20
bookwyrm/views/status.py
View File

@ -19,16 +19,16 @@ from .reading import edit_readthrough
# pylint: disable= no-self-use
@method_decorator(login_required, name="dispatch")
class CreateStatus(View):
""" the view for *posting* """
"""the view for *posting*"""
def get(self, request):
""" compose view (used for delete-and-redraft """
"""compose view (used for delete-and-redraft"""
book = get_object_or_404(models.Edition, id=request.GET.get("book"))
data = {"book": book}
return TemplateResponse(request, "compose.html", data)
def post(self, request, status_type):
""" create status of whatever type """
"""create status of whatever type"""
status_type = status_type[0].upper() + status_type[1:]
try:
@ -80,10 +80,10 @@ class CreateStatus(View):
@method_decorator(login_required, name="dispatch")
class DeleteStatus(View):
""" tombstone that bad boy """
"""tombstone that bad boy"""
def post(self, request, status_id):
""" delete and tombstone a status """
"""delete and tombstone a status"""
status = get_object_or_404(models.Status, id=status_id)
# don't let people delete other people's statuses
@ -97,10 +97,10 @@ class DeleteStatus(View):
@method_decorator(login_required, name="dispatch")
class DeleteAndRedraft(View):
""" delete a status but let the user re-create it """
"""delete a status but let the user re-create it"""
def post(self, request, status_id):
""" delete and tombstone a status """
"""delete and tombstone a status"""
status = get_object_or_404(
models.Status.objects.select_subclasses(), id=status_id
)
@ -130,7 +130,7 @@ class DeleteAndRedraft(View):
def find_mentions(content):
""" detect @mentions in raw status content """
"""detect @mentions in raw status content"""
if not content:
return
for match in re.finditer(regex.strict_username, content):
@ -148,7 +148,7 @@ def find_mentions(content):
def format_links(content):
""" detect and format links """
"""detect and format links"""
return re.sub(
r'([^(href=")]|^|\()(https?:\/\/(%s([\w\.\-_\/+&\?=:;,])*))' % regex.domain,
r'\g<1><a href="\g<2>">\g<3></a>',
@ -157,7 +157,7 @@ def format_links(content):
def to_markdown(content):
""" catch links and convert to markdown """
"""catch links and convert to markdown"""
content = markdown(content)
content = format_links(content)
# sanitize resulting html

4
bookwyrm/views/updates.py
View File

@ -7,7 +7,7 @@ from bookwyrm import activitystreams
@login_required
def get_notification_count(request):
""" any notifications waiting? """
"""any notifications waiting?"""
return JsonResponse(
{
"count": request.user.notification_set.filter(read=False).count(),
@ -17,7 +17,7 @@ def get_notification_count(request):
@login_required
def get_unread_status_count(request, stream="home"):
""" any unread statuses for this feed? """
"""any unread statuses for this feed?"""
stream = activitystreams.streams.get(stream)
if not stream:
return JsonResponse({})

22
bookwyrm/views/user.py
View File

@ -22,10 +22,10 @@ from .helpers import is_blocked, privacy_filter
# pylint: disable= no-self-use
class User(View):
""" user profile page """
"""user profile page"""
def get(self, request, username):
""" profile page for a user """
"""profile page for a user"""
try:
user = get_user_from_username(request.user, username)
except models.User.DoesNotExist:
@ -90,10 +90,10 @@ class User(View):
class Followers(View):
""" list of followers view """
"""list of followers view"""
def get(self, request, username):
""" list of followers """
"""list of followers"""
try:
user = get_user_from_username(request.user, username)
except models.User.DoesNotExist:
@ -115,10 +115,10 @@ class Followers(View):
class Following(View):
""" list of following view """
"""list of following view"""
def get(self, request, username):
""" list of followers """
"""list of followers"""
try:
user = get_user_from_username(request.user, username)
except models.User.DoesNotExist:
@ -141,10 +141,10 @@ class Following(View):
@method_decorator(login_required, name="dispatch")
class EditUser(View):
""" edit user view """
"""edit user view"""
def get(self, request):
""" edit profile page for a user """
"""edit profile page for a user"""
data = {
"form": forms.EditUserForm(instance=request.user),
"user": request.user,
@ -152,7 +152,7 @@ class EditUser(View):
return TemplateResponse(request, "preferences/edit_user.html", data)
def post(self, request):
""" les get fancy with images """
"""les get fancy with images"""
form = forms.EditUserForm(request.POST, request.FILES, instance=request.user)
if not form.is_valid():
data = {"form": form, "user": request.user}
@ -164,7 +164,7 @@ class EditUser(View):
def save_user_form(form):
""" special handling for the user form """
"""special handling for the user form"""
user = form.save(commit=False)
if "avatar" in form.files:
@ -181,7 +181,7 @@ def save_user_form(form):
def crop_avatar(image):
""" reduce the size and make an avatar square """
"""reduce the size and make an avatar square"""
target_size = 120
width, height = image.size
thumbnail_scale = (

10
bookwyrm/views/user_admin.py
View File

@ -17,10 +17,10 @@ from bookwyrm.settings import PAGE_LENGTH
name="dispatch",
)
class UserAdminList(View):
""" admin view of users on this server """
"""admin view of users on this server"""
def get(self, request):
""" list of users """
"""list of users"""
filters = {}
server = request.GET.get("server")
if server:
@ -59,16 +59,16 @@ class UserAdminList(View):
name="dispatch",
)
class UserAdmin(View):
""" moderate an individual user """
"""moderate an individual user"""
def get(self, request, user):
""" user view """
"""user view"""
user = get_object_or_404(models.User, id=user)
data = {"user": user, "group_form": forms.UserGroupForm()}
return TemplateResponse(request, "user_admin/user.html", data)
def post(self, request, user):
""" update user group """
"""update user group"""
user = get_object_or_404(models.User, id=user)
form = forms.UserGroupForm(request.POST, instance=user)
if form.is_valid():

12
bookwyrm/views/wellknown.py
View File

@ -13,7 +13,7 @@ from bookwyrm.settings import DOMAIN, VERSION
@require_GET
def webfinger(request):
""" allow other servers to ask about a user """
"""allow other servers to ask about a user"""
resource = request.GET.get("resource")
if not resource or not resource.startswith("acct:"):
return HttpResponseNotFound()
@ -40,7 +40,7 @@ def webfinger(request):
@require_GET
def nodeinfo_pointer(_):
""" direct servers to nodeinfo """
"""direct servers to nodeinfo"""
return JsonResponse(
{
"links": [
@ -55,7 +55,7 @@ def nodeinfo_pointer(_):
@require_GET
def nodeinfo(_):
""" basic info about the server """
"""basic info about the server"""
status_count = models.Status.objects.filter(user__local=True).count()
user_count = models.User.objects.filter(local=True).count()
@ -90,7 +90,7 @@ def nodeinfo(_):
@require_GET
def instance_info(_):
""" let's talk about your cool unique instance """
"""let's talk about your cool unique instance"""
user_count = models.User.objects.filter(local=True).count()
status_count = models.Status.objects.filter(user__local=True).count()
@ -116,12 +116,12 @@ def instance_info(_):
@require_GET
def peers(_):
""" list of federated servers this instance connects with """
"""list of federated servers this instance connects with"""
names = models.FederatedServer.objects.values_list("server_name", flat=True)
return JsonResponse(list(names), safe=False)
@require_GET
def host_meta(request):
""" meta of the host """
"""meta of the host"""
return TemplateResponse(request, "host_meta.xml", {"DOMAIN": DOMAIN})