authentication with persistence working

lib/myapp/battle_net/auth.ex

@@ -4,7 +4,8 @@ defmodule MyApp.BattleNet.Auth do
 
   def token_uri, do: "https://us.battle.net/oauth/token"
 
-  def get_token(code) do
+  @spec get_access_token(String.t) :: {:ok, String.t} | {:error, String.t}
+  def get_access_token(code) do
     client_id = Application.get_env(:myapp, :bnet_client_id)
     client_secret = Application.get_env(:myapp, :bnet_client_secret)
     redirect_uri = Application.get_env(:myapp, :bnet_redirect_uri)
@@ -14,28 +15,16 @@ defmodule MyApp.BattleNet.Auth do
     HTTPoison.request(:post, token_uri, get_req_body(code), [], req_options)
     |> parse_body
     |> parse_token
-    |> validate_user
-    |> generate_jwt
   end
 
   defp parse_body({:error, err}), do: {:error, err}
   defp parse_body({:ok, %HTTPoison.Response{body: body}}), do: Poison.decode(body)
 
   defp parse_token({:ok, %{"access_token" => token}}), do: {:ok, token}
-  defp parse_token({:ok, %{"error" => err}}), do: {:error, err}
+  defp parse_token({:ok, %{"error" => error}}), do: {:error, error}
   defp parse_token({:error, err}), do: {:error, "Authentication error"}
 
-  defp validate_user({:error, err}), do: {:error, err}
-  defp validate_user({:ok, token}), do: User.get_user(token)
-
-  defp generate_jwt({:error, err}), do: {:error, err}
-  defp generate_jwt({:ok, user}) do
-    case JWT.get_jwt(user, user) do
-      {:ok, token} -> {:ok, Map.merge(user, %{"token" => token})}
-      {:error, err} -> {:error, err}
-    end
-  end
-
+  @spec get_req_body(String.t) :: tuple
   defp get_req_body(code) do
     redirect_uri = Application.get_env(:myapp, :bnet_redirect_uri)
     {:form, [

lib/myapp/battle_net/user.ex

@@ -1,16 +1,32 @@
 defmodule MyApp.BattleNet.User do
-  defstruct id: nil, battletag: nil
+
+  @type battle_net_user :: %{"battle_net_id": integer, "battletag": String.t, "access_token": String.t}
 
   def api_url, do: "https://us.api.battle.net"
 
-  def get_user(access_token) do
-    case HTTPoison.get(resource_url("account/user", access_token)) do
-      {:ok, %HTTPoison.Response{body: body}} -> {:ok, Poison.decode!(body, as: Battlenet.User)}
-      {:error, err} -> {:error, err}
+  # grab user information from battle net api - use token for auth
+  @spec get_user(String.t | {atom, any}) :: {:ok, battle_net_user} | {:error, any}
+  def get_user(access_token) when is_binary(access_token) do
+    HTTPoison.get(resource_url("account/user", access_token))
+    |> parse_user_response(access_token)
+  end
+  def get_user({:ok, access_token}), do: get_user(access_token)
+  def get_user({:error, error}), do: {:error, error}
+
+  defp parse_user_response({:error, error}, _), do: {:error, error}
+  defp parse_user_response({:ok, %HTTPoison.Response{body: body}}, access_token) do
+    case Poison.decode(body) do
+      {:ok, user} ->
+        user = user
+        |> Map.merge(%{"access_token" => access_token}) # add access token to return map
+        |> Map.put("battle_net_id", Map.get(user, "id")) # change id key to battle_net_id
+        |> Map.delete("id") # remove id key
+        {:ok, user}
+      {:error, error} -> {:error, error}
     end
   end
 
   defp resource_url(path, access_token) do
-    "#{api_url}/#{path}?access_token=#{access_token}"
+    "#{api_url()}/#{path}?access_token=#{access_token}"
   end
 end