#Elixir 练手 + 实战：短链接服务

mix new shorten_api --sup

mix deps.get

mix run --no-halt

curl --request POST \
  --url http://localhost:8080/api/v1 \
  --header 'content-type: application/json' \
  --data '{
    "url": "https://next.mogeko.me/posts/1c50d67603c680cda8e1eb6a89429e04"
  }'

{
  "ok": true,
  "short_link": "http://localhost:8080/D9mP2G8N"
}

defp deps do
  [
    {:plug_cowboy, "~> 2.0"},
    {:ecto_sql, "~> 3.2"},
    {:postgrex, "~> 0.15"},
    {:jason, "~> 1.3"}
  ]
end

# ./lib/shorten_api/hash_id.ex

defmodule ShortenApi.HashId do

  @hash_id_length 8

  @spec generate(String.t() | any()) :: :error | {:ok, String.t()}
  def generate(text) when is_binary(text) do 
    hash_id = text
    |> (&:crypto.hash(:sha, &1)).()
    |> Base.encode64
    |> binary_part(0, @hash_id_length)
    {:ok, hash_id}
  end

  def generate(_any), do: :error
end

# ./lib/shorten_api/router.ex

defmodule ShortenApi.Router do
  use Plug.Router
  import Plug.Conn

  plug Plug.Logger
  plug Plug.Parsers, parsers: [:urlencoded, :json], json_decoder: Jason
  plug :match
  plug :dispatch

  get "/" do
    [host_url | _tail] = get_req_header(conn, "host")
    res = Jason.encode!(%{message: "#{conn.scheme}://#{host_url}/api/v1"})
    conn
    |> put_resp_content_type("application/json")
    |> send_resp(200, res)
  end

  forward "/api/v1", to: ShortenApi.Plug.REST

  match _ do
    res = Jason.encode!(%{message: "Not Found"})
    conn
    |> put_resp_content_type("application/json")
    |> send_resp(404, res)
  end
end

# ./lib/shorten_api/rest.ex

defmodule ShortenApi.Plug.REST do
  @behaviour Plug
  import Plug.Conn

  @spec init(Plug.opts()) :: Plug.opts()
  def init(opts), do: opts

  @spec call(Plug.Conn.t(), Plug.opts()) :: Plug.Conn.t()
  def call(conn, _opts) do
    resp_msg = with {:ok, url} <- Map.fetch(conn.params, "url") do
      hortenApi.HashId.generate(url)
    end

    conn
    |> put_resp_content_type("application/json")
    |> put_resp_msg(resp_msg)
    |> send_resp()
  end

  @spec put_resp_msg(Plug.Conn.t(), :error | {:ok, String.t()}) :: Plug.Conn.t()
  def put_resp_msg(conn, {:ok, hash_id}) do
    [host_url | _tail] = get_req_header(conn, "host")
    res = Jason.encode!(%{ok: true, short_link: "#{conn.scheme}://#{host_url}/#{hash_id}"})
    resp(conn, 201, res)
  end

  def put_resp_msg(conn, :error) do
    res = Jason.encode!(%{ok: false, message: "Parameter error"})
    resp(conn, 404, res)
  end
end

# ./lib/shorten_api/appliation.ex

def start(_type, _args) do
  children = [
    {Plug.Cowboy, scheme: :http, plug: ShortenApi.Router, options: [port: 8080]}
  ]

  opts = [strategy: :one_for_one, name: ShortenApi.Supervisor]

  Logger.info("Starting application...")

  Supervisor.start_link(children, opts)
end

# ./lib/shorten_api/repo.ex

defmodule ShortenApi.Repo do
  use Ecto.Repo,
    otp_app: :shorten_api,
    adapter: Ecto.Adapters.Postgres
end

# ./priv/repo/migrations/*_create_links.exs

defmodule ShortenApi.Repo.Migrations.CreateLinks do
  use Ecto.Migration

  def change do
    create table(:links, primary_key: false) do
      add :hash, :string, primary_key: true, null: false
      add :url, :string, null: false

      timestamps()
    end

    create unique_index(:links, [:url])
  end
end

# ./lib/shorten_api/db/link.ex

defmodule ShortenApi.DB.Link do
  use Ecto.Schema

  @primary_key {:hash, :string, [autogenerate: false]}
  schema "links" do
    field(:url, :string)
    timestamps()
  end
end

# ./lib/shorten_api/db/link.ex

defmodule ShortenApi.DB.Link do
  use Ecto.Schema
  import Ecto.Changeset

  @primary_key {:hash, :string, [autogenerate: false]}
  schema "links" do
    field(:url, :string)
    timestamps()
  end

  @spec changeset(Ecto.Schema.t() | map, map) :: Ecto.Changeset.t() 
  def changeset(struct, params) do
    struct 
    |> cast(params, [:hash, :url]) 
    |> validate_required([:hash, :url]) 
    |> validate_format(:url, ~r/htt(p|ps):\/\/(\w+.)+/) 
    |> validate_hash_matched(:hash, :url) 
    |> unique_constraint(:url) 
  end

  @spec validate_hash_matched(Ecto.Changeset.t(), atom, atom) :: Ecto.Changeset.t() 
  def validate_hash_matched(changeset, hash, text) do
    import ShortenApi.HashId, only: [generate!: 1] 
    target_hash = get_field(changeset, hash) 
    target_text = get_field(changeset, text) 

    if generate!(target_text) != target_hash do
      add_error(changeset, :hash, "does not match target link") 
    else
      changeset 
    end
  end

  @spec write(String.t(), String.t()) :: {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()} 
  def write(hash, url) do
    %ShortenApi.DB.Link{} 
    |> changeset(%{hash: hash, url: url}) 
    |> ShortenApi.Repo.insert() 
  end
