636 lines
19 KiB
Elixir
636 lines
19 KiB
Elixir
defmodule PlausibleWeb.SiteController do
|
|
use PlausibleWeb, :controller
|
|
use Plausible.Repo
|
|
use Plausible
|
|
|
|
alias Plausible.Sites
|
|
|
|
@unrestricted_actions [:new, :create_site]
|
|
@destructive_actions [:settings_danger_zone, :reset_stats, :delete_site]
|
|
|
|
@special_cased_actions @unrestricted_actions ++ @destructive_actions
|
|
|
|
plug(PlausibleWeb.RequireAccountPlug)
|
|
|
|
plug(
|
|
PlausibleWeb.Plugs.AuthorizeSiteAccess,
|
|
[:owner, :admin, :editor, :super_admin]
|
|
when action not in @special_cased_actions
|
|
)
|
|
|
|
plug(
|
|
PlausibleWeb.Plugs.AuthorizeSiteAccess,
|
|
[:owner, :admin, :super_admin] when action in @destructive_actions
|
|
)
|
|
|
|
def new(conn, params) do
|
|
flow = params["flow"] || PlausibleWeb.Flows.register()
|
|
team = conn.assigns.current_team
|
|
|
|
render(conn, "new.html",
|
|
changeset: Plausible.Site.changeset(%Plausible.Site{}),
|
|
site_limit: Plausible.Teams.Billing.site_limit(team),
|
|
site_limit_exceeded?: Plausible.Teams.Billing.ensure_can_add_new_site(team) != :ok,
|
|
form_submit_url: "/sites?flow=#{flow}",
|
|
flow: flow
|
|
)
|
|
end
|
|
|
|
def create_site(conn, %{"site" => site_params}) do
|
|
team = conn.assigns.current_team
|
|
user = conn.assigns.current_user
|
|
first_site? = Plausible.Teams.Billing.site_usage(team) == 0
|
|
flow = conn.params["flow"]
|
|
|
|
case Sites.create(user, site_params, team) do
|
|
{:ok, %{site: site}} ->
|
|
if first_site? do
|
|
PlausibleWeb.Email.welcome_email(user)
|
|
|> Plausible.Mailer.send()
|
|
end
|
|
|
|
redirect(conn,
|
|
to:
|
|
Routes.site_path(conn, :installation, site.domain,
|
|
site_created: true,
|
|
flow: flow
|
|
)
|
|
)
|
|
|
|
{:error, _, :permission_denied, _} ->
|
|
conn
|
|
|> put_flash(:error, "You are not permitted to add sites in the current team")
|
|
|> render("new.html",
|
|
changeset: Plausible.Site.changeset(%Plausible.Site{}),
|
|
first_site?: first_site?,
|
|
site_limit: Plausible.Teams.Billing.site_limit(team),
|
|
site_limit_exceeded?: false,
|
|
flow: flow,
|
|
form_submit_url: "/sites?flow=#{flow}"
|
|
)
|
|
|
|
{:error, _, {:over_limit, limit}, _} ->
|
|
render(conn, "new.html",
|
|
changeset: Plausible.Site.changeset(%Plausible.Site{}),
|
|
first_site?: first_site?,
|
|
site_limit: limit,
|
|
site_limit_exceeded?: true,
|
|
flow: flow,
|
|
form_submit_url: "/sites?flow=#{flow}"
|
|
)
|
|
|
|
{:error, _, changeset, _} ->
|
|
render(conn, "new.html",
|
|
changeset: changeset,
|
|
first_site?: first_site?,
|
|
site_limit: Plausible.Teams.Billing.site_limit(team),
|
|
site_limit_exceeded?: false,
|
|
flow: flow,
|
|
form_submit_url: "/sites?flow=#{flow}"
|
|
)
|
|
end
|
|
end
|
|
|
|
def settings(conn, %{"domain" => domain}) do
|
|
redirect(conn, to: Routes.site_path(conn, :settings_general, domain))
|
|
end
|
|
|
|
def settings_general(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
conn
|
|
|> render("settings_general.html",
|
|
site: site,
|
|
changeset: Plausible.Site.changeset(site, %{}),
|
|
connect_live_socket: true,
|
|
dogfood_page_path: "/:dashboard/settings/general",
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_people(conn, _params) do
|
|
site = Repo.preload(conn.assigns.site, :team)
|
|
|
|
%{memberships: memberships, invitations: invitations} =
|
|
Sites.list_people(site)
|
|
|
|
conn
|
|
|> render("settings_people.html",
|
|
site: site,
|
|
memberships: memberships,
|
|
invitations: invitations,
|
|
dogfood_page_path: "/:dashboard/settings/people",
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_visibility(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
conn
|
|
|> render("settings_visibility.html",
|
|
site: site,
|
|
dogfood_page_path: "/:dashboard/settings/visibility",
|
|
connect_live_socket: true,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_goals(conn, _params) do
|
|
conn
|
|
|> render("settings_goals.html",
|
|
dogfood_page_path: "/:dashboard/settings/goals",
|
|
connect_live_socket: true,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_funnels(conn, _params) do
|
|
conn
|
|
|> render("settings_funnels.html",
|
|
dogfood_page_path: "/:dashboard/settings/funnels",
|
|
connect_live_socket: true,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_props(conn, _params) do
|
|
conn
|
|
|> render("settings_props.html",
|
|
dogfood_page_path: "/:dashboard/settings/properties",
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"},
|
|
connect_live_socket: true
|
|
)
|
|
end
|
|
|
|
def settings_email_reports(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
conn
|
|
|> render("settings_email_reports.html",
|
|
site: site,
|
|
weekly_report: Repo.get_by(Plausible.Site.WeeklyReport, site_id: site.id),
|
|
monthly_report: Repo.get_by(Plausible.Site.MonthlyReport, site_id: site.id),
|
|
spike_notification:
|
|
Repo.get_by(Plausible.Site.TrafficChangeNotification, site_id: site.id, type: :spike),
|
|
drop_notification:
|
|
Repo.get_by(Plausible.Site.TrafficChangeNotification, site_id: site.id, type: :drop),
|
|
dogfood_page_path: "/:dashboard/settings/email-reports",
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_danger_zone(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
conn
|
|
|> render("settings_danger_zone.html",
|
|
site: site,
|
|
dogfood_page_path: "/:dashboard/settings/danger-zone",
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_integrations(conn, _params) do
|
|
site =
|
|
conn.assigns.site
|
|
|> Repo.preload([:google_auth])
|
|
|
|
search_console_domains =
|
|
if site.google_auth do
|
|
Plausible.Google.API.fetch_verified_properties(site.google_auth)
|
|
end
|
|
|
|
has_plugins_tokens? = Plausible.Plugins.API.Tokens.any?(site)
|
|
|
|
conn
|
|
|> render("settings_integrations.html",
|
|
site: site,
|
|
has_plugins_tokens?: has_plugins_tokens?,
|
|
search_console_domains: search_console_domains,
|
|
dogfood_page_path: "/:dashboard/settings/integrations",
|
|
connect_live_socket: true,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_shields(conn, %{"shield" => shield})
|
|
when shield in ["ip_addresses", "countries", "pages", "hostnames"] do
|
|
site = conn.assigns.site
|
|
|
|
conn
|
|
|> render("settings_shields.html",
|
|
site: site,
|
|
shield: shield,
|
|
dogfood_page_path: "/:dashboard/settings/shields/#{shield}",
|
|
connect_live_socket: true,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def settings_imports_exports(conn, _params) do
|
|
site = conn.assigns.site
|
|
|
|
conn
|
|
|> render("settings_imports_exports.html",
|
|
site: site,
|
|
dogfood_page_path: "/:dashboard/settings/imports-exports",
|
|
connect_live_socket: true,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
|
|
def update_google_auth(conn, %{"google_auth" => attrs}) do
|
|
site = conn.assigns[:site] |> Repo.preload(:google_auth)
|
|
|
|
Plausible.Site.GoogleAuth.set_property(site.google_auth, attrs)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Google integration saved successfully")
|
|
|> redirect(to: Routes.site_path(conn, :settings_integrations, site.domain))
|
|
end
|
|
|
|
def delete_google_auth(conn, _params) do
|
|
site =
|
|
conn.assigns[:site]
|
|
|> Repo.preload(:google_auth)
|
|
|
|
if site.google_auth do
|
|
Repo.delete!(site.google_auth)
|
|
end
|
|
|
|
put_flash(conn, :success, "Google account unlinked from Plausible")
|
|
redirect(conn, to: Routes.site_path(conn, :settings_integrations, site.domain))
|
|
end
|
|
|
|
def update_settings(conn, %{"site" => site_params}) do
|
|
site = conn.assigns[:site]
|
|
changeset = Plausible.Site.update_changeset(site, site_params)
|
|
|
|
case Repo.update(changeset) do
|
|
{:ok, site} ->
|
|
site_session_key = "authorized_site__" <> site.domain
|
|
|
|
conn
|
|
|> put_session(site_session_key, nil)
|
|
|> put_flash(:success, "Your site settings have been saved")
|
|
|> redirect(to: Routes.site_path(conn, :settings_general, site.domain))
|
|
|
|
{:error, changeset} ->
|
|
conn
|
|
|> put_flash(:error, "Could not update your site settings")
|
|
|> render("settings_general.html",
|
|
site: site,
|
|
changeset: changeset,
|
|
layout: {PlausibleWeb.LayoutView, "site_settings.html"}
|
|
)
|
|
end
|
|
end
|
|
|
|
def reset_stats(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
Plausible.Purge.reset!(site)
|
|
|
|
conn
|
|
|> put_flash(:success, "#{site.domain} stats will be reset in a few minutes")
|
|
|> redirect(to: Routes.site_path(conn, :settings_danger_zone, site.domain))
|
|
end
|
|
|
|
def delete_site(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
Plausible.Site.Removal.run(site)
|
|
|
|
conn
|
|
|> put_flash(:success, "Your site and page views deletion process has started.")
|
|
|> redirect(to: "/sites")
|
|
end
|
|
|
|
def make_public(conn, _params) do
|
|
site =
|
|
conn.assigns[:site]
|
|
|> Plausible.Site.make_public()
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Stats for #{site.domain} are now public.")
|
|
|> redirect(to: Routes.site_path(conn, :settings_visibility, site.domain))
|
|
end
|
|
|
|
def make_private(conn, _params) do
|
|
site =
|
|
conn.assigns[:site]
|
|
|> Plausible.Site.make_private()
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Stats for #{site.domain} are now private.")
|
|
|> redirect(to: Routes.site_path(conn, :settings_visibility, site.domain))
|
|
end
|
|
|
|
def enable_weekly_report(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
result =
|
|
Plausible.Site.WeeklyReport.changeset(%Plausible.Site.WeeklyReport{}, %{
|
|
site_id: site.id,
|
|
recipients: [conn.assigns[:current_user].email]
|
|
})
|
|
|> Repo.insert()
|
|
|
|
:ok = tolerate_unique_contraint_violation(result, "weekly_reports_site_id_index")
|
|
|
|
conn
|
|
|> put_flash(:success, "You will receive an email report every Monday going forward")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def disable_weekly_report(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
Repo.delete_all(from(wr in Plausible.Site.WeeklyReport, where: wr.site_id == ^site.id))
|
|
|
|
conn
|
|
|> put_flash(:success, "You will not receive weekly email reports going forward")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def add_weekly_report_recipient(conn, %{"recipient" => recipient}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.get_by(Plausible.Site.WeeklyReport, site_id: site.id)
|
|
|> Plausible.Site.WeeklyReport.add_recipient(recipient)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Added #{recipient} as a recipient for the weekly report")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def remove_weekly_report_recipient(conn, %{"recipient" => recipient}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.get_by(Plausible.Site.WeeklyReport, site_id: site.id)
|
|
|> Plausible.Site.WeeklyReport.remove_recipient(recipient)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(
|
|
:success,
|
|
"Removed #{recipient} as a recipient for the weekly report"
|
|
)
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def enable_monthly_report(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
|
|
result =
|
|
%Plausible.Site.MonthlyReport{}
|
|
|> Plausible.Site.MonthlyReport.changeset(%{
|
|
site_id: site.id,
|
|
recipients: [conn.assigns[:current_user].email]
|
|
})
|
|
|> Repo.insert()
|
|
|
|
:ok = tolerate_unique_contraint_violation(result, "monthly_reports_site_id_index")
|
|
|
|
conn
|
|
|> put_flash(:success, "You will receive an email report every month going forward")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def disable_monthly_report(conn, _params) do
|
|
site = conn.assigns[:site]
|
|
Repo.delete_all(from(mr in Plausible.Site.MonthlyReport, where: mr.site_id == ^site.id))
|
|
|
|
conn
|
|
|> put_flash(:success, "You will not receive monthly email reports going forward")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def add_monthly_report_recipient(conn, %{"recipient" => recipient}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.get_by(Plausible.Site.MonthlyReport, site_id: site.id)
|
|
|> Plausible.Site.MonthlyReport.add_recipient(recipient)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Added #{recipient} as a recipient for the monthly report")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def remove_monthly_report_recipient(conn, %{"recipient" => recipient}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.get_by(Plausible.Site.MonthlyReport, site_id: site.id)
|
|
|> Plausible.Site.MonthlyReport.remove_recipient(recipient)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(
|
|
:success,
|
|
"Removed #{recipient} as a recipient for the monthly report"
|
|
)
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def enable_traffic_change_notification(conn, %{"type" => type}) do
|
|
site = conn.assigns[:site]
|
|
|
|
res =
|
|
Plausible.Site.TrafficChangeNotification.changeset(
|
|
%Plausible.Site.TrafficChangeNotification{},
|
|
%{
|
|
site_id: site.id,
|
|
type: type,
|
|
threshold: if(type == "spike", do: 10, else: 1),
|
|
recipients: [conn.assigns[:current_user].email]
|
|
}
|
|
)
|
|
|> Repo.insert()
|
|
|
|
case res do
|
|
{:ok, _} ->
|
|
conn
|
|
|> put_flash(:success, "Traffic #{type} notifications enabled")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
|
|
{:error, _} ->
|
|
conn
|
|
|> put_flash(:error, "Unable to create a #{type} notification")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
end
|
|
|
|
def disable_traffic_change_notification(conn, %{"type" => type}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.delete_all(
|
|
from(mr in Plausible.Site.TrafficChangeNotification,
|
|
where: mr.site_id == ^site.id and mr.type == ^type
|
|
)
|
|
)
|
|
|
|
conn
|
|
|> put_flash(:success, "Traffic #{type} notifications disabled")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def update_traffic_change_notification(conn, %{
|
|
"traffic_change_notification" => params,
|
|
"type" => type
|
|
}) do
|
|
site = conn.assigns[:site]
|
|
|
|
notification =
|
|
Repo.get_by(Plausible.Site.TrafficChangeNotification, site_id: site.id, type: type)
|
|
|
|
Plausible.Site.TrafficChangeNotification.changeset(notification, params)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Notification settings updated")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def add_traffic_change_notification_recipient(conn, %{"recipient" => recipient, "type" => type}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.get_by(Plausible.Site.TrafficChangeNotification, site_id: site.id, type: type)
|
|
|> Plausible.Site.TrafficChangeNotification.add_recipient(recipient)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(:success, "Added #{recipient} as a recipient for the traffic spike notification")
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def remove_traffic_change_notification_recipient(conn, %{
|
|
"recipient" => recipient,
|
|
"type" => type
|
|
}) do
|
|
site = conn.assigns[:site]
|
|
|
|
Repo.get_by(Plausible.Site.TrafficChangeNotification, site_id: site.id, type: type)
|
|
|> Plausible.Site.TrafficChangeNotification.remove_recipient(recipient)
|
|
|> Repo.update!()
|
|
|
|
conn
|
|
|> put_flash(
|
|
:success,
|
|
"Removed #{recipient} as a recipient for the monthly report"
|
|
)
|
|
|> redirect(to: Routes.site_path(conn, :settings_email_reports, site.domain))
|
|
end
|
|
|
|
def forget_import(conn, %{"import_id" => import_id}) do
|
|
site = conn.assigns.site
|
|
|
|
if site_import = Plausible.Imported.get_import(site, import_id) do
|
|
Oban.cancel_all_jobs(
|
|
from(j in Oban.Job,
|
|
where:
|
|
j.queue == "analytics_imports" and
|
|
fragment("(? ->> 'import_id')::int", j.args) == ^site_import.id
|
|
)
|
|
)
|
|
|
|
Plausible.Purge.delete_imported_stats!(site_import)
|
|
|
|
Plausible.Repo.delete!(site_import)
|
|
end
|
|
|
|
conn
|
|
|> put_flash(:success, "Imported data has been cleared")
|
|
|> redirect(to: Routes.site_path(conn, :settings_imports_exports, site.domain))
|
|
end
|
|
|
|
def forget_imported(conn, _params) do
|
|
site = conn.assigns.site
|
|
|
|
import_ids =
|
|
site
|
|
|> Plausible.Imported.list_all_imports()
|
|
|> Enum.map(& &1.id)
|
|
|
|
if import_ids != [] do
|
|
Oban.cancel_all_jobs(
|
|
from(j in Oban.Job,
|
|
where:
|
|
j.queue == "analytics_imports" and
|
|
fragment("(? ->> 'import_id')::int", j.args) in ^import_ids
|
|
)
|
|
)
|
|
|
|
Plausible.Purge.delete_imported_stats!(site)
|
|
|
|
Plausible.Imported.delete_imports_for_site(site)
|
|
end
|
|
|
|
conn
|
|
|> put_flash(:success, "Imported data has been cleared")
|
|
|> redirect(to: Routes.site_path(conn, :settings_integrations, site.domain))
|
|
end
|
|
|
|
on_ee do
|
|
def download_export(conn, _params) do
|
|
%{id: site_id, domain: domain} = conn.assigns.site
|
|
|
|
if s3_export = Plausible.Exports.get_s3_export!(site_id) do
|
|
s3_bucket = Plausible.S3.exports_bucket()
|
|
download_url = Plausible.S3.download_url(s3_bucket, s3_export.path)
|
|
redirect(conn, external: download_url)
|
|
else
|
|
conn
|
|
|> put_flash(:error, "Export not found")
|
|
|> redirect(to: Routes.site_path(conn, :settings_imports_exports, domain))
|
|
end
|
|
end
|
|
else
|
|
def download_export(conn, _params) do
|
|
%{id: site_id, domain: domain, timezone: timezone} = conn.assigns.site
|
|
|
|
if local_export = Plausible.Exports.get_local_export(site_id, domain, timezone) do
|
|
%{path: export_path, name: name} = local_export
|
|
|
|
conn
|
|
|> put_resp_content_type("application/zip")
|
|
|> put_resp_header("content-disposition", Plausible.Exports.content_disposition(name))
|
|
|> send_file(200, export_path)
|
|
else
|
|
conn
|
|
|> put_flash(:error, "Export not found")
|
|
|> redirect(to: Routes.site_path(conn, :settings_imports_exports, domain))
|
|
end
|
|
end
|
|
end
|
|
|
|
def csv_import(conn, _params) do
|
|
conn
|
|
|> assign(:skip_plausible_tracking, true)
|
|
|> render("csv_import.html",
|
|
connect_live_socket: true
|
|
)
|
|
end
|
|
|
|
defp tolerate_unique_contraint_violation(result, name) do
|
|
case result do
|
|
{:ok, _} ->
|
|
:ok
|
|
|
|
{:error,
|
|
%{
|
|
errors: [
|
|
site_id: {_, [constraint: :unique, constraint_name: ^name]}
|
|
]
|
|
}} ->
|
|
:ok
|
|
|
|
other ->
|
|
other
|
|
end
|
|
end
|
|
end
|