def test_template_response(self, rf):
req = rf.get("/")
resp = TurboStream("my-form").append.template("simple.html",
{}).response(req)
assert resp.status_code == 200
assert "is_turbo_stream" in resp.context_data
content = resp.render().content
assert b"my content" in content
assert b'<turbo-stream action="append" target="my-form"' in content
def accept_cookies(request):
response = TurboStream("accept-cookies").remove.response()
response.set_cookie(
"accept-cookies",
value="true",
expires=timezone.now() + datetime.timedelta(days=30),
samesite="Lax",
)
return response
def remove_from_queue(request: HttpRequest, episode_id: int) -> HttpResponse:
episode = get_episode_or_404(episode_id)
items = QueueItem.objects.filter(user=request.user)
items.filter(episode=episode).delete()
if "remove" in request.POST:
if items.count() == 0:
return TurboStream("queue").replace.response(
"Your Play Queue is now empty")
return TurboStream(episode.get_queue_dom_id()).remove.response()
return render_queue_response(request, episode, False)
def remove_history(request: HttpRequest, episode_id: int) -> HttpResponse:
episode = get_episode_or_404(episode_id)
logs = AudioLog.objects.filter(user=request.user)
logs.filter(episode=episode).delete()
if logs.count() == 0:
return TurboStream("history").replace.response(
"Your History is now empty.")
return TurboStream(episode.get_history_dom_id()).remove.response()
def remove_favorite(request: HttpRequest, episode_id: int) -> HttpResponse:
episode = get_episode_or_404(episode_id)
favorites = Favorite.objects.filter(user=request.user)
favorites.filter(episode=episode).delete()
if "remove" in request.POST:
if favorites.count() == 0:
return TurboStream("favorites").replace.response(
"There are no more episodes in your Favorites.")
return TurboStream(episode.get_favorite_dom_id()).remove.response()
return render_favorite_response(request, episode, False)
def activity_delete_view(request, pk, model):
obj = get_activity_or_404(request,
model,
pk,
permission="activities.delete_activity")
if request.user != obj.owner:
obj.soft_delete()
obj.notify_on_delete(request.user)
else:
obj.delete()
messages.success(
request,
model_translation_string(_("%(model)s has been deleted"),
obj,
capitalize=True),
)
target = request.POST.get("target", None)
if target:
return TurboStream(target).remove.response()
return redirect(settings.HOME_PAGE_URL
if obj.deleted or obj.published else "activities:private")
def create_comment_view(request, pk, model):
obj = get_object_or_404(
get_activity_queryset(request, model),
pk=pk,
)
has_perm_or_403(request.user, "activities.create_comment", obj)
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.content_object = obj
comment.community = request.community
comment.owner = request.user
comment.save()
comment.notify_on_create()
messages.success(request, _("Your comment has been posted"))
return redirect(obj)
return (TurboStream("comment-form").replace.template(
"activities/includes/comment_form.html", {
"form": form,
"object": obj
}).response(request))
def render_subscribe_response(request: HttpRequest, podcast: Podcast,
is_subscribed: bool) -> HttpResponse:
return (TurboStream(podcast.get_subscribe_toggle_id()).replace.template(
"podcasts/_subscribe.html",
{
"podcast": podcast,
"is_subscribed": is_subscribed
},
).response(request))
def render_queue_response(request: HttpRequest, episode: Episode,
is_queued: bool) -> List[str]:
return (TurboStream(episode.get_queue_toggle_id()).replace.template(
"episodes/queue/_toggle.html",
{
"episode": episode,
"is_queued": is_queued,
},
).response(request))
def render_favorite_response(request: HttpRequest, episode: Episode,
is_favorited: bool) -> HttpResponse:
return (TurboStream(episode.get_favorite_toggle_id()).replace.template(
"episodes/favorites/_toggle.html",
{
"episode": episode,
"is_favorited": is_favorited
},
).response(request))
def message_mark_read_view(request, pk):
message = get_object_or_404(
Message.objects.for_community(request.community).for_recipient(
request.user).unread(),
pk=pk,
)
message.mark_read()
return TurboStream(f"message-{message.id}-mark-read").remove.response()
def render_player_toggle(request: HttpRequest, episode: Episode,
is_playing: bool) -> str:
return (TurboStream(episode.get_player_toggle_id()).replace.template(
"episodes/player/_toggle.html",
{
"episode": episode,
"is_episode_playing": is_playing,
},
request=request,
).render())
def notification_mark_read_view(request, pk):
obj = get_object_or_404(get_unread_notification_queryset(request), pk=pk)
obj.is_read = True
obj.save()
notification_read.send(
sender=obj.content_object.__class__,
instance=obj.content_object,
)
target = (f"notification-{obj.id}" if Notification.objects.filter(
recipient=request.user, is_read=False).exists() else "notifications")
return TurboStream(target).remove.response()
def render_player_start_response(request: HttpRequest,
episode: Episode,
streams: List[str],
current_time: int = 0) -> HttpResponse:
# remove from queue
QueueItem.objects.filter(user=request.user, episode=episode).delete()
episode.log_activity(request.user, current_time=current_time)
request.player.start(episode, current_time)
response = TurboStreamResponse(streams + [
render_player_toggle(request, episode, True),
TurboStream("player-container").update.template(
"episodes/player/_player.html",
{
"episode": episode
},
request=request,
).render(),
TurboStream("queue").replace.template(
"episodes/queue/_episode_list.html",
{
"queue_items": get_queue_items(request)
},
request=request,
).render(),
])
response["X-Player"] = json.dumps({
"action": "start",
"mediaUrl": episode.media_url,
"currentTime": current_time,
"metadata": episode.get_media_metadata(),
})
return response
def message_delete_view(request, pk):
message = get_object_or_404(
Message.objects.for_community(
request.community).for_sender_or_recipient(request.user),
pk=pk,
)
message.soft_delete(request.user)
messages.info(request, _("Message has been deleted"))
if "redirect" in request.POST:
return redirect("private_messages:inbox" if message.recipient ==
request.user else "private_messages:outbox")
return TurboStream(f"message-{pk}").remove.response()
def message_recipient_create_view(request, username):
has_perm_or_403(request.user, "private_messages.create_message",
request.community)
recipient = get_object_or_404(
get_user_model().objects.exclude(pk=request.user.id).for_community(
request.community).exclude_blocking(request.user),
username__iexact=username,
)
stream = TurboStream("modal")
if request.method == "POST":
form = MessageForm(request.POST)
if form.is_valid():
message = form.save(commit=False)
message.community = request.community
message.sender = request.user
message.recipient = recipient
message.save()
message.notify_on_send()
messages.success(
request,
_("Your message has been sent to %(recipient)s") %
{"recipient": recipient.get_display_name()},
)
return stream.update.response()
else:
form = MessageForm()
form["message"].label = _("Send message to %(recipient)s" %
{"recipient": recipient.get_display_name()})
return stream.update.template(
"private_messages/includes/modal_message_form.html",
{
"form": form,
"recipient": recipient
},
).response(request)
def test_render(self):
s = TurboStream("my-form").append.render("OK")
assert (
s ==
'<turbo-stream action="append" target="my-form"><template>OK</template></turbo-stream>'
)
def render_player_stop_response(streams: List[str]) -> HttpResponse:
response = TurboStreamResponse(streams + [
TurboStream("player-controls").remove.render(),
])
response["X-Player"] = json.dumps({"action": "stop"})
return response
def test_response(self):
resp = TurboStream("my-form").append.response("OK")
assert resp.status_code == 200
assert b"OK" in resp.content
assert b'<turbo-stream action="append" target="my-form"' in resp.content
def test_template(self):
s = TurboStream("my-form").append.template("simple.html", {}).render()
assert "my content" in s
assert '<turbo-stream action="append" target="my-form">' in s
def render_close_modal() -> str:
return TurboStream("modal").update.render()
def dismiss_notice_view(request, notice):
request.user.dismiss_notice(notice)
return TurboStream(f"notice-{notice}").remove.response()
def notification_delete_view(request, pk):
obj = get_object_or_404(get_notification_queryset(request), pk=pk)
target = f"notification-{obj.id}"
obj.delete()
return TurboStream(target).remove.response()
