请求与响应 #

%Plug.Conn{
  host: "localhost",
  method: "GET",
  path_info: ["users", "1"],
  request_path: "/users/1",
  params: %{"id" => "1"},
  query_string: "page=1",
  req_headers: [{"content-type", "application/json"}],
  req_cookies: %{"session" => "abc123"},
  body_params: %{"name" => "John"},
  assigns: %{},
  status: nil,
  resp_headers: [],
  resp_cookies: %{},
  state: :unset
}

def show(conn, params) do
  host = conn.host
  method = conn.method
  path = conn.request_path
  query = conn.query_string
  headers = conn.req_headers

  json(conn, %{
    host: host,
    method: method,
    path: path,
    query: query
  })
end

def create(conn, params) do
  path_params = conn.path_params
  query_params = conn.query_params
  body_params = conn.body_params
  all_params = conn.params

  json(conn, %{
    path: path_params,
    query: query_params,
    body: body_params,
    all: all_params
  })
end

get "/users/:id", UserController, :show
get "/posts/:post_id/comments/:id", CommentController, :show

def show(conn, %{"id" => id}) do
  user = Hello.Accounts.get_user!(id)
  render(conn, :show, user: user)
end

def index(conn, params) do
  page = Map.get(params, "page", "1")
  search = Map.get(params, "search", "")

  users = Hello.Accounts.list_users(page: page, search: search)
  render(conn, :index, users: users)
end

def create(conn, %{"user" => user_params}) do
  case Hello.Accounts.create_user(user_params) do
    {:ok, user} ->
      redirect(conn, to: ~p"/users/#{user.id}")

    {:error, changeset} ->
      render(conn, :new, changeset: changeset)
  end
end

def create(conn, params) do
  case Hello.Accounts.create_user(params) do
    {:ok, user} ->
      json(conn, %{data: user})

    {:error, changeset} ->
      json(conn, %{errors: format_errors(changeset)})
  end
end

def show(conn, _params) do
  content_type = Plug.Conn.get_req_header(conn, "content-type")
  authorization = Plug.Conn.get_req_header(conn, "authorization")
  user_agent = Plug.Conn.get_req_header(conn, "user-agent")

  json(conn, %{
    content_type: content_type,
    authorization: authorization,
    user_agent: user_agent
  })
end

def headers(conn, _params) do
  headers = Enum.into(conn.req_headers, %{})
  json(conn, headers)
end

def show(conn, _params) do
  session_id = conn.cookies["session_id"]
  preferences = conn.cookies["preferences"]

  json(conn, %{
    session_id: session_id,
    preferences: preferences
  })
end

def set_preference(conn, %{"theme" => theme}) do
  conn
  |> put_resp_cookie("theme", theme, max_age: 365 * 24 * 60 * 60)
  |> json(%{theme: theme})
end

def clear_preference(conn, _params) do
  conn
  |> delete_resp_cookie("theme")
  |> json(%{message: "Preference cleared"})
end

def show(conn, _params) do
  user_id = Plug.Conn.get_session(conn, :user_id)
  user = Hello.Accounts.get_user(user_id)

  render(conn, :show, user: user)
end

def create(conn, %{"email" => email, "password" => password}) do
  case Hello.Accounts.authenticate_user(email, password) do
    {:ok, user} ->
      conn
      |> Plug.Conn.put_session(:user_id, user.id)
      |> put_flash(:info, "Logged in successfully")
      |> redirect(to: ~p"/")

    {:error, _} ->
      conn
      |> put_flash(:error, "Invalid credentials")
      |> render(:new)
  end
end

def delete(conn, _params) do
  conn
  |> Plug.Conn.clear_session()
  |> put_flash(:info, "Logged out successfully")
  |> redirect(to: ~p"/")
end

def index(conn, _params) do
  users = Hello.Accounts.list_users()
  render(conn, :index, users: users)
end

def show(conn, %{"id" => id}) do
  user = Hello.Accounts.get_user!(id)
  json(conn, %{data: user})
end

def health(conn, _params) do
  text(conn, "OK")
end

def download(conn, %{"id" => id}) do
  file = Hello.Files.get_file!(id)

  conn
  |> put_resp_content_type(file.content_type)
  |> send_download({:binary, file.content}, filename: file.name)
end

def delete(conn, %{"id" => id}) do
  {:ok, _} = Hello.Accounts.delete_user(id)
  send_resp(conn, :no_content, "")
end

def show(conn, %{"id" => id}) do
  user = Hello.Accounts.get_user!(id)

  conn
  |> put_resp_header("x-request-id", generate_request_id())
  |> put_resp_header("cache-control", "public, max-age=3600")
  |> put_resp_header("x-content-type-options", "nosniff")
  |> render(:show, user: user)
end

