Add Interactive (#867)

* Add interactive fields to db

* Add interactive to API

* Allow user to upload interactive sessions

* Display interactive project on channel, toggle it

* Add interactive scope

* Check scope before sending Authorized field

* Upload and filter files

* Remove zip of projects every 15 min

* Check for executables

* Remove old projects, cleanup conditions

* Serve interactive project files

* Add sandbox

* Display errors if upload fails

* Use file whitelist

* Add code comments

* Add basic default interactive project

* Fix code quality

* Switch to array from zip files

* Only show itneractive button if its enabled

* Fix code quality

* Delete previous project before validation

---------

Co-authored-by: Luke Strickland <luke@axxim.net>

Author: aMytho

lib/glimesh/api.ex

@@ -21,7 +21,8 @@ defmodule Glimesh.Api do
                 chat: false,
                 streamkey: false,
                 follow: false,
-                stream_info: false
+                stream_info: false,
+                interactive: false
               }
   end
 

lib/glimesh/api/resolvers/channel_resolver.ex

@@ -2,6 +2,7 @@ defmodule Glimesh.Api.ChannelResolver do
   @moduledoc false
   import Ecto.Query
 
+  alias Absinthe.Subscription
   alias Glimesh.Api
   alias Glimesh.ChannelCategories
   alias Glimesh.ChannelLookups
@@ -275,6 +276,53 @@ defmodule Glimesh.Api.ChannelResolver do
     |> Api.connection_from_query_with_count(args)
   end
 
+  # Sends a message over client id
+  def send_interactive_message(_parent, args, %{context: %{access: %{access_type: "app"}}}) do
+    event_name = Map.get(args, :event_name)
+    session = Map.get(args, :session_id)
+    data = Map.get(args, :data)
+
+    Subscription.publish(
+      GlimeshWeb.Endpoint,
+      %{data: data, event_name: event_name, authorized: false},
+      Keyword.put([], :interactive, "streams:interactive:#{session}")
+    )
+
+    {:ok, %{data: data, event_name: event_name, authorized: false}}
+  end
+
+  # Sends a message with an access token
+  def send_interactive_message(_parent, args, %{context: %{access: access}}) do
+    # Get the data from the message
+    event_name = Map.get(args, :event_name)
+    session = Map.get(args, :session_id)
+    data = Map.get(args, :data)
+
+    # Check that it has interactive scope, channel matches sessionID
+    # If so it is an authorized message, if not it isn't
+    with true <- Map.get(access.scopes, :interactive),
+         %Glimesh.Streams.Channel{} = channel <-
+           ChannelLookups.get_channel_for_username(access.user.username),
+         true <- channel.id == session do
+      Subscription.publish(
+        GlimeshWeb.Endpoint,
+        %{data: data, event_name: event_name, authorized: true},
+        Keyword.put([], :interactive, "streams:interactive:#{session}")
+      )
+
+      {:ok, %{data: data, event_name: event_name, authorized: true}}
+    else
+      _ ->
+        Subscription.publish(
+          GlimeshWeb.Endpoint,
+          %{data: data, event_name: event_name, authorized: false},
+          Keyword.put([], :interactive, "streams:interactive:#{session}")
+        )
+
+        {:ok, %{data: data, event_name: event_name, authorized: false}}
+    end
+  end
+
   def get_moderation_logs(args, %{source: channel}) do
     Streams.ChannelModerationLog
     |> where(channel_id: ^channel.id)

lib/glimesh/api/schema/channel_types.ex

@@ -5,6 +5,7 @@ defmodule Glimesh.Api.ChannelTypes do
 
   import Absinthe.Resolution.Helpers
   import_types(Absinthe.Plug.Types)
+  import_types(Glimesh.Api.Schema.Types.Interactive)
 
   alias Glimesh.Api
   alias Glimesh.Api.ChannelResolver
@@ -107,6 +108,15 @@ defmodule Glimesh.Api.ChannelTypes do
       resolve(&ChannelResolver.upload_stream_thumbnail/3)
     end
 
