defmodule WeChat.Component do
@moduledoc """
Use for WeChat official accounts third-party platform applications, `WeChat` module
is usually used for WeChat's functional APIs invoke directly, `WeChat.Component` is used to
call to refetch/refresh authorizer's access token internally.
"""
require Logger
alias WeChat.{Utils, Error}
defmacro __using__(opts \\ []) do
default_opts =
opts
|> Macro.prewalk(&Macro.expand(&1, __CALLER__))
|> Keyword.take([:adapter_storage, :appid, :authorizer_appid, :scenario])
quote do
def default_opts, do: unquote(default_opts)
@doc """
See WeChat.request/2 for more information.
"""
def request(method, options) do
options = Utils.merge_keyword(options, unquote(default_opts))
WeChat.component_request(method, options)
end
@doc """
The expire time (in seconds) to `access_token` and `ticket` temporary storage,
by default it is 7200 seconds
"""
defdelegate expires_in(), to: WeChat
defoverridable request: 2, expires_in: 0
end
end
@doc """
A function helper to fetch `component` application's access token.
When apply it to hub, if no available component access token from hub's storage, there will use `verify_ticket` to refetch a new one,
this function can be used for refresh function.
"""
def fetch_component_access_token(appid, adapter_storage) when is_atom(adapter_storage) do
fetch_component_access_token(appid, {adapter_storage, nil})
end
def fetch_component_access_token(appid, {adapter_storage, args}) do
case adapter_storage.fetch_component_access_token(appid, args) do
{:ok, %WeChat.Token{access_token: nil}} ->
component_access_token = remote_get_component_access_token(appid, adapter_storage, args)
Logger.info("get component_access_token from remote: #{inspect(component_access_token)}")
component_access_token
{:ok, %WeChat.Token{access_token: _}} = token ->
token
{:error, error} ->
{:error, error}
end
end
defp remote_get_component_access_token(appid, adapter_storage, args) do
case adapter_storage.fetch_component_verify_ticket(appid, args) do
{:ok, verify_ticket} when verify_ticket != nil ->
Logger.info(
">>> verify_ticket when remote_get_component_access_token: #{inspect(verify_ticket)}"
)
result =
WeChat.request(:post,
url: "/cgi-bin/component/api_component_token",
body: %{"component_verify_ticket" => verify_ticket},
appid: appid,
adapter_storage: {adapter_storage, args}
)
case result do
{:ok, response} ->
access_token = Map.get(response.body, "component_access_token")
expires_in = Map.get(response.body, "expires_in")
{
:ok,
%WeChat.Token{
access_token: access_token,
expires_in: expires_in,
timestamp: Utils.now_unix()
}
}
{:error, error} ->
Logger.error(
"remote call /cgi-bin/component/api_component_token for appid: #{inspect(appid)} occurs an error: #{
inspect(error)
}"
)
{:error, error}
end
{:error, error} ->
Logger.error(
"occur an error: #{inspect(error)} when get component access token for appid: #{
inspect(appid)
}"
)
raise %WeChat.Error{
message:
"verify_ticket is not existed for appid: #{inspect(appid)}, please try re-authorize",
reason: "verify_ticket_not_found"
}
end
end
@doc """
A function helper to fetch authorizer application's access token from `component` application.
When apply it to hub, if no available access token from hub's storage, there will use `refresh_token` to refetch a new one,
this function can be used for refresh function.
"""
def fetch_access_token(appid, authorizer_appid, adapter_storage)
when is_atom(adapter_storage) and adapter_storage != nil do
fetch_access_token(appid, authorizer_appid, {adapter_storage, nil})
end
def fetch_access_token(appid, authorizer_appid, {adapter_storage, args}) do
result = adapter_storage.fetch_access_token(appid, authorizer_appid, args)
case result do
{:ok, %WeChat.Token{access_token: access_token}} when access_token != nil ->
result
{:ok, %WeChat.Token{access_token: nil, refresh_token: refresh_token}}
when refresh_token != nil ->
refresh_or_refetch_token_to_refresh(
appid,
authorizer_appid,
refresh_token,
adapter_storage,
args
)
_ ->
find_and_refresh_access_token(appid, authorizer_appid, adapter_storage, args)
end
end
defp refresh_or_refetch_token_to_refresh(
appid,
authorizer_appid,
authorizer_refresh_token_str,
adapter_storage,
args
) do
refresh_result =
remote_refresh_authorizer_access_token(
appid,
authorizer_appid,
authorizer_refresh_token_str,
adapter_storage,
args
)
Logger.info(
">>>> remote refresh authorizer_access_token result: #{inspect(refresh_result)} <<<<"
)
case refresh_result do
nil ->
find_and_refresh_access_token(appid, authorizer_appid, adapter_storage, args)
{:ok, %WeChat.Token{access_token: _access_token}} ->
refresh_result
end
end
defp remote_refresh_authorizer_access_token(
appid,
authorizer_appid,
authorizer_refresh_token_str,
adapter_storage,
args
) do
data = %{
"authorizer_appid" => authorizer_appid,
"authorizer_refresh_token" => authorizer_refresh_token_str
}
request_result =
WeChat.request(:post,
url: "/cgi-bin/component/api_authorizer_token",
body: data,
appid: appid,
authorizer_appid: authorizer_appid,
adapter_storage: {adapter_storage, args}
)
Logger.info(
">>>> remote_refresh_authorizer_access_token request_result: #{inspect(request_result)} <<<<"
)
case request_result do
{:ok, response} ->
{
:ok,
%WeChat.Token{
access_token: Map.get(response.body, "authorizer_access_token"),
timestamp: Map.get(response.body, "timestamp"),
expires_in: Map.get(response.body, "expires_in")
}
}
{:error, error} ->
# errcode: 61023, invalid refresh_token
# try to refetch refresh_token, and then use it to refresh authorizer access_token
Logger.info(
"remote_refresh_authorizer_access_token occurs error: #{inspect(error)}, will try to refetch refresh_token and use it to refresh authorizer access_token"
)
nil
end
end
defp find_and_refresh_access_token(appid, authorizer_appid, adapter_storage, args) do
behaviours = adapter_storage.module_info[:attributes][:behaviour]
if WeChat.Storage.ComponentClient in behaviours do
# For client use case, send request to hub for refresh.
adapter_storage.refresh_access_token(appid, authorizer_appid, nil, args)
else
# For hub use case, the cached component refresh token is expired,
# rerun refresh token by authorizer list.
case remote_find_authorizer_refresh_token(appid, authorizer_appid, adapter_storage, args) do
{:ok, refresh_token_str} ->
Logger.info(
">>> refresh_token: #{inspect(refresh_token_str)} from remote_find_authorizer_refresh_token"
)
remote_refresh_authorizer_access_token(
appid,
authorizer_appid,
refresh_token_str,
adapter_storage,
args
)
error ->
error
end
end
end
defp remote_find_authorizer_refresh_token(
appid,
authorizer_appid,
adapter_storage,
args,
offset \\ 0,
count \\ 500
) do
request_result =
WeChat.request(:post,
appid: appid,
url: "/cgi-bin/component/api_get_authorizer_list",
body: %{"offset" => offset, "count" => count},
adapter_storage: {adapter_storage, args}
)
case request_result do
{:ok, response} ->
total_count = Map.get(response.body, "total_count")
Logger.info("remote get authorizer_list total_count: #{total_count}, offset: #{offset}")
list = Map.get(response.body, "list")
matched =
Enum.find(list, fn item ->
Map.get(item, "authorizer_appid") == authorizer_appid
end)
if matched != nil do
{:ok, Map.get(matched, "refresh_token")}
else
size_in_list = length(list)
if size_in_list == 0 or size_in_list == total_count do
Logger.error(
"not find matched authorizer_appid: #{authorizer_appid} in authorizer_list, please double check."
)
{:error, %Error{reason: "invalid_authorizer_appid"}}
else
if offset + 1 < total_count do
remote_find_authorizer_refresh_token(
appid,
authorizer_appid,
adapter_storage,
args,
offset + size_in_list,
count
)
else
Logger.error(
"not find matched authorizer_appid: #{authorizer_appid} in authorizer_list, please double check."
)
{:error, %Error{reason: "invalid_authorizer_appid"}}
end
end
end
{:error, error} ->
Logger.error("remote_find_authorizer_refresh_token error: #{inspect(error)}")
{:error, error}
end
end
end