def index(conn, _params) do
  conn
  |> put_resp_header("access-control-allow-origin", "*")
  |> put_resp_header("access-control-allow-methods", "GET, POST, PUT, DELETE")
  |> put_resp_header("access-control-allow-headers", "content-type, authorization")
  |> json(%{data: []})
end

pipeline :browser do
  plug :put_secure_browser_headers
end

x-content-type-options: nosniff
x-download-options: noopen
x-frame-options: SAMEORIGIN
x-permitted-cross-domain-policies: none
x-xss-protection: 1; mode=block

def create(conn, params) do
  case Hello.Accounts.create_user(params) do
    {:ok, user} ->
      conn
      |> put_status(:created)
      |> json(%{data: user})

    {:error, changeset} ->
      conn
      |> put_status(:unprocessable_entity)
      |> json(%{errors: format_errors(changeset)})
  end
end

def show(conn, %{"id" => id}) do
  case Hello.Accounts.get_user(id) do
    nil ->
      conn
      |> put_status(:not_found)
      |> json(%{error: "User not found"})

    user ->
      json(conn, %{data: user})
  end
end

def redirect_permanent(conn, _params) do
  conn
  |> put_status(:moved_permanently)
  |> redirect(to: ~p"/new-path")
end

def redirect_temporary(conn, _params) do
  conn
  |> put_status(:found)
  |> redirect(to: ~p"/temp-path")
end

pipeline :api do
  plug :accepts, ["json"]
end

pipeline :browser do
  plug :accepts, ["html"]
end

defmodule HelloWeb.Router do
  use HelloWeb, :router

  pipeline :api do
    plug :accepts, ["json", "xml"]
  end

  scope "/api", HelloWeb.Api do
    pipe_through :api

    resources "/users", UserController
  end
end

defmodule HelloWeb.Api.UserController do
  use HelloWeb, :controller

  def index(conn, _params) do
    users = Hello.Accounts.list_users()

    case get_format(conn) do
      "json" -> json(conn, %{data: users})
      "xml" -> render_xml(conn, users)
    end
  end

  defp render_xml(conn, users) do
    xml = """
    <?xml version="1.0" encoding="UTF-8"?>
    <users>
      #{Enum.map(users, &user_xml/1)}
    </users>
    """

    conn
    |> put_resp_content_type("application/xml")
    |> send_resp(200, xml)
  end

  defp user_xml(user) do
    "<user><id>#{user.id}</id><name>#{user.name}</name></user>"
  end
end

def upload(conn, %{"file" => upload}) do
  %Plug.Upload{
    filename: filename,
    content_type: content_type,
    path: temp_path
  } = upload

  case save_file(temp_path, filename) do
    {:ok, file_path} ->
      json(conn, %{path: file_path, filename: filename})

    {:error, reason} ->
      conn
      |> put_status(:unprocessable_entity)
      |> json(%{error: reason})
  end
end

defp save_file(temp_path, filename) do
  upload_dir = Application.app_dir(:hello, "priv/uploads")
  File.mkdir_p(upload_dir)

  dest_path = Path.join(upload_dir, filename)
  File.cp(temp_path, dest_path)

  {:ok, dest_path}
end

def upload_multiple(conn, %{"files" => files}) do
  results =
    files
    |> Enum.map(fn upload ->
      %Plug.Upload{filename: filename, path: temp_path} = upload
      save_file(temp_path, filename)
    end)

  json(conn, %{results: results})
end

def upload(conn, %{"file" => upload}) do
  with :ok <- validate_size(upload),
       :ok <- validate_type(upload) do
    save_and_respond(conn, upload)
  else
    {:error, reason} ->
      conn
      |> put_status(:unprocessable_entity)
      |> json(%{error: reason})
  end
end

defp validate_size(%Plug.Upload{path: path}) do
  case File.stat(path) do
    {:ok, %{size: size}} when size <= 10_000_000 -> :ok
    _ -> {:error, "File too large (max 10MB)"}
  end
end

defp validate_type(%Plug.Upload{content_type: type}) do
  allowed = ["image/jpeg", "image/png", "image/gif", "application/pdf"]

  if type in allowed do
    :ok
  else
    {:error, "Invalid file type"}
  end
end

def stream(conn, _params) do
  conn
  |> put_resp_content_type("text/plain")
  |> send_chunked(200)
  |> stream_data()
end

defp stream_data(conn) do
  Enum.reduce(1..100, conn, fn i, conn ->
    chunk(conn, "Line #{i}\n")
  end)
end

def sse(conn, _params) do
  conn
  |> put_resp_content_type("text/event-stream")
  |> send_chunked(200)
  |> send_events()
end

defp send_events(conn) do
  Enum.reduce(1..100, conn, fn i, conn ->
    event = "data: Message #{i}\n\n"
    chunk(conn, event)
  end)
end