defmodule WeChat.Http.Middleware.Common do
@moduledoc false
@behaviour Tesla.Middleware
alias Tesla.Multipart
alias WeChat.{UploadMedia, UploadMediaContent, Error, Request, Utils}
require Logger
def call(env, next, request) do
execute(env, next, request)
end
defp execute(env, next, request) do
case try_use_from_cache(env, request) do
{:cont, env, request} ->
case prepare_request(env, request) do
{:error, error} ->
{:error, error}
prepared_env ->
prepared_env
|> Tesla.run(next)
|> decode_response(env, next, request)
end
{:cached, result} ->
{:ok, result}
end
end
defp try_use_from_cache(
env,
%Request{
authorizer_appid: nil,
uri: %URI{path: "/cgi-bin/ticket/getticket"},
adapter_storage: {adapter_storage, args}
} = request
) do
type = Keyword.get(request.query, :type)
appid = request.appid
case adapter_storage.fetch_ticket(appid, type, args) do
{:ok, ticket} ->
{
:cached,
format_cached_ticket_response(ticket)
}
{:error, _} ->
{:cont, env, request}
end
end
defp try_use_from_cache(
env,
%Request{
authorizer_appid: authorizer_appid,
uri: %URI{path: "/cgi-bin/ticket/getticket"},
adapter_storage: {adapter_storage, args}
} = request
) do
type = Keyword.get(request.query, :type)
appid = request.appid
case adapter_storage.fetch_ticket(appid, authorizer_appid, type, args) do
{:ok, ticket} ->
{
:cached,
format_cached_ticket_response(ticket)
}
{:error, _} ->
{:cont, env, request}
end
end
defp try_use_from_cache(env, request) do
{:cont, env, request}
end
defp format_cached_ticket_response(ticket) do
%{
status: 200,
body: %{
"errcode" => 0,
"errmsg" => "ok",
"ticket" => ticket.value,
"type" => ticket.type,
"timestamp" => ticket.timestamp,
"expires_in" => ticket.expires_in
},
headers: []
}
end
defp prepare_request(env, request) do
env
|> populate_access_token(request)
|> encode_request()
end
defp populate_access_token(
env,
%Request{
uri: %URI{path: "/cgi-bin/token"},
appid: appid,
adapter_storage: {adapter_storage, args}
} = request
) do
case adapter_storage.fetch_secret_key(appid, args) do
{:ok, secret} ->
prepared_query = [
grant_type: "client_credential",
appid: request.appid,
secret: secret
]
{Map.update!(env, :query, &Keyword.merge(&1, prepared_query)), request}
nil ->
Logger.error("not found secret_key for appid: #{inspect(appid)}")
prepared_query = [appid: request.appid]
{Map.update!(env, :query, &Keyword.merge(&1, prepared_query)), request}
end
end
defp populate_access_token(env, %Request{uri: %URI{path: path}} = request)
when path in ["/sns/userinfo", "/sns/auth"] do
# Use oauth authorized access_token to fetch user information,
# in this case, we don't need to populate the general access_token.
{env, request}
end
defp populate_access_token(
env,
%Request{
access_token: nil,
authorizer_appid: nil,
appid: appid,
adapter_storage: {adapter_storage, args}
} = request
) do
case adapter_storage.fetch_access_token(appid, args) do
{:ok, %WeChat.Token{access_token: access_token}} ->
{Map.update!(env, :query, &Keyword.put(&1 || [], :access_token, access_token)), request}
{:error, error} ->
{:error, error}
end
end
defp populate_access_token(
env,
%Request{
access_token: nil,
authorizer_appid: authorizer_appid,
appid: appid,
adapter_storage: {adapter_storage, args}
} = request
)
when authorizer_appid != nil do
case WeChat.Component.fetch_access_token(appid, authorizer_appid, {adapter_storage, args}) do
{:ok, %WeChat.Token{access_token: access_token}} when access_token != nil ->
{Map.update!(env, :query, &Keyword.put(&1 || [], :access_token, access_token)), request}
{:error, error} ->
{:error, error}
end
end
defp populate_access_token(env, %Request{access_token: access_token} = request) do
# Use the latest re-freshed access_token from `request`
request = Map.put(request, :access_token, nil)
{Map.update!(env, :query, &Keyword.put(&1 || [], :access_token, access_token)), request}
end
def encode_request({:error, error}) do
{:error, error}
end
def encode_request({env, %Request{body: {:form, body}}}) do
mp =
Enum.reduce(body, Multipart.new(), fn {key, value}, acc ->
case value do
%UploadMedia{} ->
acc
|> Multipart.add_file(value.file_path, name: "#{key}", detect_content_type: true)
|> Multipart.add_field("type", value.type)
%UploadMediaContent{} ->
acc
|> Multipart.add_file_content(value.file_content, value.file_name, name: "#{key}")
|> Multipart.add_field("type", value.type)
_ ->
Multipart.add_field(acc, "#{key}", "#{value}")
end
end)
body_binary = mp |> Multipart.body() |> Enum.join()
headers = Multipart.headers(mp)
env
|> Map.put(:body, body_binary)
|> Tesla.put_headers(headers)
end
def encode_request({env, _request}) do
with {:ok, env} <- Tesla.Middleware.JSON.encode(env, env.opts || []) do
env
end
end
defp decode_response({:ok, %{body: body} = response}, env, next, request)
when body != "" and body != nil do
Logger.info("common decode_response: #{inspect(body)}")
case rerun_when_token_expire(env, next, request, response) do
{:no_retry, json_resp_body} ->
json_resp_body = sync_to_storage_cache(json_resp_body, request)
{
:ok,
%{
status: response.status,
headers: response.headers,
body: json_resp_body
}
}
{retry_result, _json_resp_body} ->
retry_result
end
end
defp decode_response({:ok, %{body: body} = response}, _env, _next, _request)
when body == "" or body == nil do
{:error,
%Error{reason: "unknown", message: "response body is empty", http_status: response.status}}
end
defp decode_response({:error, reason}, _env, _next, _request) do
Logger.error("occurs error when decode response with reason: #{inspect(reason)}")
{:error, %Error{reason: "#{reason}"}}
end
defp sync_to_storage_cache(
%{"access_token" => access_token} = response,
%Request{
uri: %URI{path: "/cgi-bin/token"},
adapter_storage: {adapter_storage, args},
appid: appid
}
) do
{:ok, token} = adapter_storage.save_access_token(appid, access_token, args)
# Keep the latest `WeChat.Token` in the response from hub to client, and then client can
# use this `timestamp` and `expires_in` for local registry management in client side.
response |> Map.put("timestamp", token.timestamp) |> Map.put("expires_in", token.expires_in)
end
defp sync_to_storage_cache(
response,
%Request{
uri: %URI{path: "/cgi-bin/ticket/getticket"},
scenario: scenario
}
) when scenario != :hub do
# Ignore ticket storage in non-hub scenario,
# actually, ticket is fetched from the hub when
# call "/cgi-bin/ticket/getticket" request in a client.
response
end
defp sync_to_storage_cache(
%{"ticket" => ticket} = response,
%Request{
uri: %URI{path: "/cgi-bin/ticket/getticket"},
query: query,
adapter_storage: {adapter_storage, args},
appid: appid,
authorizer_appid: authorizer_appid
}
) when authorizer_appid != nil do
type = Keyword.get(query, :type)
{:ok, ticket} = adapter_storage.save_ticket(appid, authorizer_appid, ticket, type, args)
# Keep the latest `WeChat.Ticket` in the response from hub to client, and then client can
# use this `timestamp` and `expires_in` for local registry management in client side.
response |> Map.put("timestamp", ticket.timestamp) |> Map.put("expires_in", ticket.expires_in)
end
defp sync_to_storage_cache(
%{"ticket" => ticket} = response,
%Request{
uri: %URI{path: "/cgi-bin/ticket/getticket"},
query: query,
adapter_storage: {adapter_storage, args},
appid: appid,
authorizer_appid: nil
}
) do
type = Keyword.get(query, :type)
{:ok, ticket} = adapter_storage.save_ticket(appid, ticket, type, args)
# Keep the latest `WeChat.Ticket` in the response from hub to client, and then client can
# use this `timestamp` and `expires_in` for local registry management in client side.
response |> Map.put("timestamp", ticket.timestamp) |> Map.put("expires_in", ticket.expires_in)
end
defp sync_to_storage_cache(response, _request) do
response
end
defp rerun_when_token_expire(env, next, request, %{body: body} = response) do
json_resp_body = Utils.json_decode(body)
result = rerun_when_token_expire(env, next, request, json_resp_body, response.query)
{result, json_resp_body}
end
defp rerun_when_token_expire(
_env,
_next,
%Request{uri: %{path: path}},
%{"errcode" => errcode},
_request_query
)
when path in ["/sns/userinfo", "/sns/auth"] and errcode in [40001, 42001, 40014] do
# ignore retry when the access_token put from external
:no_retry
end
defp rerun_when_token_expire(
env,
next,
%Request{
appid: appid,
authorizer_appid: authorizer_appid,
adapter_storage: {adapter_storage, args}
} = request,
%{"errcode" => errcode},
request_query
)
when errcode == 40001
when errcode == 42001
when errcode == 40014 do
#
# errcode from WeChat 40001/42001: expired access_token
# errcode from WeChat 40014: invalid access_token
#
expired_access_token = Keyword.get(request_query, :access_token)
refresh_result =
if authorizer_appid != nil do
adapter_storage.refresh_access_token(
appid,
authorizer_appid,
expired_access_token,
args
)
else
adapter_storage.refresh_access_token(appid, expired_access_token, args)
end
case refresh_result do
{:ok, %WeChat.Token{access_token: new_access_token}} ->
request = Map.put(request, :access_token, new_access_token)
execute(env, next, request)
{:error, error} ->
{:error, error}
end
end
defp rerun_when_token_expire(
_env,
_next,
request,
%{"errcode" => errcode} = json_resp_body,
_request_query
)
when errcode == 61024 do
Logger.error(
"invalid usecase to get access_token of authorizer appid(#{request.authorizer_appid}) by WeChat Component Application(#{
request.appid
})"
)
{:error,
%Error{
reason: "invalid_usecase_get_access_token",
errcode: errcode,
message: Map.get(json_resp_body, "errmsg")
}}
end
defp rerun_when_token_expire(_env, _next, _request, _json_resp_body, _request_query) do
:no_retry
end
end