+    @desc "Send a message over the interactive session"
+    field :send_interactive_message, type: :interactive do
+      arg(:session_id, non_null(:integer))
+      arg(:event_name, non_null(:string))
+      arg(:data, non_null(:json), description: "JSON data to send")
+
+      resolve(&ChannelResolver.send_interactive_message/3)
+    end
+
     @desc "Update a channel's stream info"
     field :update_stream_info, type: :channel do
       arg(:channel_id, non_null(:id))
@@ -127,6 +137,16 @@ defmodule Glimesh.Api.ChannelTypes do
         end
       end)
     end
+
+    field :interactive, :interactive do
+      arg(:session, non_null(:integer), description: "The interactive session ID")
+
+      config(fn args, _ ->
+        case Map.get(args, :session) do
+          session -> {:ok, topic: [Streams.get_subscribe_topic(:interactive, session)]}
+        end
+      end)
+    end
   end
 
   @desc "Current channel status"
@@ -135,6 +155,15 @@ defmodule Glimesh.Api.ChannelTypes do
     value(:offline, as: "offline")
   end
 
+  @desc "An interactive packet"
+  object :interactive do
+    field :event_name, :string, description: "The name of the event"
+    field :data, :json, description: "The data sent across the connection"
+    field :authorized, :boolean, description: "Was this an authorized message?"
+    field :inserted_at, non_null(:naive_datetime), description: "Interactive creation date"
+    field :updated_at, non_null(:naive_datetime), description: "Interactive updated date"
+  end
+
   @desc "Categories are the containers for live streaming content."
   object :category do
     field :id, :id, description: "Unique category identifier"

lib/glimesh/api/schema/interactive_types.ex

@@ -0,0 +1,40 @@
+defmodule Glimesh.Api.Schema.Types.Interactive do
+  @moduledoc """
+  The Json scalar type allows arbitrary JSON values to be passed in and out.
+  Requires `{ :jason, "~> 1.1" }` package: https://github.com/michalmuskala/jason
+  We use this to make sure the user is sending valid json in an interactive message
+  """
+  use Absinthe.Schema.Notation
+
+  scalar :json, name: "JSON" do
+    description("""
+    JSON data surrounded by a string.
+    "{
+      \"test\": 123
+    }"
+    """)
+
+    serialize(&encode/1)
+    parse(&decode/1)
+  end
+
+  # Decods the json, returns it if valid. Fails if not
+  @spec decode(Absinthe.Blueprint.Input.String.t()) :: {:ok, term()} | :error
+  @spec decode(Absinthe.Blueprint.Input.Null.t()) :: {:ok, nil}
+  defp decode(%Absinthe.Blueprint.Input.String{value: value}) do
+    case Jason.decode(value) do
+      {:ok, result} -> {:ok, result}
+      _ -> :error
+    end
+  end
+
+  defp decode(%Absinthe.Blueprint.Input.Null{}) do
+    {:ok, nil}
+  end
+
+  defp decode(_) do
+    :error
+  end
+
+  defp encode(value), do: value
+end

lib/glimesh/api/scopes.ex

@@ -18,6 +18,7 @@ defmodule Glimesh.Api.Scopes do
   def authorize(:streamkey, %Access{} = ua, _params), do: scope_check(ua, :streamkey)
   def authorize(:follow, %Access{} = ua, _params), do: scope_check(ua, :follow)
   def authorize(:stream_info, %Access{} = ua, _params), do: scope_check(ua, :stream_info)
+  def authorize(:interactive, %Access{} = ua, _params), do: scope_check(ua, :interactive)
 
   def authorize(:stream_mutations, %Access{is_admin: true}, _params) do
     true

lib/glimesh/oauth/scopes.ex

@@ -11,6 +11,7 @@ defmodule Glimesh.Oauth.Scopes do
       "streamkey" -> gettext("scopestream")
       "follow" -> gettext("scopefollow")
       "stream_info" -> gettext("scopestream_info")
