server - set token expiration to the same as battlnet token expiration

lib/myapp/auth/token.ex

@@ -1,17 +1,15 @@
 defmodule MyApp.Guardian.Auth.Token do
   alias MyApp.Guardian
-  
-  # ~1 year
-  defp tokenTTL(), do: {52, :weeks}
 
   @spec add_token_and_map_claims(map | {atom, any}) :: {:ok, map} | {:error, String.t}
   def add_token_and_map_claims(user) when is_map(user) do
 
     claims = user
-    |> Map.take([:id, :battletag, :battle_net_id, :access_token]) # take values from user object to map to claims
+    |> Map.take([:id, :battletag, :battle_net_id, "access_token"]) # take values from user object to map to claims
     |> Guardian.add_permissions(get_permissions(user))
 
-    case Guardian.encode_and_sign(user, claims, ttl: tokenTTL()) do
+    # set token expiration to the same as the battlenet token
+    case Guardian.encode_and_sign(user, claims, ttl: {user["expires_in"], :seconds}) do
       {:ok, token, _claims} -> {:ok, Map.merge(user, %{token: token})}
       {:error, error} -> {:error, error}
     end

lib/myapp/battle_net/auth.ex

@@ -4,7 +4,7 @@ defmodule MyApp.BattleNet.Auth do
 
   def token_uri, do: "https://us.battle.net/oauth/token"
 
-  @spec get_access_token(String.t) :: {:ok, String.t} | {:error, String.t}
+  @spec get_access_token(String.t) :: {:ok, %{access_token: String.t, expires_id: integer}} | {: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)
@@ -20,9 +20,9 @@ defmodule MyApp.BattleNet.Auth do
   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" => error}}), do: {:error, error}
   defp parse_token({:error, err}), do: {:error, "Authentication error"}
+  defp parse_token({:ok, data}) when is_map(data), do: {:ok, data}
 
   @spec get_req_body(String.t) :: tuple
   defp get_req_body(code) do

lib/myapp/battle_net/user.ex

@@ -1,28 +1,26 @@
 defmodule MyApp.BattleNet.User do
 
-  @type battle_net_user :: %{"battle_net_id": integer, "battletag": String.t, "access_token": String.t}
-
   def api_url(region), do: "https://#{region}.api.battle.net"
 
   def cache_key(user_id, region), do: "usr_char:#{user_id}:#{region}"
 
   # grab user information from battle net api - use token for auth
-  @spec get_user(String.t | {atom, any}, String.t) :: {:ok, battle_net_user} | {:error, any}
-  def get_user(access_token, region) when is_binary(access_token) do
-    access_token
+  @spec get_user(%{"access_token": String.t, "expires_in": integer}, String.t) :: {:ok, map} | {:error, any}
+  def get_user(data, region) when is_map(data) do
+    data["access_token"]
     |> resource_url("account/user", region)
     |> HTTPoison.get
-    |> parse_user_response(access_token)
+    |> parse_user_response(data)
   end
-  def get_user({:ok, access_token}, region), do: get_user(access_token, region)
+  def get_user({:ok, data}, region), do: get_user(data, region)
   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
+  defp parse_user_response({:ok, %HTTPoison.Response{body: body}}, data) do
     case Poison.decode(body) do
       {:ok, user} ->
         user = user
-        |> Map.merge(%{"access_token" => access_token}) # add access token to return map
+        |> Map.merge(data) # merge blizzard user api info
         |> Map.put("battle_net_id", Map.get(user, "id")) # change id key to battle_net_id
         |> Map.delete("id") # remove id key
         {:ok, user}

lib/myapp/data/user.ex

@@ -74,15 +74,15 @@ defmodule MyApp.Data.User do
     end
 
     output
-    |> add_access_token(Map.get(params, "access_token"))
+    |> add_extra_params(params)
   end
   def upsert_user({:ok, params}), do: upsert_user(params)
   def upsert_user({:error, error}), do: {:error, error}
 
   # need to add token back to map because we don't store it in the database
-  defp add_access_token({:error, error}, _), do: {:error, error}
-  defp add_access_token({:ok, user}, access_token) do
-    {:ok, Map.merge(user, %{access_token: access_token})}
+  defp add_extra_params({:error, error}, _), do: {:error, error}
+  defp add_extra_params({:ok, user}, params) do
+    {:ok, Map.merge(user, params)}
   end
 
   defp insert_battlenet_user(params) do