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()