+      "interactive" -> gettext("scopeinteractive")
     end
   end
 end

lib/glimesh/oauth_migration.ex

@@ -70,7 +70,8 @@ defmodule Glimesh.OauthMigration do
       %{label: "Chat", name: "chat", public: true},
       %{label: "Stream Key", name: "streamkey", public: true},
       %{label: "Follow Channel", name: "follow", public: true},
-      %{label: "Update Stream Info", name: "stream_info", public: true}
+      %{label: "Update Stream Info", name: "stream_info", public: true},
+      %{label: "Verify Interactive Messages", name: "interactive", public: true}
     ]
 
     Enum.each(scopes, fn attrs ->

lib/glimesh/streams.ex

@@ -29,6 +29,7 @@ defmodule Glimesh.Streams do
   def get_subscribe_topic(:viewers), do: "streams:viewers"
   def get_subscribe_topic(:raid), do: "streams:raid"
   def get_subscribe_topic(:channel, channel_id), do: "streams:channel:#{channel_id}"
+  def get_subscribe_topic(:interactive, channel_id), do: "streams:interactive:#{channel_id}"
   def get_subscribe_topic(:stream, stream_id), do: "streams:stream:#{stream_id}"
   def get_subscribe_topic(:chat, channel_id), do: "streams:chat:#{channel_id}"
   def get_subscribe_topic(:chatters, channel_id), do: "streams:chatters:#{channel_id}"

lib/glimesh/streams/channel.ex

@@ -46,6 +46,9 @@ defmodule Glimesh.Streams.Channel do
     field :only_followed_can_raid, :boolean, default: false
     field :raid_message, :string, default: "{streamer} is raiding you with {count} viewers!"
 
+    field :interactive_project, {:array, Glimesh.Interactive.Type}
+    field :interactive_enabled, :boolean, default: false
+
     # This is here temporarily as we add additional schema to handle it.
     field :streamloots_url, :string, default: nil
 
@@ -118,6 +121,7 @@ defmodule Glimesh.Streams.Channel do
       :require_confirmed_email,
       :minimum_account_age,
       :allow_hosting,
+      :interactive_enabled,
       :backend,
       :allow_raiding,
       :only_followed_can_raid,
@@ -133,7 +137,7 @@ defmodule Glimesh.Streams.Channel do
     )
     |> validate_inclusion(:backend, ["ftl", "whep"])
     |> set_chat_rules_content_html()
-    |> cast_attachments(attrs, [:poster, :chat_bg])
+    |> cast_attachments(attrs, [:poster, :chat_bg, :interactive_project])
     |> maybe_put_tags(:tags, attrs)
     |> maybe_put_subcategory(:subcategory, attrs)
     |> unique_constraint([:user_id])

lib/glimesh_web/controllers/interactive_controller.ex

@@ -0,0 +1,32 @@
+defmodule GlimeshWeb.InteractiveController do
+  use GlimeshWeb, :controller
+  alias Glimesh.ChannelLookups
+  alias Glimesh.Interactive
+
+  def index(conn, %{"username" => username}) do
+    # Get the channel, serve the project
+    channel = ChannelLookups.get_channel_for_username(username, true)
+
+    if channel.interactive_project do
+      # Serve the project
+      conn |> redirect(to: Interactive.url({"index.html", channel}, :request))
+    else
+      not_found(conn, nil)
+    end
+  end
+
+  def not_found(conn, _) do
+    # The project doesn't exist :(
+    conn
+    |> put_resp_header("Content-Type", "text/html")
+    |> send_file(200, "./priv/static/interactive/index.html")
+  end
+
+  def asset(conn, %{"id" => id, "asset" => asset}) do
+    # Get the channel
+    channel = ChannelLookups.get_channel_for_user_id(id, true)
+
+    # Serve the project asset
+    conn |> redirect(to: Interactive.url({Enum.join(asset, "/"), channel}, :request))
+  end
+end