Add API endpoints for site and shared link creation

pull/941/head
Uku Taht 6 years ago
parent 8ae4d46e5b
commit 3ed964b45b

@ -4,9 +4,10 @@ defmodule Plausible.Site do
alias Plausible.Auth.User
alias Plausible.Site.GoogleAuth
@derive {Jason.Encoder, only: [:domain, :timezone]}
schema "sites" do
field :domain, :string
field :timezone, :string
field :timezone, :string, default: "Etc/Greenwich"
field :public, :boolean
many_to_many :members, User, join_through: Plausible.Site.Membership

@ -1,6 +1,42 @@
defmodule Plausible.Sites do
use Plausible.Repo
alias Plausible.Site.CustomDomain
alias Plausible.Site.{CustomDomain, SharedLink}
def create(user_id, params) do
site_changeset = Plausible.Site.changeset(%Plausible.Site{}, params)
Ecto.Multi.new()
|> Ecto.Multi.insert(:site, site_changeset)
|> Ecto.Multi.run(:site_membership, fn repo, %{site: site} ->
membership_changeset =
Plausible.Site.Membership.changeset(%Plausible.Site.Membership{}, %{
site_id: site.id,
user_id: user_id
})
repo.insert(membership_changeset)
end)
|> Repo.transaction()
end
def create_shared_link(site, name) do
changes =
SharedLink.changeset(
%SharedLink{
site_id: site.id,
slug: Nanoid.generate()
},
%{name: name}
)
Repo.insert(changes)
end
def shared_link_url(site, link) do
base = PlausibleWeb.Endpoint.url()
domain = "/share/#{URI.encode_www_form(site.domain)}"
base <> domain <> "?auth=" <> link.slug
end
def get_for_user!(user_id, domain) do
Repo.one!(

@ -0,0 +1,50 @@
defmodule PlausibleWeb.Api.ExternalSitesController do
use PlausibleWeb, :controller
use Plausible.Repo
use Plug.ErrorHandler
alias Plausible.Sites
def create_site(conn, params) do
user_id = conn.assigns[:current_user_id]
site_params = Map.get(params, "site", %{})
case Sites.create(user_id, site_params) do
{:ok, %{site: site}} ->
json(conn, site)
{:error, :site, changeset, _} ->
conn
|> put_status(400)
|> json(serialize_errors(changeset))
end
end
def find_or_create_shared_link(conn, %{"domain" => domain, "link_name" => link_name}) do
site = Sites.get_for_user!(conn.assigns[:current_user_id], domain)
shared_link = Repo.get_by(Plausible.Site.SharedLink, site_id: site.id, name: link_name)
shared_link =
case shared_link do
nil -> Sites.create_shared_link(site, link_name)
link -> {:ok, link}
end
case shared_link do
{:ok, link} ->
json(conn, %{
name: link.name,
url: Sites.shared_link_url(site, link)
})
end
end
defp serialize_errors(changeset) do
{field, {msg, _opts}} = List.first(changeset.errors)
error_msg = Atom.to_string(field) <> " " <> msg
%{"error" => error_msg}
end
def handle_errors(conn, %{kind: kind, reason: reason}) do
json(conn, %{error: Exception.format_banner(kind, reason)})
end
end

@ -41,7 +41,7 @@ defmodule PlausibleWeb.SiteController do
def create_site(conn, %{"site" => site_params}) do
user = conn.assigns[:current_user]
case insert_site(user.id, site_params) do
case Sites.create(user.id, site_params) do
{:ok, %{site: site}} ->
Plausible.Slack.notify("#{user.name} created #{site.domain} [email=#{user.email}]")
@ -517,16 +517,7 @@ defmodule PlausibleWeb.SiteController do
def create_shared_link(conn, %{"website" => website, "shared_link" => link}) do
site = Sites.get_for_user!(conn.assigns[:current_user].id, website)
changes =
Plausible.Site.SharedLink.changeset(
%Plausible.Site.SharedLink{
site_id: site.id,
slug: Nanoid.generate()
},
link
)
case Repo.insert(changes) do
case Sites.create_shared_link(site, link["name"]) do
{:ok, _created} ->
redirect(conn, to: "/#{URI.encode_www_form(site.domain)}/settings/visibility")
@ -652,21 +643,4 @@ defmodule PlausibleWeb.SiteController do
|> put_flash(:success, "Custom domain deleted successfully")
|> redirect(to: "/#{URI.encode_www_form(site.domain)}/settings/custom-domain")
end
defp insert_site(user_id, params) do
site_changeset = Plausible.Site.changeset(%Plausible.Site{}, params)
Ecto.Multi.new()
|> Ecto.Multi.insert(:site, site_changeset)
|> Ecto.Multi.run(:site_membership, fn repo, %{site: site} ->
membership_changeset =
Plausible.Site.Membership.changeset(%Plausible.Site.Membership{}, %{
site_id: site.id,
user_id: user_id
})
repo.insert(membership_changeset)
end)
|> Repo.transaction()
end
end

@ -0,0 +1,56 @@
defmodule PlausibleWeb.AuthorizeSitesApiPlug do
import Plug.Conn
use Plausible.Repo
alias Plausible.Auth.ApiKey
def init(options) do
options
end
def call(conn, _opts) do
with {:ok, raw_api_key} <- get_bearer_token(conn),
{:ok, api_key} <- verify_access(raw_api_key) do
assign(conn, :current_user_id, api_key.user_id)
else
{:error, :missing_api_key} ->
unauthorized(
conn,
"Missing API key. Please use a valid Plausible API key as a Bearer Token."
)
{:error, :invalid_api_key} ->
unauthorized(
conn,
"Invalid API key. Please make sure you're using a valid API key with access to the site you've requested."
)
end
end
defp verify_access(api_key) do
hashed_key = ApiKey.do_hash(api_key)
found_key = Repo.get_by(ApiKey, key_hash: hashed_key)
cond do
found_key -> {:ok, found_key}
true -> {:error, :invalid_api_key}
end
end
defp get_bearer_token(conn) do
authorization_header =
Plug.Conn.get_req_header(conn, "authorization")
|> List.first()
case authorization_header do
"Bearer " <> token -> {:ok, String.trim(token)}
_ -> {:error, :missing_api_key}
end
end
defp unauthorized(conn, msg) do
conn
|> put_status(401)
|> Phoenix.Controller.json(%{error: msg})
|> halt()
end
end

@ -1,4 +1,4 @@
defmodule PlausibleWeb.AuthorizeApiStatsPlug do
defmodule PlausibleWeb.AuthorizeStatsApiPlug do
import Plug.Conn
use Plausible.Repo
alias Plausible.Auth.ApiKey

@ -36,10 +36,9 @@ defmodule PlausibleWeb.Router do
plug PlausibleWeb.AuthorizeStatsPlug
end
pipeline :external_stats_api do
pipeline :public_api do
plug :accepts, ["json"]
plug PlausibleWeb.Firewall
plug PlausibleWeb.AuthorizeApiStatsPlug
end
if Application.get_env(:plausible, :environment) == "dev" do
@ -73,7 +72,7 @@ defmodule PlausibleWeb.Router do
end
scope "/api/v1/stats", PlausibleWeb.Api do
pipe_through :external_stats_api
pipe_through [:public_api, PlausibleWeb.AuthorizeStatsApiPlug]
get "/realtime/visitors", ExternalStatsController, :realtime_visitors
get "/aggregate", ExternalStatsController, :aggregate
@ -81,6 +80,13 @@ defmodule PlausibleWeb.Router do
get "/timeseries", ExternalStatsController, :timeseries
end
scope "/api/v1/sites", PlausibleWeb.Api do
pipe_through [:public_api, PlausibleWeb.AuthorizeSitesApiPlug]
post "/", ExternalSitesController, :create_site
put "/:domain/shared-links/:link_name", ExternalSitesController, :find_or_create_shared_link
end
scope "/api", PlausibleWeb do
pipe_through :api

@ -22,8 +22,7 @@ defmodule PlausibleWeb.SiteView do
end
def shared_link_dest(site, link) do
domain = "/share/#{URI.encode_www_form(site.domain)}"
plausible_url() <> domain <> "?auth=" <> link.slug
Plausible.Sites.shared_link_url(site, link)
end
def snippet(site) do

@ -0,0 +1,67 @@
defmodule PlausibleWeb.Api.ExternalSitesControllerTest do
use PlausibleWeb.ConnCase
import Plausible.TestUtils
setup [:create_user, :create_api_key, :use_api_key]
describe "POST /api/v1/sites" do
test "can create a site", %{conn: conn} do
conn =
post(conn, "/api/v1/sites", %{
"site" => %{
"domain" => "some-site.domain",
"timezone" => "Europe/Tallinn"
}
})
assert json_response(conn, 200) == %{
"domain" => "some-site.domain",
"timezone" => "Europe/Tallinn"
}
end
test "timezone defaults to Etc/Greenwich", %{conn: conn} do
conn =
post(conn, "/api/v1/sites", %{
"site" => %{
"domain" => "some-site.domain"
}
})
assert json_response(conn, 200) == %{
"domain" => "some-site.domain",
"timezone" => "Etc/Greenwich"
}
end
test "domain is required", %{conn: conn} do
conn = post(conn, "/api/v1/sites", %{})
assert json_response(conn, 400) == %{
"error" => "domain can't be blank"
}
end
end
describe "PUT /api/v1/sites/shared-links/:link_name" do
setup :create_site
test "can add a shared link to a site", %{conn: conn, site: site} do
conn = put(conn, "/api/v1/sites/#{site.domain}/shared-links/Wordpress")
res = json_response(conn, 200)
assert res["name"] == "Wordpress"
assert String.starts_with?(res["url"], "http://")
end
test "is idempotent find or create op", %{conn: conn, site: site} do
conn = put(conn, "/api/v1/sites/#{site.domain}/shared-links/Wordpress")
%{"url" => url} = json_response(conn, 200)
conn = put(conn, "/api/v1/sites/#{site.domain}/shared-links/Wordpress")
assert %{"url" => ^url} = json_response(conn, 200)
end
end
end
Loading…
Cancel
Save