Integration of Chatkit

README.md

@@ -25,6 +25,7 @@ $ vim config/secrets.exs
     `luminus_redirect_url` are required for the application to properly authenticate with LumiNUS.
   - A valid `cs1101s_repository`, `cs1101s_rsa_key` is required for the application to 
     run with the `--updater` flag. Otherwise, the default values will suffice.
+  - A valid `instance_id`, `key_id` and `key_secret` are required to use ChatKit's services. Otherwise, the placeholder values can be left as they are.
 
 2. Install Elixir dependencies
 ```bash
@@ -66,6 +67,14 @@ We recommend setting up nginx to handle preflight checks using the following
 
 If you do this, do remember to point cadet-frontend to port `4001` instead of `4000`
 
+### Chatkit
+
+The chat functionality replacing the previous comment field found in assignments is built on top of Chatkit. Its documentation can be found [here](https://pusher.com/docs/chatkit).
+
+If you are using Chatkit, obtain your instance ID, key ID and secret key from your account, and set them in. Instructions to that are found [here](https://pusher.com/docs/chatkit/authentication#chatkit-key-and-instance-id).
+
+Internet connection is required for usage.
+
 
 ### Style Guide
 

config/config.exs

@@ -16,6 +16,8 @@ config :cadet, Cadet.Jobs.Scheduler,
   overlap: false,
   jobs: [
     {"@hourly", {Mix.Tasks.Cadet.Assessments.Update, :run, [nil]}},
+    # Create Chatkit rooms if they do not already exist at 1am
+    {"0 1 * * *", {Mix.Tasks.Cadet.ChatkitRoom, :run, [nil]}},
     # Grade previous day's submission at 3am
     {"0 3 * * *", {Cadet.Autograder.GradingJob, :grade_all_due_yesterday, []}}
   ]

config/secrets.exs.example

@@ -13,6 +13,11 @@ config :cadet,
   ],
   autograder: [
     lambda_name: "autograderLambdaName"
+  ],
+  chat: [
+    instance_id: "CHATKIT_INSTANCE_ID",
+    key_id: "CHATKIT_KEY_ID",
+    key_secret: "CHATKIT_KEY_SECRET"
   ]
 
 config :sentry,

lib/cadet/assessments/answer.ex

@@ -30,7 +30,7 @@ defmodule Cadet.Assessments.Answer do
   end
 
   @required_fields ~w(answer submission_id question_id type)a
-  @optional_fields ~w(xp xp_adjustment grade comment adjustment grader_id)a
+  @optional_fields ~w(xp xp_adjustment grade adjustment grader_id)a
 
   def changeset(answer, params) do
     answer
@@ -49,7 +49,7 @@ defmodule Cadet.Assessments.Answer do
     answer
     |> cast(
       params,
-      ~w(grader_id xp xp_adjustment grade adjustment autograding_results autograding_status comment)a
+      ~w(grader_id xp xp_adjustment grade adjustment autograding_results autograding_status)a
     )
     |> add_belongs_to_id_from_model(:grader, params)
     |> foreign_key_constraint(:grader_id)
@@ -63,6 +63,12 @@ defmodule Cadet.Assessments.Answer do
     |> validate_xp_grade_adjustment_total()
   end
 
+  # TODO: add some validation
+  @spec comment_changeset(%__MODULE__{} | Ecto.Changeset.t(), map()) :: Ecto.Changeset.t()
+  def comment_changeset(answer, params) do
+    cast(answer, params, ~w(comment)a)
+  end
+
   @spec validate_xp_grade_adjustment_total(Ecto.Changeset.t()) :: Ecto.Changeset.t()
   defp validate_xp_grade_adjustment_total(changeset) do
     answer = apply_changes(changeset)

lib/cadet/assessments/assessments.ex

@@ -10,6 +10,7 @@ defmodule Cadet.Assessments do
   alias Cadet.Accounts.User
   alias Cadet.Assessments.{Answer, Assessment, Query, Question, Submission}
   alias Cadet.Autograder.GradingJob
+  alias Cadet.Chat.Room
   alias Ecto.Multi
 
   @xp_early_submission_max_bonus 100
@@ -363,8 +364,13 @@ defmodule Cadet.Assessments do
            {:is_open?, true} <- is_open?(question.assessment),
            {:ok, submission} <- find_or_create_submission(user, question.assessment),
            {:status, true} <- {:status, submission.status != :submitted},
-           {:ok, _} <- insert_or_update_answer(submission, question, raw_answer) do
+           {:ok, answer} <- insert_or_update_answer(submission, question, raw_answer) do
         update_submission_status(submission, question.assessment)
+
+        if answer.comment == nil do
+          Room.create_rooms(submission, answer, user)
+        end
+
         {:ok, nil}
       else
         {:question_found?, false} -> {:error, {:not_found, "Question not found"}}
@@ -468,7 +474,6 @@ defmodule Cadet.Assessments do
                    xp_adjustment: 0,
                    autograding_status: :none,
                    autograding_results: [],
-                   comment: nil,
                    grader_id: nil
                  })
                  |> Repo.update()}

lib/cadet/chat/room.ex

@@ -0,0 +1,91 @@
+defmodule Cadet.Chat.Room do
+  @moduledoc """
+  Contains logic pertaining to chatroom creation to supplement ChatKit, an external service engaged for Source Academy.
+  ChatKit's API can be found here: https://pusher.com/docs/chatkit
+  """
+
+  require Logger
+
+  import Ecto.Query
+
+  alias Cadet.Repo
+  alias Cadet.Assessments.{Answer, Submission}
+  alias Cadet.Accounts.User
+  alias Cadet.Chat.Token
+
+  @instance_id (if Mix.env() != :test do
+                  :cadet |> Application.fetch_env!(:chat) |> Keyword.get(:instance_id)
+                else
+                  "instance_id"
+                end)
+
+  @doc """
+  Creates a chatroom for every answer, and updates db with the chatroom id.
+  """
+  def create_rooms(
+        %Submission{
+          assessment_id: assessment_id
+        },
+        answer = %Answer{question_id: question_id, comment: comment},
+        user
+      ) do
+    with true <- comment == nil,
+         {:ok, %{"id" => room_id}} <- create_room(assessment_id, question_id, user) do
+      answer
+      |> Answer.comment_changeset(%{
+        comment: room_id
+      })
+      |> Repo.update()
+    end
+  end
+
+  defp create_room(
+         assessment_id,
+         question_id,
+         %User{
+           id: student_id,
+           nusnet_id: nusnet_id
+         }
+       ) do
+    HTTPoison.start()
+
+    url = "https://us1.pusherplatform.io/services/chatkit/v4/#{@instance_id}/rooms"
+
+    {:ok, token} = Token.get_superuser_token()
+    headers = [Authorization: "Bearer #{token}"]
+
+    body =
+      Poison.encode!(%{
+        "name" => "#{nusnet_id}_#{assessment_id}_Q#{question_id}",
+        "private" => true,
+        "user_ids" => get_staff_admin_user_ids() ++ [to_string(student_id)]
+      })
+
+    case HTTPoison.post(url, body, headers) do
+      {:ok, %HTTPoison.Response{body: body, status_code: 201}} ->
+        Poison.decode(body)
+
+      {:ok, %HTTPoison.Response{body: body, status_code: status_code}} ->
+        response_body = Poison.decode!(body)
+
+        Logger.error(
+          "Room creation failed: #{response_body["error"]}, " <>
+            "#{response_body["error_description"]} (status code #{status_code}) " <>
+            "[user_id: #{student_id}, assessment_id: #{assessment_id}, question_id: #{question_id}]"
+        )
+
+        {:error, nil}
+
+      {:error, %HTTPoison.Error{reason: error}} ->
+        Logger.error("error: #{inspect(error, pretty: true)}")
+        {:error, nil}
+    end
+  end
+
+  defp get_staff_admin_user_ids do
+    User
+    |> where([u], u.role in ^[:staff, :admin])
+    |> Repo.all()
+    |> Enum.map(fn user -> to_string(user.id) end)
+  end
+end

lib/cadet/chat/token.ex

@@ -0,0 +1,50 @@
+defmodule Cadet.Chat.Token do
+  @moduledoc """
+  Contains logic pertaining to the generation of tokens to supplement the usage of ChatKit, an external service engaged for Source Academy.
+  ChatKit's API can be found here: https://pusher.com/docs/chatkit
+  """
+
+  alias Cadet.Accounts.User
+
+  @instance_id :cadet |> Application.fetch_env!(:chat) |> Keyword.get(:instance_id)
+  @key_id :cadet |> Application.fetch_env!(:chat) |> Keyword.get(:key_id)
+  @key_secret :cadet |> Application.fetch_env!(:chat) |> Keyword.get(:key_secret)
+  @token_ttl 86_400
+  @admin_user_id "admin"
+
+  @doc """
+  Generates user token for connection to ChatKit's ChatManager.
+  Returns {:ok, token, ttl}.
+  """
+  def get_user_token(%User{id: user_id}) do
+    {:ok, token} = get_token(to_string(user_id))
+    {:ok, token, @token_ttl}
+  end
+
+  @doc """
+  Generates a token for user with admin rights to enable superuser permissions.
+  Returns {:ok, token}
+  """
+  def get_superuser_token do
+    get_token(@admin_user_id, true)
+  end
+
+  defp get_token(user_id, su \\ false) when is_binary(user_id) do
+    curr_time_epoch = DateTime.to_unix(DateTime.utc_now())
+
+    payload = %{
+      "instance" => @instance_id,
+      "iss" => "api_keys/#{@key_id}",
+      "exp" => curr_time_epoch + @token_ttl,
+      "iat" => curr_time_epoch,
+      "sub" => user_id,
+      "su" => su
+    }
+
+    # Note: dialyzer says signing only returns {:ok, token}
+    Joken.Signer.sign(
+      payload,
+      Joken.Signer.create("HS256", @key_secret)
+    )
+  end
+end

lib/cadet_web/controllers/chat_controller.ex

@@ -0,0 +1,51 @@
+defmodule CadetWeb.ChatController do
+  @moduledoc """
+  Provides token for connection to ChatKit's server.
+  Refer to ChatKit's API here: https://pusher.com/docs/chatkit
+  """
+
+  use CadetWeb, :controller
+  use PhoenixSwagger
+
+  alias Cadet.Chat.Token
+
+  def index(conn, _) do
+    user = conn.assigns.current_user
+    {:ok, token, ttl} = Token.get_user_token(user)
+
+    render(
+      conn,
+      "index.json",
+      access_token: token,
+      expires_in: ttl
+    )
+  end
+
+  swagger_path :index do
+    post("/chat/token")
+
+    summary("Get the ChatKit bearer token of a user. Token expires in 24 hours.")
+
+    security([%{JWT: []}])
+
+    produces("application/json")
+
+    response(200, "OK", Schema.ref(:TokenInfo))
+  end
+
+  def swagger_definitions do
+    %{
+      TokenInfo:
+        swagger_schema do
+          title("ChatKit Token")
+          description("Token used for connection to ChatKit's server")
+
+          properties do
+            access_token(:string, "Bearer token", required: true)
+
+            expires_in(:string, "TTL of token", required: true)
+          end
+        end
+    }
+  end
+end

lib/cadet_web/router.ex

@@ -39,6 +39,8 @@ defmodule CadetWeb.Router do
     post("/grading/:submissionid/:questionid", GradingController, :update)
 
     get("/user", UserController, :index)
+
+    post("/chat/token", ChatController, :index)
   end
 
   # Other scopes may use custom stacks.

lib/cadet_web/views/chat_view.ex

@@ -0,0 +1,10 @@
+defmodule CadetWeb.ChatView do
+  use CadetWeb, :view
+
+  def render("index.json", %{access_token: token, expires_in: ttl}) do
+    %{
+      access_token: token,
+      expires_in: ttl
+    }
+  end
+end

lib/mix/tasks/chatkit_room.ex

@@ -0,0 +1,34 @@
+defmodule Mix.Tasks.Cadet.ChatkitRoom do
+  @moduledoc """
+    Creates ChatKit rooms for answers with empty comments in the database.
+    Room creation: https://pusher.com/docs/chatkit/reference/api#create-a-room
+    Status codes: https://pusher.com/docs/chatkit/reference/api#response-and-error-codes
+
+    Note:
+    - Task is to run daily
+  """
+  use Mix.Task
+
+  import Ecto.Query
+  import Mix.EctoSQL
+
+  alias Cadet.Repo
+  alias Cadet.Assessments.Submission
+  alias Cadet.Chat.Room
+
+  def run(_args) do
+    ensure_started(Repo, [])
+
+    Submission
+    |> join(:inner, [s], a in assoc(s, :answers))
+    |> join(:inner, [s], u in assoc(s, :student))
+    |> preload([_, a, u], answers: a, student: u)
+    |> where([_, a], is_nil(a.comment))
+    |> Repo.all()
+    |> Enum.each(fn submission ->
+      Enum.each(submission.answers, fn answer ->
+        Room.create_rooms(submission, answer, submission.student)
+      end)
+    end)
+  end
+end