end

# ./lib/shorten_api/hash_id.ex

defmodule ShortenApi.HashId do

  @hash_id_length 8

  @spec generate(String.t() | any()) :: :error | {:ok, String.t()}
  def generate(text) when is_binary(text), do: {:ok, generate!(text)}
  def generate(_any), do: :error

  @spec generate!(String.t() | any()) :: :error | String.t()
  def generate!(text) when is_binary(text) do
    text
    |> (&:crypto.hash(:sha, &1)).()
    |> Base.encode64()
    |> binary_part(0, @hash_id_length)
  end

  def generate!(_any), do: :error
end

# ./lib/shorten_api/appliation.ex

def start(_type, _args) do
  children = [ 
    {Plug.Cowboy, scheme: :http, plug: ShortenApi.Router, options: [port: 8080]}, 
    ShortenApi.Repo
  ] 

  opts = [strategy: :one_for_one, name: ShortenApi.Supervisor]

  Logger.info("Starting application...")

  Supervisor.start_link(children, opts)
end

# ./lib/shorten_api/rest.ex

defmodule ShortenApi.Plug.REST do
  @behaviour Plug
  import Plug.Conn

  @spec init(Plug.opts()) :: Plug.opts()
  def init(opts), do: opts

  @spec call(Plug.Conn.t(), Plug.opts()) :: Plug.Conn.t()
  def call(conn, _opts) do
    resp_msg =
      with {:ok, url} <- Map.fetch(conn.params, "url"),
           {:ok, hash} <- ShortenApi.HashId.generate(url) do
        ShortenApi.DB.Link.write(hash, url)
      end

    conn
    |> put_resp_content_type("application/json")
    |> put_resp_msg(resp_msg)
    |> send_resp()
  end
end

# ./lib/shorten_api/rest.ex

defmodule ShortenApi.Plug.REST.Resp do
  @derive Jason.Encoder
  defstruct ok: true, short_link: ""
  @type t :: %__MODULE__{ok: boolean, short_link: String.t()}
end

defmodule ShortenApi.Plug.REST.ErrResp do
  @derive Jason.Encoder
  defstruct ok: false, message: ""
  @type t :: %__MODULE__{ok: boolean, message: String.t()}
end

defmodule ShortenApi.Plug.REST do
  import Plug.Conn

  @spec put_resp_msg(
          Plug.Conn.t(),
          :error | {:error, Ecto.Changeset.t()} | {:ok, Ecto.Schema.t()}
        ) :: Plug.Conn.t()
  def put_resp_msg(conn, {:ok, struct}) do
    alias ShortenApi.Plug.REST.Resp
    [host_url | _tail] = get_req_header(conn, "host")
    short_link = "#{conn.scheme}://#{host_url}/#{struct.hash}"
    resp_json = Jason.encode!(%Resp{short_link: short_link})
    resp(conn, 201, resp_json)
  end

  def put_resp_msg(conn, {:error, _changeset}) do
    alias ShortenApi.Plug.REST.ErrResp
    resp_json = Jason.encode!(%ErrResp{message: "Wrong format"})
    resp(conn, 403, resp_json)
  end

  def put_resp_msg(conn, :error) do
    alias ShortenApi.Plug.REST.ErrResp
    resp_json = Jason.encode!(%ErrResp{message: "Parameter error"})
    resp(conn, 404, resp_json)
  end
end

# ./lib/shorten_api/router.ex

defmodule ShortenApi.Router do
  use Plug.Router
  import Plug.Conn

  plug(Plug.Logger)
  plug(Plug.Parsers, parsers: [:urlencoded, :json], json_decoder: Jason)
  plug(:match)
  plug(:dispatch)

  get "/:hash" do
    import Ecto.Query, only: [from: 2] 
    query = from l in ShortenApi.DB.Link, where: l.hash == ^hash, select: l.url 
    url = ShortenApi.Repo.one(query) 

    if is_nil(url) do
      conn 
      |> put_resp_content_type("application/json") 
      |> send_resp(404, Jason.encode!(%{message: "Not Found"})) 
    else
      conn 
      |> put_resp_header("location", url) 
      |> send_resp(302, "Redirect to #{url}") 
    end
  end
  
   get "/" do
    [host_url | _tail] = get_req_header(conn, "host")
    res = Jason.encode!(%{message: "#{conn.scheme}://#{host_url}/api/v1"})
    conn
    |> put_resp_content_type("application/json")
    |> send_resp(200, res)
  end

  forward "/api/v1", to: ShortenApi.Plug.REST

  match _ do
    res = Jason.encode!(%{message: "Not Found"})
    conn
    |> put_resp_content_type("application/json")
    |> send_resp(404, res)
  end
end