├── native
    └── ketbin_utils_syntax
    │   ├── .gitignore
    │   ├── .cargo
    │       └── config
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── src
    │       └── lib.rs
    │   └── Cargo.lock
├── rel
    └── overlays
    │   └── bin
    │       ├── server.bat
    │       └── server
├── assets
    ├── .babelrc
    ├── static
    │   ├── favicon.ico
    │   ├── images
    │   │   └── phoenix.png
    │   ├── fonts
    │   │   └── jetbrains_mono_variable.ttf
    │   └── robots.txt
    ├── postcss.config.js
    ├── tailwind.config.js
    ├── js
    │   ├── app.js
    │   └── socket.js
    ├── package.json
    ├── build.js
    └── css
    │   ├── app.css
    │   ├── markdown.css
    │   └── highlight.css
├── test
    ├── test_helper.exs
    ├── ketbin_web
    │   ├── views
    │   │   ├── page_view_test.exs
    │   │   ├── layout_view_test.exs
    │   │   └── error_view_test.exs
    │   └── controllers
    │   │   ├── page_controller_test.exs
    │   │   ├── user_registration_controller_test.exs
    │   │   ├── paste_controller_test.exs
    │   │   ├── user_session_controller_test.exs
    │   │   ├── user_confirmation_controller_test.exs
    │   │   ├── user_reset_password_controller_test.exs
    │   │   ├── user_settings_controller_test.exs
    │   │   └── user_auth_test.exs
    ├── support
    │   ├── fixtures
    │   │   └── accounts_fixtures.ex
    │   ├── channel_case.ex
    │   ├── data_case.ex
    │   └── conn_case.ex
    └── ketbin
    │   └── pastes_test.exs
├── lib
    ├── ketbin
    │   ├── mailer.ex
    │   ├── repo.ex
    │   ├── utils
    │   │   └── syntax.ex
    │   ├── pastes
    │   │   ├── paste.ex
    │   │   └── utils.ex
    │   ├── application.ex
    │   ├── accounts
    │   │   ├── user_notifier.ex
    │   │   ├── user_token.ex
    │   │   └── user.ex
    │   ├── pastes.ex
    │   └── accounts.ex
    ├── ketbin_web
    │   ├── views
    │   │   ├── layout_view.ex
    │   │   ├── page_view.ex
    │   │   ├── user_session_view.ex
    │   │   ├── user_settings_view.ex
    │   │   ├── user_confirmation_view.ex
    │   │   ├── user_registration_view.ex
    │   │   ├── user_reset_password_view.ex
    │   │   ├── api
    │   │   │   └── paste_view.ex
    │   │   ├── error_view.ex
    │   │   └── error_helpers.ex
    │   ├── templates
    │   │   ├── page
    │   │   │   ├── index.html.heex
    │   │   │   ├── edit.html.heex
    │   │   │   ├── pastes.html.heex
    │   │   │   ├── shorten.html.heex
    │   │   │   ├── show.html.heex
    │   │   │   └── form.html.heex
    │   │   ├── user_reset_password
    │   │   │   ├── new.html.heex
    │   │   │   └── edit.html.heex
    │   │   ├── user_confirmation
    │   │   │   └── new.html.heex
    │   │   ├── user_registration
    │   │   │   └── new.html.heex
    │   │   ├── user_session
    │   │   │   └── new.html.heex
    │   │   ├── layout
    │   │   │   ├── _user_menu.html.heex
    │   │   │   └── app.html.heex
    │   │   └── user_settings
    │   │   │   └── edit.html.heex
    │   ├── gettext.ex
    │   ├── controllers
    │   │   ├── user_session_controller.ex
    │   │   ├── user_registration_controller.ex
    │   │   ├── api
    │   │   │   └── paste_controller.ex
    │   │   ├── user_confirmation_controller.ex
    │   │   ├── user_reset_password_controller.ex
    │   │   ├── user_settings_controller.ex
    │   │   ├── page_controller.ex
    │   │   └── user_auth.ex
    │   ├── channels
    │   │   └── user_socket.ex
    │   ├── endpoint.ex
    │   ├── telemetry.ex
    │   └── router.ex
    ├── ketbin.ex
    ├── release.ex
    └── ketbin_web.ex
├── priv
    ├── repo
    │   ├── migrations
    │   │   ├── .formatter.exs
    │   │   ├── 20240507005300_add_timestamps_pastes.exs
    │   │   ├── 20210811213141_create_pastes.exs
    │   │   └── 20210811065554_create_users_auth_tables.exs
    │   ├── seeds.exs
    │   └── structure.sql
    ├── cert.pem
    └── gettext
    │   ├── en
    │       └── LC_MESSAGES
    │       │   └── errors.po
    │   └── errors.pot
├── renovate.json
├── Makefile
├── .formatter.exs
├── sample.env
├── config
    ├── dev.secret.sample.exs
    ├── test.exs
    ├── config.exs
    ├── dev.exs
    ├── prod.exs
    └── releases.exs
├── startup.sh
├── fly.toml
├── .dockerignore
├── .gitignore
├── .github
    └── workflows
    │   └── fly.yml
├── Dockerfile
├── README.md
├── mix.exs
└── mix.lock


/native/ketbin_utils_syntax/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | 


--------------------------------------------------------------------------------
/rel/overlays/bin/server.bat:
--------------------------------------------------------------------------------
1 | set PHX_SERVER=true
2 | call "%~dp0\ketbin" start
3 | 


--------------------------------------------------------------------------------
/assets/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 |     "presets": [
3 |         "@babel/preset-env"
4 |     ]
5 | }
6 | 


--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | Ecto.Adapters.SQL.Sandbox.mode(Ketbin.Repo, :manual)
3 | 


--------------------------------------------------------------------------------
/lib/ketbin/mailer.ex:
--------------------------------------------------------------------------------
1 | defmodule Ketbin.Mailer do
2 |   use Swoosh.Mailer, otp_app: :ketbin
3 | end
4 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 |   import_deps: [:ecto_sql],
3 |   inputs: ["*.exs"]
4 | ]
5 | 


--------------------------------------------------------------------------------
/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SphericalKat/katbin/HEAD/assets/static/favicon.ico


--------------------------------------------------------------------------------
/lib/ketbin_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.LayoutView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.PageView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/rel/overlays/bin/server:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | cd -P -- "$(dirname -- "$0")"
3 | PHX_SERVER=true exec ./ketbin start
4 | 


--------------------------------------------------------------------------------
/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SphericalKat/katbin/HEAD/assets/static/images/phoenix.png


--------------------------------------------------------------------------------
/lib/ketbin_web/views/user_session_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.UserSessionView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/user_settings_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.UserSettingsView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/user_confirmation_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.UserConfirmationView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/user_registration_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.UserRegistrationView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/user_reset_password_view.ex:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.UserResetPasswordView do
2 |   use KetbinWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/test/ketbin_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.PageViewTest do
2 |   use KetbinWeb.ConnCase, async: true
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/page/index.html.heex:
--------------------------------------------------------------------------------
1 | <%= render "form.html", Map.put(assigns, :action, Routes.page_path(@conn, :create)) %>
2 | 


--------------------------------------------------------------------------------
/lib/ketbin/repo.ex:
--------------------------------------------------------------------------------
1 | defmodule Ketbin.Repo do
2 |   use Ecto.Repo,
3 |     otp_app: :ketbin,
4 |     adapter: Ecto.Adapters.Postgres
5 | end
6 | 


--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 |   "extends": [
4 |     "config:base"
5 |   ]
6 | }
7 | 


--------------------------------------------------------------------------------
/assets/static/fonts/jetbrains_mono_variable.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SphericalKat/katbin/HEAD/assets/static/fonts/jetbrains_mono_variable.ttf


--------------------------------------------------------------------------------
/assets/postcss.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   plugins: {
3 | 		"postcss-import": {},
4 |     tailwindcss: {},
5 |     autoprefixer: {},
6 |   },
7 | }
8 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | .PHONY: image
2 | image:
3 | 	docker build -t atechnohazard/katbin-elixir .
4 | 
5 | .PHONY: push
6 | push: image
7 | 	docker push atechnohazard/katbin-elixir


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/page/edit.html.heex:
--------------------------------------------------------------------------------
1 | <%= render "form.html", Map.put(assigns, :action, Routes.page_path(@conn, :update, @paste)) |> Map.put(:is_edit, true) %>
2 | 


--------------------------------------------------------------------------------
/native/ketbin_utils_syntax/.cargo/config:
--------------------------------------------------------------------------------
1 | [target.'cfg(target_os = "macos")']
2 | rustflags = [
3 |     "-C", "link-arg=-undefined",
4 |     "-C", "link-arg=dynamic_lookup",
5 | ]
6 | 


--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 |   import_deps: [:ecto, :phoenix],
3 |   inputs: ["*.{ex,exs}", "priv/*/seeds.exs", "{config,lib,test}/**/*.{ex,exs}"],
4 |   subdirectories: ["priv/*/migrations"]
5 | ]
6 | 


--------------------------------------------------------------------------------
/sample.env:
--------------------------------------------------------------------------------
1 | DATABASE_URL='<insert db url here>'
2 | SECRET_KEY_BASE='<insert secret key here>'
3 | SWOOSH_USERNAME='noreply@katb.in'
4 | SWOOSH_PASSWORD='<insert your password here>'
5 | SWOOSH_SMTP_RELAY='smtp.example.com'


--------------------------------------------------------------------------------
/assets/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/page_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.PageControllerTest do
2 |   use KetbinWeb.ConnCase
3 | 
4 |   test "GET /", %{conn: conn} do
5 |     conn = get(conn, "/")
6 |     assert html_response(conn, 200) =~ "Welcome to Phoenix!"
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/lib/ketbin.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin do
 2 |   @moduledoc """
 3 |   Ketbin keeps the contexts that define your domain
 4 |   and business logic.
 5 | 
 6 |   Contexts are also responsible for managing your data, regardless
 7 |   if it comes from the database, an external API or others.
 8 |   """
 9 | end
10 | 


--------------------------------------------------------------------------------
/test/ketbin_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule KetbinWeb.LayoutViewTest do
2 |   use KetbinWeb.ConnCase, async: true
3 | 
4 |   # When testing helpers, you may want to import Phoenix.HTML and
5 |   # use functions such as safe_to_string() to convert the helper
6 |   # result into an HTML string.
7 |   # import Phoenix.HTML
8 | end
9 | 


--------------------------------------------------------------------------------
/lib/ketbin/utils/syntax.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Utils.Syntax do
 2 |   # use Rustler, otp_app: :ketbin, crate: "ketbin_utils_syntax"
 3 | 
 4 |   # When your NIF is loaded, it will override this function.
 5 |   def add(_a, _b), do: error()
 6 | 
 7 |   def highlight_text(text, _lang), do:
 8 |     text
 9 | 
10 |   defp error(), do: :erlang.nif_error(:nif_not_loaded)
11 | end
12 | 


--------------------------------------------------------------------------------
/native/ketbin_utils_syntax/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "ketbin_utils_syntax"
 3 | version = "0.1.0"
 4 | authors = ["SphericalKat <amolele@gmail.com>"]
 5 | edition = "2018"
 6 | 
 7 | [lib]
 8 | name = "ketbin_utils_syntax"
 9 | path = "src/lib.rs"
10 | crate-type = ["cdylib"]
11 | 
12 | [dependencies]
13 | rustler = { version = "*", features = ["nif_version_2_17"] }
14 | syntect = "4.6"
15 | 


--------------------------------------------------------------------------------
/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
 1 | # Script for populating the database. You can run it as:
 2 | #
 3 | #     mix run priv/repo/seeds.exs
 4 | #
 5 | # Inside the script, you can read and write to any of your
 6 | # repositories directly:
 7 | #
 8 | #     Ketbin.Repo.insert!(%Ketbin.SomeSchema{})
 9 | #
10 | # We recommend using the bang functions (`insert!`, `update!`
11 | # and so on) as they will fail if something goes wrong.
12 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/20240507005300_add_timestamps_pastes.exs:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Repo.Migrations.AddTimestampsPastes do
 2 |   use Ecto.Migration
 3 | 
 4 |   def change do
 5 |     alter table(:pastes) do
 6 |       add :inserted_at, :naive_datetime, null: false, default: fragment("CURRENT_TIMESTAMP")
 7 |       add :updated_at, :naive_datetime, null: false, default: fragment("CURRENT_TIMESTAMP")
 8 |     end
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/api/paste_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.Api.PasteView do
 2 |   use KetbinWeb, :view
 3 | 
 4 |   def render("paste.json", %{paste: paste}) do
 5 |     %{
 6 |       id: paste.id,
 7 |       content: paste.content,
 8 |       is_url: paste.is_url
 9 |     }
10 |   end
11 | 
12 |   def render("error.json", _assigns) do
13 |     %{
14 |       success: false,
15 |       msg: "Something went wrong"
16 |     }
17 |   end
18 | end
19 | 


--------------------------------------------------------------------------------
/assets/tailwind.config.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   content: [
 3 |     "../lib/**/*.ex",
 4 |     "../lib/**/*.leex",
 5 |     "../lib/**/*.eex",
 6 |     "../lib/**/*.heex",
 7 |     "./js/**/*.js",
 8 |   ],
 9 |   darkMode: 'media', // or 'media' or 'class'
10 |   theme: {
11 |     extend: {
12 |       colors: {
13 |         amber: "#ff9800",
14 |         "light-grey": "#212121",
15 |       },
16 |     },
17 |   },
18 |   variants: {
19 |     extend: {},
20 |   },
21 |   plugins: [],
22 | };
23 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/page/pastes.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex relative flex-col w-full h-full">
 2 |     <ul class="break-word py-4 h-full w-full overflow-y-auto">
 3 |         <%= for paste <- @pastes do %>
 4 |             <li class="flex flex-row items-center justify-between">
 5 |                 <a href={ Routes.page_path(@conn, :show, paste) } class="">
 6 | https://katb.in/v/<%= paste.id %>
 7 |                 </a>
 8 |             </li>    
 9 |         <% end %>
10 |     </ul>
11 | </div>
12 | 


--------------------------------------------------------------------------------
/test/ketbin_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.ErrorViewTest do
 2 |   use KetbinWeb.ConnCase, async: true
 3 | 
 4 |   # Bring render/3 and render_to_string/3 for testing custom views
 5 |   import Phoenix.View
 6 | 
 7 |   test "renders 404.html" do
 8 |     assert render_to_string(KetbinWeb.ErrorView, "404.html", []) == "Not Found"
 9 |   end
10 | 
11 |   test "renders 500.html" do
12 |     assert render_to_string(KetbinWeb.ErrorView, "500.html", []) == "Internal Server Error"
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/20210811213141_create_pastes.exs:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Repo.Migrations.CreatePastes do
 2 |   use Ecto.Migration
 3 | 
 4 |   def change do
 5 |     create_if_not_exists table(:pastes, primary_key: false) do
 6 |       add :id, :string, primary_key: true
 7 |       add :is_url, :boolean, default: false, null: false
 8 |       add :content, :text, null: false
 9 |       add :belongs_to, references(:users, on_delete: :delete_all)
10 |     end
11 | 
12 |     create_if_not_exists index(:pastes, [:belongs_to])
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/assets/js/app.js:
--------------------------------------------------------------------------------
 1 | // We need to import the CSS so that webpack will load it.
 2 | // The MiniCssExtractPlugin is used to separate it out into
 3 | // its own CSS file.
 4 | import "../css/app.css";
 5 | 
 6 | // webpack automatically bundles all modules in your
 7 | // entry points. Those entry points can be configured
 8 | // in "webpack.config.js".
 9 | //
10 | // Import deps with the dep name or local files with a relative path, for example:
11 | //
12 | //     import {Socket} from "phoenix"
13 | //     import socket from "./socket"
14 | //
15 | import "phoenix_html";
16 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/error_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.ErrorView do
 2 |   use KetbinWeb, :view
 3 | 
 4 |   # If you want to customize a particular status code
 5 |   # for a certain format, you may uncomment below.
 6 |   # def render("500.html", _assigns) do
 7 |   #   "Internal Server Error"
 8 |   # end
 9 | 
10 |   # By default, Phoenix returns the status message from
11 |   # the template name. For example, "404.html" becomes
12 |   # "Not Found".
13 |   def template_not_found(template, _assigns) do
14 |     Phoenix.Controller.status_message_from_template(template)
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/native/ketbin_utils_syntax/README.md:
--------------------------------------------------------------------------------
 1 | # NIF for Elixir.Ketbin.Utils.Syntax
 2 | 
 3 | ## To build the NIF module:
 4 | 
 5 | - Your NIF will now build along with your project.
 6 | 
 7 | ## To load the NIF:
 8 | 
 9 | ```elixir
10 | defmodule Ketbin.Utils.Syntax do
11 |     use Rustler, otp_app: :ketbin, crate: "ketbin_utils_syntax"
12 | 
13 |     # When your NIF is loaded, it will override this function.
14 |     def add(_a, _b), do: :erlang.nif_error(:nif_not_loaded)
15 | end
16 | ```
17 | 
18 | ## Examples
19 | 
20 | [This](https://github.com/hansihe/NifIo) is a complete example of a NIF written in Rust.
21 | 


--------------------------------------------------------------------------------
/assets/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "repository": {},
 3 |   "description": " ",
 4 |   "license": "MIT",
 5 |   "scripts": {
 6 |     "deploy": "NODE_ENV=production node build.js",
 7 |     "watch": "node build.js"
 8 |   },
 9 |   "dependencies": {
10 |     "phoenix": "file:../deps/phoenix",
11 |     "phoenix_html": "file:../deps/phoenix_html"
12 |   },
13 |   "devDependencies": {
14 |     "autoprefixer": "^10.3.1",
15 |     "esbuild": "^0.12.22",
16 |     "esbuild-plugin-postcss2": "0.0.9",
17 |     "fs-extra": "^10.0.0",
18 |     "postcss": "^8.3.6",
19 |     "postcss-import": "^15.0.0",
20 |     "tailwindcss": "^3.4.3"
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/config/dev.secret.sample.exs:
--------------------------------------------------------------------------------
 1 | import Mix.Config
 2 | 
 3 | # Configure your database
 4 | config :ketbin, Ketbin.Repo,
 5 |   username: "postgres",
 6 |   password: "postgres",
 7 |   database: "ketbin_dev",
 8 |   hostname: "localhost",
 9 |   show_sensitive_data_on_connection_error: true,
10 |   pool_size: 10
11 | 
12 | smtp_relay = "<Your SMTP Relay Here>"
13 | username = "<Your SMTP username here>"
14 | password = "<Your SMTP password here>"
15 | 
16 | # configure mailer
17 | config :ketbin, Ketbin.Mailer,
18 |   adapter: Swoosh.Adapters.SMTP,
19 |   relay: smtp_relay,
20 |   username: username,
21 |   password: password,
22 |   tls: :always,
23 |   auth: :always,
24 |   port: 587
25 | 


--------------------------------------------------------------------------------
/lib/ketbin/pastes/paste.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Pastes.Paste do
 2 |   use Ecto.Schema
 3 |   import Ecto.Changeset
 4 |   @derive {Jason.Encoder, only: [:content, :is_url, :belongs_to]}
 5 | 
 6 |   @primary_key {:id, :string, autogenerate: false}
 7 |   @derive {Phoenix.Param, key: :id}
 8 |   schema "pastes" do
 9 |     field :content, :string
10 |     field :is_url, :boolean, default: false
11 |     field :belongs_to, :id
12 | 
13 |     timestamps()
14 |   end
15 | 
16 |   @doc false
17 |   def changeset(paste, attrs) do
18 |     paste
19 |     |> cast(attrs, [:is_url, :content, :id, :belongs_to])
20 |     |> validate_required([:is_url, :content])
21 |     |> unique_constraint(:id, name: :pastes_pkey)
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/startup.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env sh
 2 | 
 3 | log() {
 4 |   printf "[%s] %s\n" "$1" "$2"
 5 | }
 6 | 
 7 | info() {
 8 |   log "INFO" "$1"
 9 | }
10 | 
11 | error() {
12 |   log "ERROR" "$1"
13 | }
14 | 
15 | migrate() {
16 |   info 'Performing migrations with "Ketbin.Release.migrate()"'
17 |   bin/ketbin eval "Ketbin.Release.migrate()"
18 | 
19 |   LAST_EXIT=$?
20 |   if [ $LAST_EXIT = 0 ]; then 
21 |     info 'Done performing migrations'
22 |   else
23 |     error "Unable to perform migrations, exit code $LAST_EXIT"
24 |     exit $LAST_EXIT
25 |   fi
26 | }
27 | 
28 | start() {
29 |   info 'Starting the application'
30 |   bin/ketbin start
31 | }
32 | 
33 | SLEEP_TIME=10
34 | info "Sleeping for $SLEEP_TIME seconds for all services to be up"
35 | sleep $SLEEP_TIME
36 | 
37 | migrate
38 | start


--------------------------------------------------------------------------------
/lib/release.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Release do
 2 |   @moduledoc """
 3 |   This module is used by the entrypoint to migrate the database
 4 |   """
 5 | 
 6 |   @app :ketbin
 7 | 
 8 |   require Logger
 9 | 
10 |   def migrate do
11 |     Application.ensure_all_started(@app)
12 |     load_app()
13 | 
14 |     for repo <- repos() do
15 |       {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
16 |     end
17 |   end
18 | 
19 |   def rollback(repo, version) do
20 |     load_app()
21 | 
22 |     {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
23 |   end
24 | 
25 |   defp repos do
26 |     Application.fetch_env!(@app, :ecto_repos)
27 |   end
28 | 
29 |   defp load_app do
30 |     Application.load(@app)
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/gettext.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.Gettext do
 2 |   @moduledoc """
 3 |   A module providing Internationalization with a gettext-based API.
 4 | 
 5 |   By using [Gettext](https://hexdocs.pm/gettext),
 6 |   your module gains a set of macros for translations, for example:
 7 | 
 8 |       import KetbinWeb.Gettext
 9 | 
10 |       # Simple translation
11 |       gettext("Here is the string to translate")
12 | 
13 |       # Plural translation
14 |       ngettext("Here is the string to translate",
15 |                "Here are the strings to translate",
16 |                3)
17 | 
18 |       # Domain-based translation
19 |       dgettext("errors", "Here is the error message to translate")
20 | 
21 |   See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 |   """
23 |   use Gettext, otp_app: :ketbin
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/user_session_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserSessionController do
 2 |   use KetbinWeb, :controller
 3 | 
 4 |   alias Ketbin.Accounts
 5 |   alias KetbinWeb.UserAuth
 6 | 
 7 |   def new(conn, _params) do
 8 |     render(conn, "new.html", error_message: nil)
 9 |   end
10 | 
11 |   def create(conn, %{"user" => user_params}) do
12 |     %{"email" => email, "password" => password} = user_params
13 | 
14 |     if user = Accounts.get_user_by_email_and_password(email, password) do
15 |       UserAuth.log_in_user(conn, user, user_params)
16 |     else
17 |       render(conn, "new.html", error_message: "Invalid email or password")
18 |     end
19 |   end
20 | 
21 |   def delete(conn, _params) do
22 |     conn
23 |     |> put_flash(:info, "Logged out successfully.")
24 |     |> UserAuth.log_out_user()
25 | 
26 |     conn
27 |   end
28 | end
29 | 


--------------------------------------------------------------------------------
/config/test.exs:
--------------------------------------------------------------------------------
 1 | import Config
 2 | 
 3 | # Only in tests, remove the complexity from the password hashing algorithm
 4 | config :bcrypt_elixir, :log_rounds, 1
 5 | 
 6 | # Configure your database
 7 | #
 8 | # The MIX_TEST_PARTITION environment variable can be used
 9 | # to provide built-in test partitioning in CI environment.
10 | # Run `mix help test` for more information.
11 | config :ketbin, Ketbin.Repo,
12 |   username: "postgres",
13 |   password: "postgres",
14 |   database: "ketbin_test#{System.get_env("MIX_TEST_PARTITION")}",
15 |   hostname: "localhost",
16 |   pool: Ecto.Adapters.SQL.Sandbox
17 | 
18 | # We don't run a server during test. If one is required,
19 | # you can enable the server option below.
20 | config :ketbin, KetbinWeb.Endpoint,
21 |   http: [port: 4002],
22 |   server: false
23 | 
24 | # Print only warnings and errors during test
25 | config :logger, level: :warn
26 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/user_reset_password/new.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex flex-col w-full h-full justify-center items-center">
 2 | 	<h1 class="font-bold text-4xl text-amber pt-4">Forgot your password?</h1>
 3 | 
 4 | 	<%= form_for :user, Routes.user_reset_password_path(@conn, :create), [class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
 5 | 		<div class="flex flex-col w-full">
 6 | 			<%= label f, :email %>
 7 | 			<%= email_input f, :email, [class: "text-black px-2 py-1 outline-none", required: true] %>
 8 | 		</div>
 9 | 
10 | 		<div class="bg-amber mt-4 rounded-sm px-2 py-1">
11 | 			<%= submit "Send instructions to reset password" %>
12 | 		</div>
13 | 	<% end %>
14 | 
15 | 	<p class="mb-4 text-amber">
16 | 		<%= link "Register", to: Routes.user_registration_path(@conn, :new) %> |
17 | 		<%= link "Log in", to: Routes.user_session_path(@conn, :new) %>
18 | 	</p>
19 | </div>
20 | 


--------------------------------------------------------------------------------
/lib/ketbin/pastes/utils.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Pastes.Utils do
 2 |   defp rand_vowel do
 3 |     String.graphemes("aeiou")
 4 |     |> Enum.take_random(1)
 5 |     |> Enum.at(0)
 6 |   end
 7 | 
 8 |   defp rand_consonant do
 9 |     String.graphemes("bcdfghjklmnpqrstvwxyz")
10 |     |> Enum.take_random(1)
11 |     |> Enum.at(0)
12 |   end
13 | 
14 |   def generate_key(length \\ 10) do
15 |     random = Enum.random([0, 1])
16 | 
17 |     Enum.map(0..length, fn i ->
18 |       if Integer.mod(i, 2) == random, do: rand_consonant(), else: rand_vowel()
19 |     end)
20 |     |> List.to_string()
21 |   end
22 | 
23 |   def is_url?(url) do
24 |     try do
25 |       uri = URI.parse(url)
26 | 
27 |       uri.scheme != nil && uri.host =~ "." &&
28 |         Enum.member?(["https", "http", "mailto"], uri.scheme) && !(uri.host =~ "katb.in")
29 |     rescue
30 |       FunctionClauseError -> false
31 |     end
32 |   end
33 | end
34 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/user_confirmation/new.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex flex-col w-full h-full justify-center items-center">
 2 | 	<h1 class="font-bold text-4xl text-amber pt-4">Resend confirmation instructions</h1>
 3 | 
 4 | 	<%= form_for :user, Routes.user_confirmation_path(@conn, :create), [class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
 5 | 		<div class="flex flex-col w-full">
 6 | 			<%= label f, :email %>
 7 | 			<%= email_input f, :email, [class: "text-black px-2 py-1 outline-none", required: true] %>
 8 | 		</div>
 9 | 
10 | 		<div class="bg-amber mt-4 rounded-sm px-2 py-1">
11 | 			<%= submit "Resend confirmation instructions" %>
12 | 		</div>
13 | 	<% end %>
14 | 
15 | 	<p class="mb-4 text-amber">
16 | 		<%= link "Register", to: Routes.user_registration_path(@conn, :new) %> |
17 | 		<%= link "Log in", to: Routes.user_session_path(@conn, :new) %>
18 | 	</p>
19 | </div>
20 | 


--------------------------------------------------------------------------------
/test/support/fixtures/accounts_fixtures.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.AccountsFixtures do
 2 |   @moduledoc """
 3 |   This module defines test helpers for creating
 4 |   entities via the `Ketbin.Accounts` context.
 5 |   """
 6 | 
 7 |   def unique_user_email, do: "user#{System.unique_integer()}@example.com"
 8 |   def valid_user_password, do: "hello world!"
 9 | 
10 |   def valid_user_attributes(attrs \\ %{}) do
11 |     Enum.into(attrs, %{
12 |       email: unique_user_email(),
13 |       password: valid_user_password()
14 |     })
15 |   end
16 | 
17 |   def user_fixture(attrs \\ %{}) do
18 |     {:ok, user} =
19 |       attrs
20 |       |> valid_user_attributes()
21 |       |> Ketbin.Accounts.register_user()
22 | 
23 |     user
24 |   end
25 | 
26 |   def extract_user_token(fun) do
27 |     {:ok, captured} = fun.(&"[TOKEN]#{&1}[TOKEN]")
28 |     [_, token, _] = String.split(captured.body, "[TOKEN]")
29 |     token
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/page/shorten.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex relative flex-col w-full h-full">
 2 | 	<div class="flex absolute top-0 right-0 p-4">
 3 | 		<%= if @show_edit do%>
 4 | 			<a href={ Routes.page_path(@conn, :edit, @paste.id) } class="text-white hover:text-amber">
 5 | 			<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="h-6 w-6 cursor-pointer fill-current">
 6 | 				<path d="M3 17.46v3.04c0 .28.22.5.5.5h3.04c.13 0 .26-.05.35-.15L17.81 9.94l-3.75-3.75L3.15 17.1c-.1.1-.15.22-.15.36zM20.71 7.04a.996.996 0 0 0 0-1.41l-2.34-2.34a.996.996 0 0 0-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path>
 7 | 			</svg>
 8 | 		</a>
 9 | 		<% end %>
10 | 	</div>
11 | 	<div class="break-word px-6 py-4 h-full w-full overflow-y-auto">
12 |         <span>
13 |             Your shortened url is: <a href={Routes.page_path(@conn, :show, @paste.id) }>https://katb.in/<%= @paste.id %></a>
14 |         </span>
15 |     </div>
16 | </div>
17 | 


--------------------------------------------------------------------------------
/native/ketbin_utils_syntax/src/lib.rs:
--------------------------------------------------------------------------------
 1 | use syntect::{
 2 |     html::{ClassStyle, ClassedHTMLGenerator},
 3 |     parsing::SyntaxSet,
 4 |     util::LinesWithEndings,
 5 | };
 6 | 
 7 | #[rustler::nif]
 8 | fn add(a: i64, b: i64) -> i64 {
 9 |     a + b
10 | }
11 | 
12 | #[rustler::nif]
13 | pub fn highlight_text(text: String, lang: String) -> String {
14 |     let syntax_set = SyntaxSet::load_defaults_newlines();
15 | 
16 |     let syntax = syntax_set
17 |         .find_syntax_by_extension(&lang)
18 |         .unwrap_or(syntax_set.find_syntax_plain_text());
19 | 
20 |     let mut rs_html_generator =
21 |         ClassedHTMLGenerator::new_with_class_style(syntax, &syntax_set, ClassStyle::Spaced);
22 | 
23 |     for line in LinesWithEndings::from(&text) {
24 |         rs_html_generator.parse_html_for_line_which_includes_newline(&line)
25 |     }
26 | 
27 |     rs_html_generator.finalize()
28 | }
29 | 
30 | rustler::init!("Elixir.Ketbin.Utils.Syntax", [add, highlight_text]);
31 | 


--------------------------------------------------------------------------------
/fly.toml:
--------------------------------------------------------------------------------
 1 | # fly.toml file generated for katbin on 2022-05-06T17:46:21+05:30
 2 | 
 3 | app = "katbin"
 4 | 
 5 | kill_signal = "SIGTERM"
 6 | kill_timeout = 5
 7 | processes = []
 8 | 
 9 | # [deploy]
10 | #   release_command = "/app/bin/migrate"
11 | 
12 | [env]
13 |   PHX_HOST = "katbin.fly.dev"
14 |   PORT = "8080"
15 | 
16 | [experimental]
17 |   allowed_public_ports = []
18 |   auto_rollback = true
19 | 
20 | [[services]]
21 |   http_checks = []
22 |   internal_port = 8080
23 |   processes = ["app"]
24 |   protocol = "tcp"
25 |   script_checks = []
26 | 
27 |   [services.concurrency]
28 |     hard_limit = 10000
29 |     soft_limit = 6000
30 |     type = "connections"
31 | 
32 |   [[services.ports]]
33 |     force_https = true
34 |     handlers = ["http"]
35 |     port = 80
36 | 
37 |   [[services.ports]]
38 |     handlers = ["tls", "http"]
39 |     port = 443
40 | 
41 |   [[services.tcp_checks]]
42 |     grace_period = "1s"
43 |     interval = "15s"
44 |     restart_limit = 0
45 |     timeout = "2s"
46 | 


--------------------------------------------------------------------------------
/priv/repo/migrations/20210811065554_create_users_auth_tables.exs:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Repo.Migrations.CreateUsersAuthTables do
 2 |   use Ecto.Migration
 3 | 
 4 |   def change do
 5 |     execute "CREATE EXTENSION IF NOT EXISTS citext", ""
 6 | 
 7 |     create_if_not_exists table(:users) do
 8 |       add :email, :citext, null: false
 9 |       add :hashed_password, :string, null: false
10 |       add :confirmed_at, :naive_datetime
11 |       timestamps()
12 |     end
13 | 
14 |     create_if_not_exists unique_index(:users, [:email])
15 | 
16 |     create_if_not_exists table(:users_tokens) do
17 |       add :user_id, references(:users, on_delete: :delete_all), null: false
18 |       add :token, :binary, null: false
19 |       add :context, :string, null: false
20 |       add :sent_to, :string
21 |       timestamps(updated_at: false)
22 |     end
23 | 
24 |     create_if_not_exists index(:users_tokens, [:user_id])
25 |     create_if_not_exists unique_index(:users_tokens, [:context, :token])
26 |   end
27 | end
28 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/user_registration_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserRegistrationController do
 2 |   use KetbinWeb, :controller
 3 | 
 4 |   alias Ketbin.Accounts
 5 |   alias Ketbin.Accounts.User
 6 |   alias KetbinWeb.UserAuth
 7 | 
 8 |   def new(conn, _params) do
 9 |     changeset = Accounts.change_user_registration(%User{})
10 |     render(conn, "new.html", changeset: changeset)
11 |   end
12 | 
13 |   def create(conn, %{"user" => user_params}) do
14 |     case Accounts.register_user(user_params) do
15 |       {:ok, user} ->
16 |         {:ok, _} =
17 |           Accounts.deliver_user_confirmation_instructions(
18 |             user,
19 |             &Routes.user_confirmation_url(conn, :confirm, &1)
20 |           )
21 | 
22 |         conn
23 |         |> put_flash(:info, "User created successfully.")
24 |         |> UserAuth.log_in_user(user)
25 |         |> redirect(to: "/users/confirm")
26 | 
27 |       {:error, %Ecto.Changeset{} = changeset} ->
28 |         render(conn, "new.html", changeset: changeset)
29 |     end
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/page/show.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex relative flex-col w-full h-full">
 2 | 	<div class="flex absolute top-0 right-0 p-4">
 3 | 		<%= if @show_edit do%>
 4 | 			<a href={ Routes.page_path(@conn, :edit, @paste.id) } class="text-white hover:text-amber">
 5 | 			<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="h-6 w-6 cursor-pointer fill-current">
 6 | 				<path d="M3 17.46v3.04c0 .28.22.5.5.5h3.04c.13 0 .26-.05.35-.15L17.81 9.94l-3.75-3.75L3.15 17.1c-.1.1-.15.22-.15.36zM20.71 7.04a.996.996 0 0 0 0-1.41l-2.34-2.34a.996.996 0 0 0-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path>
 7 | 			</svg>
 8 | 		</a>
 9 | 		<% end %>
10 | 	</div>
11 | 	<%= if @extension == "md" do%>
12 | 		<div class="break-word px-6 py-4 h-full w-full markdown overflow-y-auto"><%= raw Earmark.as_html!(@paste.content, escape: true, gfm_tables: true) |> HtmlSanitizeEx.markdown_html %></div>
13 | 	<% else %>
14 | 		<code class="break-word px-6 py-4 h-full w-full overflow-y-auto"><%= raw Ketbin.Utils.Syntax.highlight_text(@paste.content, @extension) |> HtmlSanitizeEx.html5 %></code>
15 | 	<% end %>
16 | </div>
17 | 


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | ketbin-*.tar
24 | 
25 | # If NPM crashes, it generates a log, let's ignore it too.
26 | npm-debug.log
27 | 
28 | # The directory NPM downloads your dependencies sources to.
29 | /assets/node_modules/
30 | 
31 | # Since we are building assets from assets/,
32 | # we ignore priv/static. You may want to comment
33 | # this depending on your deployment strategy.
34 | /priv/static/
35 | .idea
36 | /native/ketbin_utils_syntax/target
37 | /native/ketbin_utils_syntax/.cargo
38 | .elixir_ls


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | ketbin-*.tar
24 | 
25 | # If NPM crashes, it generates a log, let's ignore it too.
26 | npm-debug.log
27 | 
28 | # The directory NPM downloads your dependencies sources to.
29 | /assets/node_modules/
30 | 
31 | # Since we are building assets from assets/,
32 | # we ignore priv/static. You may want to comment
33 | # this depending on your deployment strategy.
34 | /priv/static/
35 | /priv/native/
36 | .idea
37 | .env
38 | .envrc
39 | 
40 | # Secret config files
41 | config/*.secret.exs
42 | 


--------------------------------------------------------------------------------
/.github/workflows/fly.yml:
--------------------------------------------------------------------------------
 1 | name: Build and Push Docker Image
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ develop ]
 6 | 
 7 | env:
 8 |   REGISTRY: ghcr.io
 9 |   IMAGE_NAME: ${{ github.repository }}
10 | 
11 | jobs:
12 |   build-and-push:
13 |     runs-on: ubuntu-latest
14 |     permissions:
15 |       contents: read
16 |       packages: write
17 | 
18 |     steps:
19 |       - name: Checkout repository
20 |         uses: actions/checkout@v4
21 | 
22 |       - name: Log in to the Container registry
23 |         uses: docker/login-action@v3
24 |         with:
25 |           registry: ghcr.io
26 |           username: ${{ github.actor }}
27 |           password: ${{ secrets.GITHUB_TOKEN }}
28 | 
29 |       - name: Extract metadata (tags, labels) for Docker
30 |         id: meta
31 |         uses: docker/metadata-action@v5
32 |         with:
33 |           images: ghcr.io/SphericalKat/katbin
34 | 
35 |       - name: Build and push Docker image
36 |         uses: docker/build-push-action@v5
37 |         with:
38 |           context: .
39 |           push: true
40 |           tags: ${{ steps.meta.outputs.tags }}
41 |           labels: ${{ steps.meta.outputs.labels }}
42 | 


--------------------------------------------------------------------------------
/lib/ketbin/application.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Application do
 2 |   # See https://hexdocs.pm/elixir/Application.html
 3 |   # for more information on OTP Applications
 4 |   @moduledoc false
 5 | 
 6 |   use Application
 7 | 
 8 |   def start(_type, _args) do
 9 |     children = [
10 |       # Start the Ecto repository
11 |       Ketbin.Repo,
12 |       # Start the Telemetry supervisor
13 |       KetbinWeb.Telemetry,
14 |       # Start the PubSub system
15 |       {Phoenix.PubSub, name: Ketbin.PubSub},
16 |       # Start the Endpoint (http/https)
17 |       KetbinWeb.Endpoint
18 |       # Start a worker by calling: Ketbin.Worker.start_link(arg)
19 |       # {Ketbin.Worker, arg}
20 |     ]
21 | 
22 |     # See https://hexdocs.pm/elixir/Supervisor.html
23 |     # for other strategies and supported options
24 |     opts = [strategy: :one_for_one, name: Ketbin.Supervisor]
25 |     Supervisor.start_link(children, opts)
26 |   end
27 | 
28 |   # Tell Phoenix to update the endpoint configuration
29 |   # whenever the application is updated.
30 |   def config_change(changed, _new, removed) do
31 |     KetbinWeb.Endpoint.config_change(changed, removed)
32 |     :ok
33 |   end
34 | end
35 | 


--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | #
 4 | # This configuration file is loaded before any dependency and
 5 | # is restricted to this project.
 6 | 
 7 | # General application configuration
 8 | import Config
 9 | 
10 | config :ketbin,
11 |   ecto_repos: [Ketbin.Repo]
12 | 
13 | # Configures the endpoint
14 | config :ketbin, KetbinWeb.Endpoint,
15 |   url: [host: "localhost"],
16 |   secret_key_base: "9uGXQJhm7f2+kO7HKKWUmgBpaRK6oMt795GQKFNlnxdhUjG0Xpy/XddOb03H1aH2",
17 |   render_errors: [view: KetbinWeb.ErrorView, accepts: ~w(html json), layout: false],
18 |   pubsub_server: Ketbin.PubSub,
19 |   live_view: [signing_salt: "76BWv42A"]
20 | 
21 | # Configures Elixir's Logger
22 | config :logger, :console,
23 |   format: "$time $metadata[$level] $message\n",
24 |   metadata: [:request_id]
25 | 
26 | # Use Jason for JSON parsing in Phoenix
27 | config :phoenix, :json_library, Jason
28 | 
29 | # Import environment specific config. This must remain at the bottom
30 | # of this file so it overrides the configuration defined above.
31 | import_config "#{Mix.env()}.exs"
32 | 


--------------------------------------------------------------------------------
/assets/build.js:
--------------------------------------------------------------------------------
 1 | const fs = require("fs-extra");
 2 | const esbuild = require("esbuild");
 3 | const { default: postCSSPlugin } = require("esbuild-plugin-postcss2");
 4 | 
 5 | // PostCSS Plugins
 6 | const autoprefixer = require("autoprefixer");
 7 | const tailwindcss = require("tailwindcss");
 8 | const postcssImport = require("postcss-import");
 9 | 
10 | const productionBuild = process.env.NODE_ENV === "production";
11 | fs.copySync("static/", "../priv/static/");
12 | 
13 | console.log("[build.js] [info] Copying static files from static/");
14 | 
15 | if (!productionBuild) {
16 |   console.log("[build.js] [info] Starting to watch assets for changes");
17 | } else {
18 |   console.log("[build.js] [info] Building assets in production mode");
19 | }
20 | 
21 | esbuild
22 |   .build({
23 |     entryPoints: ["js/app.js"],
24 |     bundle: true,
25 |     outfile: "../priv/static/assets/app.js",
26 |     minify: productionBuild,
27 |     watch: !productionBuild,
28 |     external: ["*.ttf"],
29 |     plugins: [
30 |       postCSSPlugin({
31 |         plugins: [postcssImport, tailwindcss, autoprefixer],
32 |       }),
33 |     ],
34 |   })
35 |   .catch((e) => {
36 |     console.error(`[build.js] [error] ${e}`);
37 |     process.exit(1);
38 |   });
39 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserSocket do
 2 |   use Phoenix.Socket
 3 | 
 4 |   ## Channels
 5 |   # channel "room:*", KetbinWeb.RoomChannel
 6 | 
 7 |   # Socket params are passed from the client and can
 8 |   # be used to verify and authenticate a user. After
 9 |   # verification, you can put default assigns into
10 |   # the socket that will be set for all channels, ie
11 |   #
12 |   #     {:ok, assign(socket, :user_id, verified_user_id)}
13 |   #
14 |   # To deny connection, return `:error`.
15 |   #
16 |   # See `Phoenix.Token` documentation for examples in
17 |   # performing token verification on connect.
18 |   @impl true
19 |   def connect(_params, socket, _connect_info) do
20 |     {:ok, socket}
21 |   end
22 | 
23 |   # Socket id's are topics that allow you to identify all sockets for a given user:
24 |   #
25 |   #     def id(socket), do: "user_socket:#{socket.assigns.user_id}"
26 |   #
27 |   # Would allow you to broadcast a "disconnect" event and terminate
28 |   # all active sockets and channels for a given user:
29 |   #
30 |   #     KetbinWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
31 |   #
32 |   # Returning `nil` makes this socket anonymous.
33 |   @impl true
34 |   def id(_socket), do: nil
35 | end
36 | 


--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.ChannelCase do
 2 |   @moduledoc """
 3 |   This module defines the test case to be used by
 4 |   channel tests.
 5 | 
 6 |   Such tests rely on `Phoenix.ChannelTest` and also
 7 |   import other functionality to make it easier
 8 |   to build common data structures and query the data layer.
 9 | 
10 |   Finally, if the test case interacts with the database,
11 |   we enable the SQL sandbox, so changes done to the database
12 |   are reverted at the end of every test. If you are using
13 |   PostgreSQL, you can even run database tests asynchronously
14 |   by setting `use KetbinWeb.ChannelCase, async: true`, although
15 |   this option is not recommended for other databases.
16 |   """
17 | 
18 |   use ExUnit.CaseTemplate
19 | 
20 |   using do
21 |     quote do
22 |       # Import conveniences for testing with channels
23 |       import Phoenix.ChannelTest
24 |       import KetbinWeb.ChannelCase
25 | 
26 |       # The default endpoint for testing
27 |       @endpoint KetbinWeb.Endpoint
28 |     end
29 |   end
30 | 
31 |   setup tags do
32 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(Ketbin.Repo)
33 | 
34 |     unless tags[:async] do
35 |       Ecto.Adapters.SQL.Sandbox.mode(Ketbin.Repo, {:shared, self()})
36 |     end
37 | 
38 |     :ok
39 |   end
40 | end
41 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM elixir:alpine AS build
 2 | 
 3 | # install build dependencies
 4 | RUN apk add --no-cache build-base npm git curl py-pip rust cargo
 5 | 
 6 | # prepare build dir
 7 | WORKDIR /app
 8 | 
 9 | # install hex + rebar
10 | RUN mix local.hex --force && \
11 |     mix local.rebar --force
12 | 
13 | # set build ENV
14 | ENV MIX_ENV=prod
15 | 
16 | # install mix dependencies
17 | COPY mix.exs mix.lock ./
18 | COPY config config
19 | RUN mix do deps.get, deps.compile
20 | 
21 | # build assets
22 | COPY assets/package.json assets/package-lock.json ./assets/
23 | RUN npm --prefix ./assets ci --progress=false --no-audit --loglevel=error
24 | 
25 | COPY priv priv
26 | COPY assets assets
27 | COPY lib lib
28 | COPY native native
29 | RUN npm run --prefix ./assets deploy
30 | RUN mix phx.digest
31 | 
32 | # uncomment COPY if rel/ exists
33 | # COPY rel rel
34 | RUN mix do compile, release
35 | 
36 | # prepare release image
37 | FROM alpine AS app
38 | RUN apk add --no-cache openssl ncurses-libs libstdc++
39 | 
40 | WORKDIR /app
41 | 
42 | RUN chown nobody:nobody /app
43 | 
44 | USER nobody:nobody
45 | 
46 | COPY --from=build --chown=nobody:nobody /app/_build/prod/rel/ketbin ./
47 | 
48 | COPY --chown=nobody:nobody startup.sh startup.sh
49 | 
50 | RUN chmod +x /app/startup.sh
51 | 
52 | ENV HOME=/app
53 | 
54 | CMD ["/app/startup.sh"]
55 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/user_registration/new.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex flex-col w-full h-full justify-center items-center">
 2 | 	<h1 class="font-bold text-4xl text-amber pt-4">Register</h1>
 3 | 
 4 | 	<%= form_for @changeset, Routes.user_registration_path(@conn, :create), [class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
 5 | 		<%= if @changeset.action do %>
 6 | 			<div class="alert alert-danger">
 7 | 				<p>Oops, something went wrong! Please check the errors below.</p>
 8 | 			</div>
 9 | 		<% end %>
10 | 
11 | 		<div class="flex flex-col w-full">
12 | 			<%= label f, :email %>
13 | 			<%= email_input f, :email, [class: "text-black px-2 py-1 outline-none", required: true] %>
14 | 			<%= error_tag f, :email %>
15 | 		</div>
16 | 
17 | 		<div class="flex flex-col mt-2 w-full">
18 | 			<%= label f, :password, [class: ""] %>
19 | 			<%= password_input f, :password, [class: "text-black px-2 py-1 outline-none", required: true] %>
20 | 			<%= error_tag f, :password %>
21 | 		</div>
22 | 
23 | 		<div class="bg-amber mt-4 rounded-sm px-2 py-1">
24 | 			<%= submit "Sign up" %>
25 | 		</div>
26 | 	<% end %>
27 | 
28 | 	<p class="mb-4 text-amber">
29 | 		<%= link "Log in", to: Routes.user_session_path(@conn, :new) %> <span>|</span>
30 | 		<%= link "Forgot password?", to: Routes.user_reset_password_path(@conn, :new) %>
31 | 	</p>
32 | </div>
33 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/api/paste_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.Api.PasteController do
 2 |   use KetbinWeb, :controller
 3 | 
 4 |   alias Ketbin.Pastes
 5 |   alias Ketbin.Pastes.Utils
 6 | 
 7 |   def show(conn, %{"id" => id}) do
 8 |     [head | _tail] = String.split(id, ".")
 9 | 
10 |     # fetch paste from db
11 |     paste = Pastes.get_paste!(head)
12 |     render(conn, "paste.json", paste: paste)
13 |   end
14 | 
15 |   def create(%{assigns: %{current_user: current_user}} = conn, %{"paste" => paste_params}) do
16 |     # generate phonetic key
17 |     id = Utils.generate_key()
18 | 
19 |     # check if content is a url
20 |     is_url =
21 |       Map.get(paste_params, "content")
22 |       |> Utils.is_url?()
23 | 
24 |     # put id and is_url values into changeset
25 |     paste_params =
26 |       Map.put(paste_params, "id", id)
27 |       |> Map.put("is_url", is_url)
28 |       |> Map.put("belongs_to", current_user && current_user.id)
29 | 
30 |     # attempt to create a paste
31 |     case Pastes.create_paste(paste_params) do
32 |       # all good
33 |       {:ok, paste} ->
34 |         conn
35 |         |> put_status(:created)
36 |         |> render("paste.json", paste: paste)
37 | 
38 |       # something went wrong, bail
39 |       {:error, %Ecto.Changeset{} = _changeset} ->
40 |         conn
41 |         |> put_status(:internal_server_error)
42 |         |> render("error.json")
43 |     end
44 |   end
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/user_reset_password/edit.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex flex-col w-full h-full justify-center items-center">
 2 | 	<h1 class="font-bold text-4xl text-amber pt-4">Reset password</h1>
 3 | 
 4 | 	<%= form_for @changeset, Routes.user_reset_password_path(@conn, :update, @token), [class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
 5 | 		<%= if @changeset.action do %>
 6 | 			<div class="alert alert-danger">
 7 | 				<p>Oops, something went wrong! Please check the errors below.</p>
 8 | 			</div>
 9 | 		<% end %>
10 | 
11 | 		<div class="flex flex-col w-full">
12 | 			<%= label f, :password, "New password" %>
13 | 			<%= password_input f, :password, [class: "text-black px-2 py-1 outline-none", required: true] %>
14 | 			<%= error_tag f, :password %>
15 | 		</div>
16 | 
17 | 		<div class="flex flex-col w-full">
18 | 			<%= label f, :password_confirmation, "Confirm new password" %>
19 | 			<%= password_input f, :password_confirmation, [class: "text-black px-2 py-1 outline-none", required: true] %>
20 | 			<%= error_tag f, :password_confirmation %>
21 | 		</div>
22 | 
23 | 		<div class="bg-amber mt-4 rounded-sm px-2 py-1">
24 | 			<%= submit "Reset password" %>
25 | 		</div>
26 | 	<% end %>
27 | 
28 | 	<p class="mb-4 text-amber">
29 | 		<%= link "Register", to: Routes.user_registration_path(@conn, :new) %> |
30 | 		<%= link "Log in", to: Routes.user_session_path(@conn, :new) %>
31 | 	</p>
32 | </div>
33 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/user_session/new.html.heex:
--------------------------------------------------------------------------------
 1 | <div class="flex flex-col w-full h-full justify-center items-center">
 2 | 	<h1 class="font-bold text-4xl text-amber pt-4">Log in</h1>
 3 | 
 4 | 	<%= form_for @conn, Routes.user_session_path(@conn, :create), [as: :user, class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
 5 | 		<%= if @error_message do %>
 6 | 			<div class="alert alert-danger">
 7 | 				<p><%= @error_message %></p>
 8 | 			</div>
 9 | 		<% end %>
10 | 
11 | 		<div class="flex flex-col w-full">
12 | 			<%= label f, :email %>
13 | 			<%= email_input f, :email, [class: "text-black px-2 py-1 outline-none", required: true] %>
14 | 		</div>
15 | 
16 | 		<div class="flex flex-col mt-2 w-full">
17 | 			<%= label f, :password %>
18 | 			<%= password_input f, :password, [class: "text-black px-2 py-1 outline-none", required: true] %>
19 | 		</div>
20 | 		<div class="flex mt-2 w-full justify-center items-center">
21 | 			<%= checkbox f, :remember_me,  [class: "mr-2 outline-none"] %>
22 | 			<%= label f, :remember_me, "Keep me logged in for 60 days" %>
23 | 		</div>
24 | 
25 | 		<div class="bg-amber mt-4 rounded-sm px-2 py-1">
26 | 				<%= submit "Log in" %>
27 | 			</div>
28 | 	<% end %>
29 | 
30 | 	<p class="mb-4 text-amber">
31 | 		<%= link "Register", to: Routes.user_registration_path(@conn, :new) %> |
32 | 		<%= link "Forgot your password?", to: Routes.user_reset_password_path(@conn, :new) %>
33 | 	</p>
34 | </div>
35 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/layout/_user_menu.html.heex:
--------------------------------------------------------------------------------
 1 | <script>
 2 | function toggleDropdown() {
 3 |     const dropdown = document.querySelector('#dropdown');
 4 |     const dropdownLabel = document.querySelector('#dropdown-label');
 5 |     if (dropdown.classList.contains('hidden')) {
 6 |         dropdown.classList.remove('hidden');
 7 |         dropdown.classList.add('absolute');
 8 |         dropdownLabel.innerHTML = dropdownLabel.innerHTML.replace('▼', '▲');
 9 |     } else {
10 |         dropdown.classList.add('hidden');
11 |         dropdown.classList.remove('absolute');
12 |         dropdownLabel.innerHTML = dropdownLabel.innerHTML.replace('▲', '▼');
13 |     }
14 | }
15 | </script>
16 | <ul>
17 | 	<%= if @current_user do %>
18 | 		<div class="relative">
19 |             <li id="dropdown-label" onclick="toggleDropdown()" class="text-[#ff9800] cursor-pointer select-none"><%= @current_user.email %> ▼</li>
20 |             <div id="dropdown" class="hidden right-0 z-50 bg-[#313131] px-4 py-2">
21 |                 <li><%= link "Settings", to: Routes.user_settings_path(@conn, :edit) %></li>
22 |                 <li><%= link "Log out", to: Routes.user_session_path(@conn, :delete), method: :delete %></li>
23 |                 <li><%= link "My Pastes", to: Routes.page_path(@conn, :pastes) %></li>
24 |             </div>
25 |         </div>
26 | 	<% else %>
27 | 		<li><%= link "Register", to: Routes.user_registration_path(@conn, :new) %></li>
28 | 		<li><%= link "Log in", to: Routes.user_session_path(@conn, :new) %></li>
29 | 	<% end %>
30 | </ul>
31 | 


--------------------------------------------------------------------------------
/priv/cert.pem:
--------------------------------------------------------------------------------
 1 | -----BEGIN CERTIFICATE-----
 2 | MIIEQTCCAqmgAwIBAgIUKUbJkc6kHUPlOf0l1xQYzrLjECowDQYJKoZIhvcNAQEM
 3 | BQAwOjE4MDYGA1UEAwwvOTM5MDZiYWYtYzcxYi00MTczLTg2YTItZjA2MzFmMjZj
 4 | M2VhIFByb2plY3QgQ0EwHhcNMjEwNjI0MDc1NTUyWhcNMzEwNjIyMDc1NTUyWjA6
 5 | MTgwNgYDVQQDDC85MzkwNmJhZi1jNzFiLTQxNzMtODZhMi1mMDYzMWYyNmMzZWEg
 6 | UHJvamVjdCBDQTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAMM4NOOH
 7 | 1OXoq7GFd25OXNne5Me3bCdAO3DLHbHtK8reFPZeq/liaGz32t/xdNvuKns3augS
 8 | oFNiKqcU5kb07D9s70ME1iWBjaUyoYdKSWwS69ZOZNAXmPEgfnNNRTyS1zHB2F85
 9 | rYxz3lKsDFQJEM09DTihB5uk5qZIxP23N6K1ifxF+mh5MQkWsGXpEj5bol2GeLp7
10 | DKRCPUmWZs4QYX2cjRFBm4WdXkCH8K8GbAymrgLDKoujAPJQQTlWQGJFVw6RXc+J
11 | 2I5L7NwKV0+C8X2DuG5y0TYIKAJymrEhYNvnnOorofjBJACMt6EqkjxOxICT8XAx
12 | 7DOme1whKvurEeYY4XBA5RGQRqIxwmHG3vw7BQDYQkugpqfpS2T2dV8nmjdpCboQ
13 | E10/N+9h0b8iBRV9q/fcG74ecffPvHNKZ9hW5YoRLq0Fh2sfsEGBtgoTXdeXkVk6
14 | doIYKR46yRgSn8tVf/sxWZPfgqTQgseGHex3uS2quqhtu1T0Uda9Z43mqwIDAQAB
15 | oz8wPTAdBgNVHQ4EFgQUUrDjALr7J/5fjidqpfV1BlMjgd0wDwYDVR0TBAgwBgEB
16 | /wIBADALBgNVHQ8EBAMCAQYwDQYJKoZIhvcNAQEMBQADggGBAJD14yAPgirbAlgr
17 | 8vt5vXrjT4jmbnRc2DukvgabLVG6ecRVYkE96gPeqYMi6E5OuHZTjPBYiqX6EZ9k
18 | YkT8qJ+odca6XpQmPjh1G5imefpqJ5xFxvPXYdlopKpWttx8R5z+YS84mq/ULG+x
19 | +uDxOyrX5euoihoPcYjotzDHV+LmaCIu0dybWuEtCvMSOKlicdOl9y2/93/I84WG
20 | VLHye4Qp5vIoXBEQ8FS5Furuh6ABFhp3LnKgJOeCn+u89sganuWf5JuCohK/9IfZ
21 | /VNd+DvggVxPDemX/9j1HzGdwQ/W4dD2GyBi6nT8TUrTMbV6S8FJC5Ba9Tovy9QN
22 | aO05pgq4LNlG9gecX45TzIPV2BsB6TYmvq/mbr5sGRQLgVlqiYC/KEH7cdnjN418
23 | gqBcwUlct0FiKHM1YWd0uXEEJh1yu14wnZmJDnr3Dkj2k7uyrUoMt9bDv5nnyocZ
24 | ub+CsnVPqBBHs4JOAw5atRxpGeEiSVZCJt6xpVHHl3vlW3pwFQ==
25 | -----END CERTIFICATE-----
26 | 


--------------------------------------------------------------------------------
/test/support/data_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.DataCase do
 2 |   @moduledoc """
 3 |   This module defines the setup for tests requiring
 4 |   access to the application's data layer.
 5 | 
 6 |   You may define functions here to be used as helpers in
 7 |   your tests.
 8 | 
 9 |   Finally, if the test case interacts with the database,
10 |   we enable the SQL sandbox, so changes done to the database
11 |   are reverted at the end of every test. If you are using
12 |   PostgreSQL, you can even run database tests asynchronously
13 |   by setting `use Ketbin.DataCase, async: true`, although
14 |   this option is not recommended for other databases.
15 |   """
16 | 
17 |   use ExUnit.CaseTemplate
18 | 
19 |   using do
20 |     quote do
21 |       alias Ketbin.Repo
22 | 
23 |       import Ecto
24 |       import Ecto.Changeset
25 |       import Ecto.Query
26 |       import Ketbin.DataCase
27 |     end
28 |   end
29 | 
30 |   setup tags do
31 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(Ketbin.Repo)
32 | 
33 |     unless tags[:async] do
34 |       Ecto.Adapters.SQL.Sandbox.mode(Ketbin.Repo, {:shared, self()})
35 |     end
36 | 
37 |     :ok
38 |   end
39 | 
40 |   @doc """
41 |   A helper that transforms changeset errors into a map of messages.
42 | 
43 |       assert {:error, changeset} = Accounts.create_user(%{password: "short"})
44 |       assert "password is too short" in errors_on(changeset).password
45 |       assert %{password: ["password is too short"]} = errors_on(changeset)
46 | 
47 |   """
48 |   def errors_on(changeset) do
49 |     Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
50 |       Regex.replace(~r"%{(\w+)}", message, fn _, key ->
51 |         opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
52 |       end)
53 |     end)
54 |   end
55 | end
56 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.ErrorHelpers do
 2 |   @moduledoc """
 3 |   Conveniences for translating and building error messages.
 4 |   """
 5 | 
 6 |   use Phoenix.HTML
 7 | 
 8 |   @doc """
 9 |   Generates tag for inlined form input errors.
10 |   """
11 |   def error_tag(form, field) do
12 |     Enum.map(Keyword.get_values(form.errors, field), fn error ->
13 |       content_tag(:span, translate_error(error),
14 |         class: "absolute top-0 left-0 px-6 py-4",
15 |         phx_feedback_for: input_name(form, field)
16 |       )
17 |     end)
18 |   end
19 | 
20 |   @doc """
21 |   Translates an error message using gettext.
22 |   """
23 |   def translate_error({msg, opts}) do
24 |     # When using gettext, we typically pass the strings we want
25 |     # to translate as a static argument:
26 |     #
27 |     #     # Translate "is invalid" in the "errors" domain
28 |     #     dgettext("errors", "is invalid")
29 |     #
30 |     #     # Translate the number of files with plural rules
31 |     #     dngettext("errors", "1 file", "%{count} files", count)
32 |     #
33 |     # Because the error messages we show in our forms and APIs
34 |     # are defined inside Ecto, we need to translate them dynamically.
35 |     # This requires us to call the Gettext module passing our gettext
36 |     # backend as first argument.
37 |     #
38 |     # Note we use the "errors" domain, which means translations
39 |     # should be written to the errors.po file. The :count option is
40 |     # set by Ecto and indicates we should also apply plural rules.
41 |     if count = opts[:count] do
42 |       Gettext.dngettext(KetbinWeb.Gettext, "errors", msg, msg, count, opts)
43 |     else
44 |       Gettext.dgettext(KetbinWeb.Gettext, "errors", msg, opts)
45 |     end
46 |   end
47 | end
48 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Katbin
 2 | 
 3 | To start your Phoenix server:
 4 | 
 5 |   * Copy `config/dev.secret.sample.exs` to `config/dev.secret.exs`
 6 |   * Fill in the SMTP and database configuration in `config/dev.secret.exs`
 7 |   * Install dependencies with `mix deps.get`
 8 |   * Create and migrate your database with `mix ecto.setup`
 9 |   * Install Node.js dependencies with `npm install` inside the `assets` directory
10 |   * Start Phoenix endpoint with `mix phx.server`
11 | 
12 | Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.
13 | 
14 | # Self hosting
15 | 
16 | We recommend using our [official docker image](https://hub.docker.com/r/atechnohazard/katbin-elixir). If you wish to build your own docker image, the provided Dockerfile should work out of the box. If you run into any problems, please open an issue.
17 | 
18 | ## Populating the environment
19 | Copy the provided `sample.env` file to `.env`
20 | ```sh
21 | cp sample.env .env
22 | ```
23 | 
24 | Fill in this new file with the required environment variables.
25 | 
26 | ## Using the official docker image
27 | ```sh
28 | docker run --env-file .env atechnohazard/katbin-elixir
29 | ```
30 | 
31 | ## Building the docker image
32 | ```sh
33 | git clone https://github.com/SphericalKat/katbin
34 | cd katbin
35 | docker build -t <username>/katbin .
36 | ```
37 | 
38 | ## Running the built docker image
39 | ```sh
40 | docker run --env-file .env <username>/katbin
41 | ```
42 | 
43 | For other methods of self hosting, please check the [official Phoenix deployment guides](https://hexdocs.pm/phoenix/deployment.html).
44 | 
45 | 
46 | ## Learn more
47 | 
48 |   * Official website: https://www.phoenixframework.org/
49 |   * Guides: https://hexdocs.pm/phoenix/overview.html
50 |   * Docs: https://hexdocs.pm/phoenix
51 |   * Forum: https://elixirforum.com/c/phoenix-forum
52 |   * Source: https://github.com/phoenixframework/phoenix
53 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/endpoint.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.Endpoint do
 2 |   use Phoenix.Endpoint, otp_app: :ketbin
 3 | 
 4 |   # The session will be stored in the cookie and signed,
 5 |   # this means its contents can be read but not tampered with.
 6 |   # Set :encryption_salt if you would also like to encrypt it.
 7 |   @session_options [
 8 |     store: :cookie,
 9 |     key: "_ketbin_key",
10 |     signing_salt: "HmwUQdXk"
11 |   ]
12 | 
13 |   socket "/socket", KetbinWeb.UserSocket,
14 |     websocket: true,
15 |     longpoll: false
16 | 
17 |   socket "/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]]
18 | 
19 |   # Serve at "/" the static files from "priv/static" directory.
20 |   #
21 |   # You should set gzip to true if you are running phx.digest
22 |   # when deploying your static files in production.
23 |   plug Plug.Static,
24 |     at: "/",
25 |     from: :ketbin,
26 |     gzip: false,
27 |     only: ~w(assets fonts images favicon.ico robots.txt)
28 | 
29 |   # Code reloading can be explicitly enabled under the
30 |   # :code_reloader configuration of your endpoint.
31 |   if code_reloading? do
32 |     socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
33 |     plug Phoenix.LiveReloader
34 |     plug Phoenix.CodeReloader
35 |     plug Phoenix.Ecto.CheckRepoStatus, otp_app: :ketbin
36 |   end
37 | 
38 |   plug Phoenix.LiveDashboard.RequestLogger,
39 |     param_key: "request_logger",
40 |     cookie_key: "request_logger"
41 | 
42 |   plug Plug.RequestId
43 |   plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]
44 | 
45 |   plug Plug.Parsers,
46 |     parsers: [:urlencoded, :multipart, :json],
47 |     length: 10_000_000,
48 |     pass: ["*/*"],
49 |     json_decoder: Phoenix.json_library()
50 | 
51 |   plug Plug.MethodOverride
52 |   plug Plug.Head
53 |   plug Plug.Session, @session_options
54 |   plug CORSPlug
55 |   plug KetbinWeb.Router
56 | end
57 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/user_confirmation_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserConfirmationController do
 2 |   use KetbinWeb, :controller
 3 | 
 4 |   alias Ketbin.Accounts
 5 | 
 6 |   def new(conn, _params) do
 7 |     render(conn, "new.html")
 8 |   end
 9 | 
10 |   def create(conn, %{"user" => %{"email" => email}}) do
11 |     if user = Accounts.get_user_by_email(email) do
12 |       Accounts.deliver_user_confirmation_instructions(
13 |         user,
14 |         &Routes.user_confirmation_url(conn, :confirm, &1)
15 |       )
16 |     end
17 | 
18 |     # Regardless of the outcome, show an impartial success/error message.
19 |     conn
20 |     |> put_flash(
21 |       :info,
22 |       "If your email is in our system and it has not been confirmed yet, " <>
23 |         "you will receive an email with instructions shortly."
24 |     )
25 |     |> redirect(to: "/")
26 |   end
27 | 
28 |   # Do not log in the user after confirmation to avoid a
29 |   # leaked token giving the user access to the account.
30 |   def confirm(conn, %{"token" => token}) do
31 |     case Accounts.confirm_user(token) do
32 |       {:ok, _} ->
33 |         conn
34 |         |> put_flash(:info, "User confirmed successfully.")
35 |         |> redirect(to: "/")
36 | 
37 |       :error ->
38 |         # If there is a current user and the account was already confirmed,
39 |         # then odds are that the confirmation link was already visited, either
40 |         # by some automation or by the user themselves, so we redirect without
41 |         # a warning message.
42 |         case conn.assigns do
43 |           %{current_user: %{confirmed_at: confirmed_at}} when not is_nil(confirmed_at) ->
44 |             redirect(conn, to: "/")
45 | 
46 |           %{} ->
47 |             conn
48 |             |> put_flash(:error, "User confirmation link is invalid or it has expired.")
49 |             |> redirect(to: "/")
50 |         end
51 |     end
52 |   end
53 | end
54 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/page/form.html.heex:
--------------------------------------------------------------------------------
 1 | <%= form_for @changeset, @action, [class: "flex flex-col w-full h-full relative", id: "page_form"], fn f -> %>
 2 | 		<script>
 3 | 			document.addEventListener("keydown", function(e) {
 4 | 				if ((window.navigator.platform.match("Mac") ? e.metaKey : e.ctrlKey) && e.keyCode == 83) {
 5 | 					e.preventDefault();
 6 | 					document.getElementById("page_form").submit()
 7 | 				}
 8 | 			}, false);
 9 | 		</script>
10 |     <%= if @changeset.action do %>
11 |         <div class="w-full text-center bg-amber">
12 |             <p>Oops, something went wrong!</p>
13 |         </div>
14 |     <% end %>
15 | 
16 |     <%= if assigns[:already_taken] do %>
17 |         <div class="w-full text-center bg-amber">
18 |             <p>This custom URL has already been taken.</p>
19 |         </div>
20 |     <% end %>
21 | 
22 |     <div class="w-full h-full">
23 |         <%= textarea f, :content, [class: "w-full h-full px-6 py-4 outline-none bg-light-grey font-bold resize-none", placeholder: "> Paste, save, share! (Pasting just a URL will shorten it!)"] %>
24 |         <div class="flex absolute top-0 right-0 p-4">
25 |             <%= if @current_user && !assigns[:is_edit] do %>
26 |             <div>
27 |                 <%= text_input f, :custom_url, [class: "px-2 mr-2 outline-none text-black px-2 py-1", placeholder: "Custom URL"]  %>
28 |             </div>
29 |             <% end %>
30 |             <button type="submit">
31 |                 <svg
32 | 									class="h-6 w-6 cursor-pointer fill-current text-white hover:text-amber"
33 | 									xmlns="http://www.w3.org/2000/svg"
34 | 									viewBox="0 0 24 24">
35 |                   <path d="M17.6 3.6c-.4-.4-.9-.6-1.4-.6H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7.8c0-.5-.2-1-.6-1.4l-2.8-2.8zM12 19c-1.7 0-3-1.3-3-3s1.3-3 3-3 3 1.3 3 3-1.3 3-3 3zm1-10H7c-1.1 0-2-.9-2-2s.9-2 2-2h6c1.1 0 2 .9 2 2s-.9 2-2 2z"/>
36 |                 </svg>
37 |             </button>
38 |         </div>
39 |     </div>
40 | <% end %>
41 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/user_registration_controller_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserRegistrationControllerTest do
 2 |   use KetbinWeb.ConnCase, async: true
 3 | 
 4 |   import Ketbin.AccountsFixtures
 5 | 
 6 |   describe "GET /users/register" do
 7 |     test "renders registration page", %{conn: conn} do
 8 |       conn = get(conn, Routes.user_registration_path(conn, :new))
 9 |       response = html_response(conn, 200)
10 |       assert response =~ "<h1>Register</h1>"
11 |       assert response =~ "Log in</a>"
12 |       assert response =~ "Register</a>"
13 |     end
14 | 
15 |     test "redirects if already logged in", %{conn: conn} do
16 |       conn = conn |> log_in_user(user_fixture()) |> get(Routes.user_registration_path(conn, :new))
17 |       assert redirected_to(conn) == "/"
18 |     end
19 |   end
20 | 
21 |   describe "POST /users/register" do
22 |     @tag :capture_log
23 |     test "creates account and logs the user in", %{conn: conn} do
24 |       email = unique_user_email()
25 | 
26 |       conn =
27 |         post(conn, Routes.user_registration_path(conn, :create), %{
28 |           "user" => valid_user_attributes(email: email)
29 |         })
30 | 
31 |       assert get_session(conn, :user_token)
32 |       assert redirected_to(conn) =~ "/"
33 | 
34 |       # Now do a logged in request and assert on the menu
35 |       conn = get(conn, "/")
36 |       response = html_response(conn, 200)
37 |       assert response =~ email
38 |       assert response =~ "Settings</a>"
39 |       assert response =~ "Log out</a>"
40 |     end
41 | 
42 |     test "render errors for invalid data", %{conn: conn} do
43 |       conn =
44 |         post(conn, Routes.user_registration_path(conn, :create), %{
45 |           "user" => %{"email" => "with spaces", "password" => "too short"}
46 |         })
47 | 
48 |       response = html_response(conn, 200)
49 |       assert response =~ "<h1>Register</h1>"
50 |       assert response =~ "must have the @ sign and no spaces"
51 |       assert response =~ "should be at least 12 character"
52 |     end
53 |   end
54 | end
55 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/user_reset_password_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserResetPasswordController do
 2 |   use KetbinWeb, :controller
 3 | 
 4 |   alias Ketbin.Accounts
 5 | 
 6 |   plug :get_user_by_reset_password_token when action in [:edit, :update]
 7 | 
 8 |   def new(conn, _params) do
 9 |     render(conn, "new.html")
10 |   end
11 | 
12 |   def create(conn, %{"user" => %{"email" => email}}) do
13 |     if user = Accounts.get_user_by_email(email) do
14 |       Accounts.deliver_user_reset_password_instructions(
15 |         user,
16 |         &Routes.user_reset_password_url(conn, :edit, &1)
17 |       )
18 |     end
19 | 
20 |     # Regardless of the outcome, show an impartial success/error message.
21 |     conn
22 |     |> put_flash(
23 |       :info,
24 |       "If your email is in our system, you will receive instructions to reset your password shortly."
25 |     )
26 |     |> redirect(to: "/")
27 |   end
28 | 
29 |   def edit(conn, _params) do
30 |     render(conn, "edit.html", changeset: Accounts.change_user_password(conn.assigns.user))
31 |   end
32 | 
33 |   # Do not log in the user after reset password to avoid a
34 |   # leaked token giving the user access to the account.
35 |   def update(conn, %{"user" => user_params}) do
36 |     case Accounts.reset_user_password(conn.assigns.user, user_params) do
37 |       {:ok, _} ->
38 |         conn
39 |         |> put_flash(:info, "Password reset successfully.")
40 |         |> redirect(to: Routes.user_session_path(conn, :new))
41 | 
42 |       {:error, changeset} ->
43 |         render(conn, "edit.html", changeset: changeset)
44 |     end
45 |   end
46 | 
47 |   defp get_user_by_reset_password_token(conn, _opts) do
48 |     %{"token" => token} = conn.params
49 | 
50 |     if user = Accounts.get_user_by_reset_password_token(token) do
51 |       conn |> assign(:user, user) |> assign(:token, token)
52 |     else
53 |       conn
54 |       |> put_flash(:error, "Reset password link is invalid or it has expired.")
55 |       |> redirect(to: "/")
56 |       |> halt()
57 |     end
58 |   end
59 | end
60 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/telemetry.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.Telemetry do
 2 |   use Supervisor
 3 |   import Telemetry.Metrics
 4 | 
 5 |   def start_link(arg) do
 6 |     Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
 7 |   end
 8 | 
 9 |   @impl true
10 |   def init(_arg) do
11 |     children = [
12 |       # Telemetry poller will execute the given period measurements
13 |       # every 10_000ms. Learn more here: https://hexdocs.pm/telemetry_metrics
14 |       {:telemetry_poller, measurements: periodic_measurements(), period: 10_000}
15 |       # Add reporters as children of your supervision tree.
16 |       # {Telemetry.Metrics.ConsoleReporter, metrics: metrics()}
17 |     ]
18 | 
19 |     Supervisor.init(children, strategy: :one_for_one)
20 |   end
21 | 
22 |   def metrics do
23 |     [
24 |       # Phoenix Metrics
25 |       summary("phoenix.endpoint.stop.duration",
26 |         unit: {:native, :millisecond}
27 |       ),
28 |       summary("phoenix.router_dispatch.stop.duration",
29 |         tags: [:route],
30 |         unit: {:native, :millisecond}
31 |       ),
32 | 
33 |       # Database Metrics
34 |       summary("ketbin.repo.query.total_time", unit: {:native, :millisecond}),
35 |       summary("ketbin.repo.query.decode_time", unit: {:native, :millisecond}),
36 |       summary("ketbin.repo.query.query_time", unit: {:native, :millisecond}),
37 |       summary("ketbin.repo.query.queue_time", unit: {:native, :millisecond}),
38 |       summary("ketbin.repo.query.idle_time", unit: {:native, :millisecond}),
39 | 
40 |       # VM Metrics
41 |       summary("vm.memory.total", unit: {:byte, :kilobyte}),
42 |       summary("vm.total_run_queue_lengths.total"),
43 |       summary("vm.total_run_queue_lengths.cpu"),
44 |       summary("vm.total_run_queue_lengths.io")
45 |     ]
46 |   end
47 | 
48 |   defp periodic_measurements do
49 |     [
50 |       # A module, function and arguments to be invoked periodically.
51 |       # This function must call :telemetry.execute/3 and a metric must be added above.
52 |       # {KetbinWeb, :count_users, []}
53 |     ]
54 |   end
55 | end
56 | 


--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
 1 | import Config
 2 | 
 3 | # For development, we disable any cache and enable
 4 | # debugging and code reloading.
 5 | #
 6 | # The watchers configuration can be used to run external
 7 | # watchers to your application. For example, we use it
 8 | # with webpack to recompile .js and .css sources.
 9 | config :ketbin, KetbinWeb.Endpoint,
10 |   http: [port: 4000],
11 |   debug_errors: true,
12 |   code_reloader: true,
13 |   check_origin: false,
14 |   watchers: [
15 |     node: [
16 |       "build.js",
17 |       cd: Path.expand("../assets", __DIR__)
18 |     ]
19 |   ]
20 | 
21 | # ## SSL Support
22 | #
23 | # In order to use HTTPS in development, a self-signed
24 | # certificate can be generated by running the following
25 | # Mix task:
26 | #
27 | #     mix phx.gen.cert
28 | #
29 | # Note that this task requires Erlang/OTP 20 or later.
30 | # Run `mix help phx.gen.cert` for more information.
31 | #
32 | # The `http:` config above can be replaced with:
33 | #
34 | #     https: [
35 | #       port: 4001,
36 | #       cipher_suite: :strong,
37 | #       keyfile: "priv/cert/selfsigned_key.pem",
38 | #       certfile: "priv/cert/selfsigned.pem"
39 | #     ],
40 | #
41 | # If desired, both `http:` and `https:` keys can be
42 | # configured to run both http and https servers on
43 | # different ports.
44 | 
45 | # Watch static and templates for browser reloading.
46 | config :ketbin, KetbinWeb.Endpoint,
47 |   live_reload: [
48 |     patterns: [
49 |       ~r"priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$",
50 |       ~r"priv/gettext/.*(po)$",
51 |       ~r"lib/ketbin_web/(live|views)/.*(ex)$",
52 |       ~r"lib/ketbin_web/templates/.*(eex)$"
53 |     ]
54 |   ]
55 | 
56 | # Do not include metadata nor timestamps in development logs
57 | config :logger, :console, format: "[$level] $message\n"
58 | 
59 | # Set a higher stacktrace during development. Avoid configuring such
60 | # in production as building large stacktraces may be expensive.
61 | config :phoenix, :stacktrace_depth, 20
62 | 
63 | # Initialize plugs at runtime for faster development compilation
64 | config :phoenix, :plug_init_mode, :runtime
65 | 
66 | # Import the secrets config
67 | import_config "dev.secret.exs"
68 | 


--------------------------------------------------------------------------------
/test/support/conn_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.ConnCase do
 2 |   @moduledoc """
 3 |   This module defines the test case to be used by
 4 |   tests that require setting up a connection.
 5 | 
 6 |   Such tests rely on `Phoenix.ConnTest` and also
 7 |   import other functionality to make it easier
 8 |   to build common data structures and query the data layer.
 9 | 
10 |   Finally, if the test case interacts with the database,
11 |   we enable the SQL sandbox, so changes done to the database
12 |   are reverted at the end of every test. If you are using
13 |   PostgreSQL, you can even run database tests asynchronously
14 |   by setting `use KetbinWeb.ConnCase, async: true`, although
15 |   this option is not recommended for other databases.
16 |   """
17 | 
18 |   use ExUnit.CaseTemplate
19 | 
20 |   using do
21 |     quote do
22 |       # Import conveniences for testing with connections
23 |       import Plug.Conn
24 |       import Phoenix.ConnTest
25 |       import KetbinWeb.ConnCase
26 | 
27 |       alias KetbinWeb.Router.Helpers, as: Routes
28 | 
29 |       # The default endpoint for testing
30 |       @endpoint KetbinWeb.Endpoint
31 |     end
32 |   end
33 | 
34 |   setup tags do
35 |     :ok = Ecto.Adapters.SQL.Sandbox.checkout(Ketbin.Repo)
36 | 
37 |     unless tags[:async] do
38 |       Ecto.Adapters.SQL.Sandbox.mode(Ketbin.Repo, {:shared, self()})
39 |     end
40 | 
41 |     {:ok, conn: Phoenix.ConnTest.build_conn()}
42 |   end
43 | 
44 |   @doc """
45 |   Setup helper that registers and logs in users.
46 | 
47 |       setup :register_and_log_in_user
48 | 
49 |   It stores an updated connection and a registered user in the
50 |   test context.
51 |   """
52 |   def register_and_log_in_user(%{conn: conn}) do
53 |     user = Ketbin.AccountsFixtures.user_fixture()
54 |     %{conn: log_in_user(conn, user), user: user}
55 |   end
56 | 
57 |   @doc """
58 |   Logs the given `user` into the `conn`.
59 | 
60 |   It returns an updated `conn`.
61 |   """
62 |   def log_in_user(conn, user) do
63 |     token = Ketbin.Accounts.generate_user_session_token(user)
64 | 
65 |     conn
66 |     |> Phoenix.ConnTest.init_test_session(%{})
67 |     |> Plug.Conn.put_session(:user_token, token)
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/config/prod.exs:
--------------------------------------------------------------------------------
 1 | import Config
 2 | 
 3 | # For production, don't forget to configure the url host
 4 | # to something meaningful, Phoenix uses this information
 5 | # when generating URLs.
 6 | #
 7 | # Note we also include the path to a cache manifest
 8 | # containing the digested version of static files. This
 9 | # manifest is generated by the `mix phx.digest` task,
10 | # which you should run after static files are built and
11 | # before starting your production server.
12 | config :ketbin, KetbinWeb.Endpoint,
13 |   url: [host: "katb.in", port: 80],
14 |   cache_static_manifest: "priv/static/cache_manifest.json"
15 | 
16 | # Do not print debug messages in production
17 | config :logger, level: :info
18 | 
19 | # ## SSL Support
20 | #
21 | # To get SSL working, you will need to add the `https` key
22 | # to the previous section and set your `:url` port to 443:
23 | #
24 | #     config :ketbin, KetbinWeb.Endpoint,
25 | #       ...
26 | #       url: [host: "example.com", port: 443],
27 | #       https: [
28 | #         port: 443,
29 | #         cipher_suite: :strong,
30 | #         keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
31 | #         certfile: System.get_env("SOME_APP_SSL_CERT_PATH"),
32 | #         transport_options: [socket_opts: [:inet6]]
33 | #       ]
34 | #
35 | # The `cipher_suite` is set to `:strong` to support only the
36 | # latest and more secure SSL ciphers. This means old browsers
37 | # and clients may not be supported. You can set it to
38 | # `:compatible` for wider support.
39 | #
40 | # `:keyfile` and `:certfile` expect an absolute path to the key
41 | # and cert in disk or a relative path inside priv, for example
42 | # "priv/ssl/server.key". For all supported SSL configuration
43 | # options, see https://hexdocs.pm/plug/Plug.SSL.html#configure/1
44 | #
45 | # We also recommend setting `force_ssl` in your endpoint, ensuring
46 | # no data is ever sent via http, always redirecting to https:
47 | #
48 | #     config :ketbin, KetbinWeb.Endpoint,
49 | #       force_ssl: [hsts: true]
50 | #
51 | # Check `Plug.SSL` for all available options in `force_ssl`.
52 | 
53 | # Finally import the config/prod.secret.exs which loads secrets
54 | # and configuration from environment variables.
55 | # import_config "prod.secret.exs"
56 | 


--------------------------------------------------------------------------------
/lib/ketbin_web.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb do
 2 |   @moduledoc """
 3 |   The entrypoint for defining your web interface, such
 4 |   as controllers, views, channels and so on.
 5 | 
 6 |   This can be used in your application as:
 7 | 
 8 |       use KetbinWeb, :controller
 9 |       use KetbinWeb, :view
10 | 
11 |   The definitions below will be executed for every view,
12 |   controller, etc, so keep them short and clean, focused
13 |   on imports, uses and aliases.
14 | 
15 |   Do NOT define functions inside the quoted expressions
16 |   below. Instead, define any helper function in modules
17 |   and import those modules here.
18 |   """
19 | 
20 |   def controller do
21 |     quote do
22 |       use Phoenix.Controller, namespace: KetbinWeb
23 | 
24 |       import Plug.Conn
25 |       import KetbinWeb.Gettext
26 |       alias KetbinWeb.Router.Helpers, as: Routes
27 |     end
28 |   end
29 | 
30 |   def view do
31 |     quote do
32 |       use Phoenix.View,
33 |         root: "lib/ketbin_web/templates",
34 |         namespace: KetbinWeb
35 | 
36 |       # Import convenience functions from controllers
37 |       import Phoenix.Controller,
38 |         only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]
39 | 
40 |       # Include shared imports and aliases for views
41 |       unquote(view_helpers())
42 |     end
43 |   end
44 | 
45 |   def router do
46 |     quote do
47 |       use Phoenix.Router
48 | 
49 |       import Plug.Conn
50 |       import Phoenix.Controller
51 |     end
52 |   end
53 | 
54 |   def channel do
55 |     quote do
56 |       use Phoenix.Channel
57 |       import KetbinWeb.Gettext
58 |     end
59 |   end
60 | 
61 |   defp view_helpers do
62 |     quote do
63 |       # Use all HTML functionality (forms, tags, etc)
64 |       use Phoenix.HTML
65 | 
66 |       # Import basic rendering functionality (render, render_layout, etc)
67 |       import Phoenix.View
68 | 
69 |       import KetbinWeb.ErrorHelpers
70 |       import KetbinWeb.Gettext
71 |       alias KetbinWeb.Router.Helpers, as: Routes
72 |     end
73 |   end
74 | 
75 |   @doc """
76 |   When used, dispatch to the appropriate controller/view/etc.
77 |   """
78 |   defmacro __using__(which) when is_atom(which) do
79 |     apply(__MODULE__, which, [])
80 |   end
81 | end
82 | 


--------------------------------------------------------------------------------
/test/ketbin/pastes_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.PastesTest do
 2 |   use Ketbin.DataCase
 3 | 
 4 |   alias Ketbin.Pastes
 5 | 
 6 |   describe "pastes" do
 7 |     alias Ketbin.Pastes.Paste
 8 | 
 9 |     @valid_attrs %{content: "some content", is_url: true}
10 |     @update_attrs %{content: "some updated content", is_url: false}
11 |     @invalid_attrs %{content: nil, is_url: nil}
12 | 
13 |     def paste_fixture(attrs \\ %{}) do
14 |       {:ok, paste} =
15 |         attrs
16 |         |> Enum.into(@valid_attrs)
17 |         |> Pastes.create_paste()
18 | 
19 |       paste
20 |     end
21 | 
22 |     test "list_pastes/0 returns all pastes" do
23 |       paste = paste_fixture()
24 |       assert Pastes.list_pastes() == [paste]
25 |     end
26 | 
27 |     test "get_paste!/1 returns the paste with given id" do
28 |       paste = paste_fixture()
29 |       assert Pastes.get_paste!(paste.id) == paste
30 |     end
31 | 
32 |     test "create_paste/1 with valid data creates a paste" do
33 |       assert {:ok, %Paste{} = paste} = Pastes.create_paste(@valid_attrs)
34 |       assert paste.content == "some content"
35 |       assert paste.is_url == true
36 |     end
37 | 
38 |     test "create_paste/1 with invalid data returns error changeset" do
39 |       assert {:error, %Ecto.Changeset{}} = Pastes.create_paste(@invalid_attrs)
40 |     end
41 | 
42 |     test "update_paste/2 with valid data updates the paste" do
43 |       paste = paste_fixture()
44 |       assert {:ok, %Paste{} = paste} = Pastes.update_paste(paste, @update_attrs)
45 |       assert paste.content == "some updated content"
46 |       assert paste.is_url == false
47 |     end
48 | 
49 |     test "update_paste/2 with invalid data returns error changeset" do
50 |       paste = paste_fixture()
51 |       assert {:error, %Ecto.Changeset{}} = Pastes.update_paste(paste, @invalid_attrs)
52 |       assert paste == Pastes.get_paste!(paste.id)
53 |     end
54 | 
55 |     test "delete_paste/1 deletes the paste" do
56 |       paste = paste_fixture()
57 |       assert {:ok, %Paste{}} = Pastes.delete_paste(paste)
58 |       assert_raise Ecto.NoResultsError, fn -> Pastes.get_paste!(paste.id) end
59 |     end
60 | 
61 |     test "change_paste/1 returns a paste changeset" do
62 |       paste = paste_fixture()
63 |       assert %Ecto.Changeset{} = Pastes.change_paste(paste)
64 |     end
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/lib/ketbin/accounts/user_notifier.ex:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.Accounts.UserNotifier do
 2 |   import Swoosh.Email
 3 |   # For simplicity, this module simply logs messages to the terminal.
 4 |   # You should replace it by a proper email or notification tool, such as:
 5 |   #
 6 |   #   * Swoosh - https://hexdocs.pm/swoosh
 7 |   #   * Bamboo - https://hexdocs.pm/bamboo
 8 |   #
 9 |   defp deliver(to, body, subject) do
10 |     require Logger
11 |     Logger.debug(body)
12 | 
13 |     Task.start(fn ->
14 |       new()
15 |       |> to(to)
16 |       |> from({"Katbin", "noreply@katb.in"})
17 |       |> subject(subject)
18 |       |> text_body(body)
19 |       |> Ketbin.Mailer.deliver()
20 |     end)
21 | 
22 |     {:ok, %{to: to, body: body}}
23 |   end
24 | 
25 |   @doc """
26 |   Deliver instructions to confirm account.
27 |   """
28 |   def deliver_confirmation_instructions(user, url) do
29 |     deliver(
30 |       user.email,
31 |       """
32 | 
33 |       ==============================
34 | 
35 |       Hi #{user.email},
36 | 
37 |       You can confirm your account by visiting the URL below:
38 | 
39 |       #{url}
40 | 
41 |       If you didn't create an account with us, please ignore this.
42 | 
43 |       ==============================
44 |       """,
45 |       "Account confirmation"
46 |     )
47 |   end
48 | 
49 |   @doc """
50 |   Deliver instructions to reset a user password.
51 |   """
52 |   def deliver_reset_password_instructions(user, url) do
53 |     deliver(
54 |       user.email,
55 |       """
56 | 
57 |       ==============================
58 | 
59 |       Hi #{user.email},
60 | 
61 |       You can reset your password by visiting the URL below:
62 | 
63 |       #{url}
64 | 
65 |       If you didn't request this change, please ignore this.
66 | 
67 |       ==============================
68 |       """,
69 |       "Password reset requested"
70 |     )
71 |   end
72 | 
73 |   @doc """
74 |   Deliver instructions to update a user email.
75 |   """
76 |   def deliver_update_email_instructions(user, url) do
77 |     deliver(
78 |       user.email,
79 |       """
80 | 
81 |       ==============================
82 | 
83 |       Hi #{user.email},
84 | 
85 |       You can change your email by visiting the URL below:
86 | 
87 |       #{url}
88 | 
89 |       If you didn't request this change, please ignore this.
90 | 
91 |       ==============================
92 |       """,
93 |       "Email update requested"
94 |     )
95 |   end
96 | end
97 | 


--------------------------------------------------------------------------------
/lib/ketbin/pastes.ex:
--------------------------------------------------------------------------------
  1 | defmodule Ketbin.Pastes do
  2 |   @moduledoc """
  3 |   The Pastes context.
  4 |   """
  5 | 
  6 |   import Ecto.Query, warn: false
  7 |   alias Ketbin.Repo
  8 | 
  9 |   alias Ketbin.Pastes.Paste
 10 | 
 11 |   @doc """
 12 |   Returns the list of pastes.
 13 | 
 14 |   ## Examples
 15 | 
 16 |       iex> list_pastes()
 17 |       [%Paste{}, ...]
 18 | 
 19 |   """
 20 |   def list_pastes do
 21 |     Repo.all(Paste)
 22 |   end
 23 | 
 24 |   def list_pastes_by_user(user_id) do
 25 |     Repo.all(from(p in Paste, where: p.belongs_to == ^user_id))
 26 |   end
 27 | 
 28 |   @doc """
 29 |   Gets a single paste.
 30 | 
 31 |   Raises `Ecto.NoResultsError` if the Paste does not exist.
 32 | 
 33 |   ## Examples
 34 | 
 35 |       iex> get_paste!(123)
 36 |       %Paste{}
 37 | 
 38 |       iex> get_paste!(456)
 39 |       ** (Ecto.NoResultsError)
 40 | 
 41 |   """
 42 |   def get_paste!(id), do: Repo.get!(Paste, id)
 43 | 
 44 |   @doc """
 45 |   Creates a paste.
 46 | 
 47 |   ## Examples
 48 | 
 49 |       iex> create_paste(%{field: value})
 50 |       {:ok, %Paste{}}
 51 | 
 52 |       iex> create_paste(%{field: bad_value})
 53 |       {:error, %Ecto.Changeset{}}
 54 | 
 55 |   """
 56 |   def create_paste(attrs \\ %{}) do
 57 |     %Paste{}
 58 |     |> Paste.changeset(attrs)
 59 |     |> Repo.insert()
 60 |   end
 61 | 
 62 |   @doc """
 63 |   Updates a paste.
 64 | 
 65 |   ## Examples
 66 | 
 67 |       iex> update_paste(paste, %{field: new_value})
 68 |       {:ok, %Paste{}}
 69 | 
 70 |       iex> update_paste(paste, %{field: bad_value})
 71 |       {:error, %Ecto.Changeset{}}
 72 | 
 73 |   """
 74 |   def update_paste(%Paste{} = paste, attrs) do
 75 |     paste
 76 |     |> Paste.changeset(attrs)
 77 |     |> Repo.update()
 78 |   end
 79 | 
 80 |   @doc """
 81 |   Deletes a paste.
 82 | 
 83 |   ## Examples
 84 | 
 85 |       iex> delete_paste(paste)
 86 |       {:ok, %Paste{}}
 87 | 
 88 |       iex> delete_paste(paste)
 89 |       {:error, %Ecto.Changeset{}}
 90 | 
 91 |   """
 92 |   def delete_paste(%Paste{} = paste) do
 93 |     Repo.delete(paste)
 94 |   end
 95 | 
 96 |   @doc """
 97 |   Returns an `%Ecto.Changeset{}` for tracking paste changes.
 98 | 
 99 |   ## Examples
100 | 
101 |       iex> change_paste(paste)
102 |       %Ecto.Changeset{data: %Paste{}}
103 | 
104 |   """
105 |   def change_paste(%Paste{} = paste, attrs \\ %{}) do
106 |     Paste.changeset(paste, attrs)
107 |   end
108 | end
109 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule Ketbin.MixProject do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :ketbin,
 7 |       version: "0.1.0",
 8 |       elixir: "~> 1.12",
 9 |       elixirc_paths: elixirc_paths(Mix.env()),
10 |       compilers: [:phoenix] ++ Mix.compilers(),
11 |       start_permanent: Mix.env() == :prod,
12 |       aliases: aliases(),
13 |       deps: deps()
14 |     ]
15 |   end
16 | 
17 |   # Configuration for the OTP application.
18 |   #
19 |   # Type `mix help compile.app` for more information.
20 |   def application do
21 |     [
22 |       mod: {Ketbin.Application, []},
23 |       extra_applications: [:logger, :runtime_tools, :ssl]
24 |     ]
25 |   end
26 | 
27 |   # Specifies which paths to compile per environment.
28 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
29 |   defp elixirc_paths(_), do: ["lib"]
30 | 
31 |   # Specifies your project dependencies.
32 |   #
33 |   # Type `mix help deps` for examples and options.
34 |   defp deps do
35 |     [
36 |       {:bcrypt_elixir, "~> 2.0"},
37 |       {:phoenix, "~> 1.6.7"},
38 |       {:phoenix_ecto, "~> 4.4"},
39 |       {:ecto_sql, "~> 3.7"},
40 |       {:postgrex, ">= 0.0.0"},
41 |       {:phoenix_html, "~> 3.0"},
42 |       {:phoenix_live_view, "~> 0.18.0"},
43 |       {:phoenix_live_reload, "~> 1.3", only: :dev},
44 |       {:phoenix_live_dashboard, "~> 0.5"},
45 |       {:telemetry_metrics, "~> 0.6"},
46 |       {:telemetry_poller, "~> 0.5"},
47 |       {:gettext, "~> 0.18"},
48 |       {:jason, "~> 1.2"},
49 |       {:plug_cowboy, "~> 2.5"},
50 |       {:cors_plug, "~> 3.0"},
51 |       {:rustler, "~> 0.25"},
52 |       {:html_sanitize_ex, "~> 1.4.3"},
53 |       {:hackney, "~> 1.17"},
54 |       {:swoosh, "~> 1.5"},
55 |       {:gen_smtp, "~> 1.1"},
56 |       {:earmark, "~> 1.4"},
57 |       {:mochiweb, "~> 3.1"}
58 |     ]
59 |   end
60 | 
61 |   # Aliases are shortcuts or tasks specific to the current project.
62 |   # For example, to install project dependencies and perform other setup tasks, run:
63 |   #
64 |   #     $ mix setup
65 |   #
66 |   # See the documentation for `Mix` for more info on aliases.
67 |   defp aliases do
68 |     [
69 |       setup: ["deps.get", "ecto.setup", "cmd npm install --prefix assets"],
70 |       "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
71 |       "ecto.reset": ["ecto.drop", "ecto.setup"],
72 |       test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"]
73 |     ]
74 |   end
75 | end
76 | 


--------------------------------------------------------------------------------
/assets/js/socket.js:
--------------------------------------------------------------------------------
 1 | // NOTE: The contents of this file will only be executed if
 2 | // you uncomment its entry in "assets/js/app.js".
 3 | 
 4 | // To use Phoenix channels, the first step is to import Socket,
 5 | // and connect at the socket path in "lib/web/endpoint.ex".
 6 | //
 7 | // Pass the token on params as below. Or remove it
 8 | // from the params if you are not using authentication.
 9 | import {Socket} from "phoenix"
10 | 
11 | let socket = new Socket("/socket", {params: {token: window.userToken}})
12 | 
13 | // When you connect, you'll often need to authenticate the client.
14 | // For example, imagine you have an authentication plug, `MyAuth`,
15 | // which authenticates the session and assigns a `:current_user`.
16 | // If the current user exists you can assign the user's token in
17 | // the connection for use in the layout.
18 | //
19 | // In your "lib/web/router.ex":
20 | //
21 | //     pipeline :browser do
22 | //       ...
23 | //       plug MyAuth
24 | //       plug :put_user_token
25 | //     end
26 | //
27 | //     defp put_user_token(conn, _) do
28 | //       if current_user = conn.assigns[:current_user] do
29 | //         token = Phoenix.Token.sign(conn, "user socket", current_user.id)
30 | //         assign(conn, :user_token, token)
31 | //       else
32 | //         conn
33 | //       end
34 | //     end
35 | //
36 | // Now you need to pass this token to JavaScript. You can do so
37 | // inside a script tag in "lib/web/templates/layout/app.html.eex":
38 | //
39 | //     <script>window.userToken = "<%= assigns[:user_token] %>";</script>
40 | //
41 | // You will need to verify the user token in the "connect/3" function
42 | // in "lib/web/channels/user_socket.ex":
43 | //
44 | //     def connect(%{"token" => token}, socket, _connect_info) do
45 | //       # max_age: 1209600 is equivalent to two weeks in seconds
46 | //       case Phoenix.Token.verify(socket, "user socket", token, max_age: 1209600) do
47 | //         {:ok, user_id} ->
48 | //           {:ok, assign(socket, :user, user_id)}
49 | //         {:error, reason} ->
50 | //           :error
51 | //       end
52 | //     end
53 | //
54 | // Finally, connect to the socket:
55 | socket.connect()
56 | 
57 | // Now that you are connected, you can join channels with a topic:
58 | let channel = socket.channel("topic:subtopic", {})
59 | channel.join()
60 |   .receive("ok", resp => { console.log("Joined successfully", resp) })
61 |   .receive("error", resp => { console.log("Unable to join", resp) })
62 | 
63 | export default socket
64 | 


--------------------------------------------------------------------------------
/assets/css/app.css:
--------------------------------------------------------------------------------
  1 | /* This file is for your main application css. */
  2 | @import "tailwindcss/base";
  3 | @import "tailwindcss/components";
  4 | @import "tailwindcss/utilities";
  5 | @import "./highlight.css";
  6 | @import "./markdown.css";
  7 | 
  8 | @font-face {
  9 |     font-family: "JetBrains Mono";
 10 |     src: url(/fonts/jetbrains_mono_variable.ttf);
 11 |     font-weight: 100 1000;
 12 |     font-stretch: 25% 151%;
 13 | }
 14 | 
 15 | * {
 16 |     font-family: "JetBrains Mono", monospace;
 17 |     color: white;
 18 |     font-size: 14px;
 19 |     font-weight: bold;
 20 | }
 21 | 
 22 | @layer base {
 23 |     h1 {
 24 |         font-size: 2em;
 25 |         font-weight: bold;
 26 |     }
 27 | 
 28 |     h2 {
 29 |         font-size: 1.5em;
 30 |         font-weight: bold;
 31 |     }
 32 | 
 33 |     h3 {
 34 |         font-size: 1.17em;
 35 |         font-weight: bold;
 36 |     }
 37 | 
 38 |     h4 {
 39 |         font-weight: bold;
 40 |     }
 41 | 
 42 |     h5 {
 43 |         font-size: 0.83em;
 44 |         font-weight: bold;
 45 |     }
 46 | 
 47 |     h6 {
 48 |         font-size: 0.67em;
 49 |         font-weight: bold;
 50 |     }
 51 | 
 52 |     h1,
 53 |     h2,
 54 |     h3 {
 55 |         margin-top: 20px;
 56 |         margin-bottom: 10px
 57 |     }
 58 | 
 59 |     img {
 60 |         display: inline;
 61 |     }
 62 | }
 63 | 
 64 | html,
 65 | body {
 66 |     width: 100%;
 67 |     height: 100%;
 68 | }
 69 | 
 70 | a {
 71 |     color: #ff9800;
 72 | }
 73 | 
 74 | a:hover {
 75 |     color: #ff9800;
 76 |     text-decoration: underline;
 77 | }
 78 | 
 79 | header {
 80 |     background-color: #1a1a1a;
 81 | }
 82 | 
 83 | code {
 84 |     font-family: "JetBrains Mono", monospace;
 85 | }
 86 | 
 87 | code {
 88 |     white-space: pre;
 89 |     font-size: 14px;
 90 |     font-weight: bold;
 91 | }
 92 | 
 93 | textarea {
 94 |     font-size: 14px;
 95 |     font-weight: bold;
 96 | }
 97 | 
 98 | ::-webkit-scrollbar {
 99 |     width: 8px;
100 |     height: 8px;
101 | }
102 | 
103 | ::-webkit-scrollbar-corner,
104 | ::-webkit-scrollbar-track {
105 |     background: transparent;
106 | }
107 | 
108 | ::-webkit-scrollbar-thumb {
109 |     border-radius: 8px;
110 |     @apply bg-amber;
111 | }
112 | 
113 | .alert {
114 |     width: 100%;
115 |     text-align: center;
116 | }
117 | 
118 | .alert-info {
119 |     background-color: #1ed98e;
120 |     color: black;
121 |     font-weight: bold;
122 | }
123 | 
124 | .alert-danger {
125 |     background-color: #ff9800;
126 |     color: black;
127 |     font-weight: bold;
128 | }


--------------------------------------------------------------------------------
/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
 1 | ## `msgid`s in this file come from POT (.pot) files.
 2 | ##
 3 | ## Do not add, change, or remove `msgid`s manually here as
 4 | ## they're tied to the ones in the corresponding POT file
 5 | ## (with the same domain).
 6 | ##
 7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
 8 | ## to merge POT files into PO files.
 9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 | 
13 | ## From Ecto.Changeset.cast/4
14 | msgid "can't be blank"
15 | msgstr ""
16 | 
17 | ## From Ecto.Changeset.unique_constraint/3
18 | msgid "has already been taken"
19 | msgstr ""
20 | 
21 | ## From Ecto.Changeset.put_change/3
22 | msgid "is invalid"
23 | msgstr ""
24 | 
25 | ## From Ecto.Changeset.validate_acceptance/3
26 | msgid "must be accepted"
27 | msgstr ""
28 | 
29 | ## From Ecto.Changeset.validate_format/3
30 | msgid "has invalid format"
31 | msgstr ""
32 | 
33 | ## From Ecto.Changeset.validate_subset/3
34 | msgid "has an invalid entry"
35 | msgstr ""
36 | 
37 | ## From Ecto.Changeset.validate_exclusion/3
38 | msgid "is reserved"
39 | msgstr ""
40 | 
41 | ## From Ecto.Changeset.validate_confirmation/3
42 | msgid "does not match confirmation"
43 | msgstr ""
44 | 
45 | ## From Ecto.Changeset.no_assoc_constraint/3
46 | msgid "is still associated with this entry"
47 | msgstr ""
48 | 
49 | msgid "are still associated with this entry"
50 | msgstr ""
51 | 
52 | ## From Ecto.Changeset.validate_length/3
53 | msgid "should be %{count} character(s)"
54 | msgid_plural "should be %{count} character(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 | 
58 | msgid "should have %{count} item(s)"
59 | msgid_plural "should have %{count} item(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 | 
63 | msgid "should be at least %{count} character(s)"
64 | msgid_plural "should be at least %{count} character(s)"
65 | msgstr[0] ""
66 | msgstr[1] ""
67 | 
68 | msgid "should have at least %{count} item(s)"
69 | msgid_plural "should have at least %{count} item(s)"
70 | msgstr[0] ""
71 | msgstr[1] ""
72 | 
73 | msgid "should be at most %{count} character(s)"
74 | msgid_plural "should be at most %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 | 
78 | msgid "should have at most %{count} item(s)"
79 | msgid_plural "should have at most %{count} item(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 | 
83 | ## From Ecto.Changeset.validate_number/3
84 | msgid "must be less than %{number}"
85 | msgstr ""
86 | 
87 | msgid "must be greater than %{number}"
88 | msgstr ""
89 | 
90 | msgid "must be less than or equal to %{number}"
91 | msgstr ""
92 | 
93 | msgid "must be greater than or equal to %{number}"
94 | msgstr ""
95 | 
96 | msgid "must be equal to %{number}"
97 | msgstr ""
98 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/user_settings_controller.ex:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserSettingsController do
 2 |   use KetbinWeb, :controller
 3 | 
 4 |   alias Ketbin.Accounts
 5 |   alias KetbinWeb.UserAuth
 6 | 
 7 |   plug :assign_email_and_password_changesets
 8 | 
 9 |   def edit(conn, _params) do
10 |     render(conn, "edit.html")
11 |   end
12 | 
13 |   def update(conn, %{"action" => "update_email"} = params) do
14 |     %{"current_password" => password, "user" => user_params} = params
15 |     user = conn.assigns.current_user
16 | 
17 |     case Accounts.apply_user_email(user, password, user_params) do
18 |       {:ok, applied_user} ->
19 |         Accounts.deliver_update_email_instructions(
20 |           applied_user,
21 |           user.email,
22 |           &Routes.user_settings_url(conn, :confirm_email, &1)
23 |         )
24 | 
25 |         conn
26 |         |> put_flash(
27 |           :info,
28 |           "A link to confirm your email change has been sent to the new address."
29 |         )
30 |         |> redirect(to: Routes.user_settings_path(conn, :edit))
31 | 
32 |       {:error, changeset} ->
33 |         render(conn, "edit.html", email_changeset: changeset)
34 |     end
35 |   end
36 | 
37 |   def update(conn, %{"action" => "update_password"} = params) do
38 |     %{"current_password" => password, "user" => user_params} = params
39 |     user = conn.assigns.current_user
40 | 
41 |     case Accounts.update_user_password(user, password, user_params) do
42 |       {:ok, user} ->
43 |         conn
44 |         |> put_flash(:info, "Password updated successfully.")
45 |         |> put_session(:user_return_to, Routes.user_settings_path(conn, :edit))
46 |         |> UserAuth.log_in_user(user)
47 | 
48 |         conn
49 | 
50 |       {:error, changeset} ->
51 |         render(conn, "edit.html", password_changeset: changeset)
52 |     end
53 |   end
54 | 
55 |   def confirm_email(conn, %{"token" => token}) do
56 |     case Accounts.update_user_email(conn.assigns.current_user, token) do
57 |       :ok ->
58 |         conn
59 |         |> put_flash(:info, "Email changed successfully.")
60 |         |> redirect(to: Routes.user_settings_path(conn, :edit))
61 | 
62 |       :error ->
63 |         conn
64 |         |> put_flash(:error, "Email change link is invalid or it has expired.")
65 |         |> redirect(to: Routes.user_settings_path(conn, :edit))
66 |     end
67 |   end
68 | 
69 |   defp assign_email_and_password_changesets(conn, _opts) do
70 |     user = conn.assigns.current_user
71 | 
72 |     conn
73 |     |> assign(:email_changeset, Accounts.change_user_email(user))
74 |     |> assign(:password_changeset, Accounts.change_user_password(user))
75 |   end
76 | end
77 | 


--------------------------------------------------------------------------------
/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
 1 | ## This is a PO Template file.
 2 | ##
 3 | ## `msgid`s here are often extracted from source code.
 4 | ## Add new translations manually only if they're dynamic
 5 | ## translations that can't be statically extracted.
 6 | ##
 7 | ## Run `mix gettext.extract` to bring this file up to
 8 | ## date. Leave `msgstr`s empty as changing them here has no
 9 | ## effect: edit them in PO (`.po`) files instead.
10 | 
11 | ## From Ecto.Changeset.cast/4
12 | msgid "can't be blank"
13 | msgstr ""
14 | 
15 | ## From Ecto.Changeset.unique_constraint/3
16 | msgid "has already been taken"
17 | msgstr ""
18 | 
19 | ## From Ecto.Changeset.put_change/3
20 | msgid "is invalid"
21 | msgstr ""
22 | 
23 | ## From Ecto.Changeset.validate_acceptance/3
24 | msgid "must be accepted"
25 | msgstr ""
26 | 
27 | ## From Ecto.Changeset.validate_format/3
28 | msgid "has invalid format"
29 | msgstr ""
30 | 
31 | ## From Ecto.Changeset.validate_subset/3
32 | msgid "has an invalid entry"
33 | msgstr ""
34 | 
35 | ## From Ecto.Changeset.validate_exclusion/3
36 | msgid "is reserved"
37 | msgstr ""
38 | 
39 | ## From Ecto.Changeset.validate_confirmation/3
40 | msgid "does not match confirmation"
41 | msgstr ""
42 | 
43 | ## From Ecto.Changeset.no_assoc_constraint/3
44 | msgid "is still associated with this entry"
45 | msgstr ""
46 | 
47 | msgid "are still associated with this entry"
48 | msgstr ""
49 | 
50 | ## From Ecto.Changeset.validate_length/3
51 | msgid "should be %{count} character(s)"
52 | msgid_plural "should be %{count} character(s)"
53 | msgstr[0] ""
54 | msgstr[1] ""
55 | 
56 | msgid "should have %{count} item(s)"
57 | msgid_plural "should have %{count} item(s)"
58 | msgstr[0] ""
59 | msgstr[1] ""
60 | 
61 | msgid "should be at least %{count} character(s)"
62 | msgid_plural "should be at least %{count} character(s)"
63 | msgstr[0] ""
64 | msgstr[1] ""
65 | 
66 | msgid "should have at least %{count} item(s)"
67 | msgid_plural "should have at least %{count} item(s)"
68 | msgstr[0] ""
69 | msgstr[1] ""
70 | 
71 | msgid "should be at most %{count} character(s)"
72 | msgid_plural "should be at most %{count} character(s)"
73 | msgstr[0] ""
74 | msgstr[1] ""
75 | 
76 | msgid "should have at most %{count} item(s)"
77 | msgid_plural "should have at most %{count} item(s)"
78 | msgstr[0] ""
79 | msgstr[1] ""
80 | 
81 | ## From Ecto.Changeset.validate_number/3
82 | msgid "must be less than %{number}"
83 | msgstr ""
84 | 
85 | msgid "must be greater than %{number}"
86 | msgstr ""
87 | 
88 | msgid "must be less than or equal to %{number}"
89 | msgstr ""
90 | 
91 | msgid "must be greater than or equal to %{number}"
92 | msgstr ""
93 | 
94 | msgid "must be equal to %{number}"
95 | msgstr ""
96 | 


--------------------------------------------------------------------------------
/config/releases.exs:
--------------------------------------------------------------------------------
  1 | # In this file, we load production configuration and secrets
  2 | # from environment variables. You can also hardcode secrets,
  3 | # although such is generally not recommended and you have to
  4 | # remember to add this file to your .gitignore.
  5 | import Config
  6 | 
  7 | db_host =
  8 |   System.get_env("DB_HOST") ||
  9 |     raise """
 10 |     environment variable DB_HOST is missing.
 11 |     """
 12 | 
 13 | db_port =
 14 |   System.get_env("DB_PORT") ||
 15 |     raise """
 16 |     environment variable DB_PORT is missing.
 17 |     """
 18 | 
 19 | db_username =
 20 |   System.get_env("DB_USERNAME") ||
 21 |     raise """
 22 |     environment variable DB_USERNAME is missing.
 23 |     """
 24 | 
 25 | db_password =
 26 |   System.get_env("DB_PASSWORD") ||
 27 |     raise """
 28 |     environment variable DB_PASSWORD is missing.
 29 |     """
 30 | 
 31 | db_database =
 32 |   System.get_env("DB_DATABASE") ||
 33 |     raise """
 34 |     environment variable DB_DATABASE is missing.
 35 |     """
 36 | 
 37 | 
 38 | 
 39 | config :ketbin, Ketbin.Repo,
 40 |   ssl: false,
 41 |   database: db_database,
 42 |   username: db_username,
 43 |   password: db_password,
 44 |   hostname: db_host,
 45 |   port: String.to_integer(db_port),
 46 |   # verify: :verify_peer,
 47 |   socket_options: [:inet],
 48 |   pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10")
 49 |   # cacertfile: "priv/cert.pem"
 50 | secret_key_base =
 51 |   System.get_env("SECRET_KEY_BASE") ||
 52 |     raise """
 53 |     environment variable SECRET_KEY_BASE is missing.
 54 |     You can generate one by calling: mix phx.gen.secret
 55 |     """
 56 | 
 57 | config :ketbin, KetbinWeb.Endpoint,
 58 |   http: [
 59 |     port: String.to_integer(System.get_env("PORT") || "4000"),
 60 |     transport_options: [socket_opts: [:inet6]]
 61 |   ],
 62 |   secret_key_base: secret_key_base,
 63 |   server: true
 64 | 
 65 | smtp_relay =
 66 |   System.get_env("SWOOSH_SMTP_RELAY") ||
 67 |     raise """
 68 |     environment variable SWOOSH_SMTP_RELAY is missing.
 69 |     """
 70 | 
 71 | username =
 72 |   System.get_env("SWOOSH_USERNAME") ||
 73 |     raise """
 74 |     environment variable SWOOSH_USERNAME is missing.
 75 |     """
 76 | 
 77 | password =
 78 |   System.get_env("SWOOSH_PASSWORD") ||
 79 |     raise """
 80 |     environment variable SWOOSH_PASSWORD is missing.
 81 |     """
 82 | 
 83 | # configure mailer
 84 | config :ketbin, Ketbin.Mailer,
 85 |   adapter: Swoosh.Adapters.SMTP,
 86 |   relay: smtp_relay,
 87 |   username: username,
 88 |   password: password,
 89 |   tls: :always,
 90 |   auth: :always,
 91 |   port: 587
 92 | 
 93 | # ## Using releases (Elixir v1.9+)
 94 | #
 95 | # If you are doing OTP releases, you need to instruct Phoenix
 96 | # to start each relevant endpoint:
 97 | #
 98 | #
 99 | # Then you can assemble a release by calling `mix release`.
100 | # See `mix help release` for more information.
101 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/user_settings/edit.html.heex:
--------------------------------------------------------------------------------
 1 | <h1 class="font-bold text-4xl text-amber pt-4 w-full text-center">Settings</h1>
 2 | 
 3 | <div class="flex w-full h-full justify-center items-center">
 4 | <%= form_for @email_changeset, Routes.user_settings_path(@conn, :update), [class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
 5 | 	<h3 class="font-bold text-2xl text-amber pb-4">Change email</h3>
 6 | 
 7 |   <%= if @email_changeset.action do %>
 8 |     <div class="alert alert-danger">
 9 |       <p>Oops, something went wrong! Please check the errors below.</p>
10 |     </div>
11 |   <% end %>
12 | 
13 |   <%= hidden_input f, :action, name: "action", value: "update_email" %>
14 | 
15 | 	<div class="flex flex-col w-full">
16 | 		<%= label f, :email %>
17 | 		<%= email_input f, :email, [class: "text-black px-2 py-1 outline-none", required: true] %>
18 | 		<%= error_tag f, :email %>
19 | 	</div>
20 | 
21 | 	<div class="flex flex-col w-full">
22 | 		<%= label f, :current_password, for: "current_password_for_email" %>
23 | 		<%= password_input f, :current_password, [class: "text-black px-2 py-1 outline-none", required: true, name: "current_password", id: "current_password_for_email"]%>
24 | 		<%= error_tag f, :current_password %>
25 | 	</div>
26 | 
27 |   <div class="bg-amber mt-4 rounded-sm px-2 py-1">
28 |     <%= submit "Change email" %>
29 |   </div>
30 | <% end %>
31 | 
32 | 
33 | 	<%= form_for @password_changeset, Routes.user_settings_path(@conn, :update), [class: "flex flex-col h-full justify-center items-start m-auto"], fn f -> %>
34 | 		<h3 class="font-bold text-2xl text-amber pb-4">Change password</h3>
35 | 
36 | 		<%= if @password_changeset.action do %>
37 | 			<div class="alert alert-danger">
38 | 				<p>Oops, something went wrong! Please check the errors below.</p>
39 | 			</div>
40 | 		<% end %>
41 | 
42 | 		<%= hidden_input f, :action, name: "action", value: "update_password" %>
43 | 
44 | 		<div class="flex flex-col w-full">
45 | 			<%= label f, :password, "New password" %>
46 | 			<%= password_input f, :password, [class: "text-black px-2 py-1 outline-none", required: true] %>
47 | 			<%= error_tag f, :password %>
48 | 		</div>
49 | 
50 | 		<div class="flex flex-col w-full">
51 | 			<%= label f, :password_confirmation, "Confirm new password" %>
52 | 			<%= password_input f, :password_confirmation, [class: "text-black px-2 py-1 outline-none", required: true] %>
53 | 			<%= error_tag f, :password_confirmation %>
54 | 		</div>
55 | 
56 | 		<div class="flex flex-col w-full">
57 | 			<%= label f, :current_password, for: "current_password_for_password" %>
58 | 			<%= password_input f, :current_password, [class: "text-black px-2 py-1 outline-none", required: true, name: "current_password", id: "current_password_for_password"] %>
59 | 			<%= error_tag f, :current_password %>
60 | 		</div>
61 | 
62 | 		<div class="bg-amber mt-4 rounded-sm px-2 py-1">
63 | 			<%= submit "Change password" %>
64 | 		</div>
65 | 	<% end %>
66 | </div>
67 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/paste_controller_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.PasteControllerTest do
 2 |   use KetbinWeb.ConnCase
 3 | 
 4 |   alias Ketbin.Pastes
 5 | 
 6 |   @create_attrs %{content: "some content", is_url: true}
 7 |   @update_attrs %{content: "some updated content", is_url: false}
 8 |   @invalid_attrs %{content: nil, is_url: nil}
 9 | 
10 |   def fixture(:paste) do
11 |     {:ok, paste} = Pastes.create_paste(@create_attrs)
12 |     paste
13 |   end
14 | 
15 |   describe "index" do
16 |     test "lists all pastes", %{conn: conn} do
17 |       conn = get(conn, Routes.paste_path(conn, :index))
18 |       assert html_response(conn, 200) =~ "Listing Pastes"
19 |     end
20 |   end
21 | 
22 |   describe "new paste" do
23 |     test "renders form", %{conn: conn} do
24 |       conn = get(conn, Routes.paste_path(conn, :new))
25 |       assert html_response(conn, 200) =~ "New Paste"
26 |     end
27 |   end
28 | 
29 |   describe "create paste" do
30 |     test "redirects to show when data is valid", %{conn: conn} do
31 |       conn = post(conn, Routes.paste_path(conn, :create), paste: @create_attrs)
32 | 
33 |       assert %{id: id} = redirected_params(conn)
34 |       assert redirected_to(conn) == Routes.paste_path(conn, :show, id)
35 | 
36 |       conn = get(conn, Routes.paste_path(conn, :show, id))
37 |       assert html_response(conn, 200) =~ "Show Paste"
38 |     end
39 | 
40 |     test "renders errors when data is invalid", %{conn: conn} do
41 |       conn = post(conn, Routes.paste_path(conn, :create), paste: @invalid_attrs)
42 |       assert html_response(conn, 200) =~ "New Paste"
43 |     end
44 |   end
45 | 
46 |   describe "edit paste" do
47 |     setup [:create_paste]
48 | 
49 |     test "renders form for editing chosen paste", %{conn: conn, paste: paste} do
50 |       conn = get(conn, Routes.paste_path(conn, :edit, paste))
51 |       assert html_response(conn, 200) =~ "Edit Paste"
52 |     end
53 |   end
54 | 
55 |   describe "update paste" do
56 |     setup [:create_paste]
57 | 
58 |     test "redirects when data is valid", %{conn: conn, paste: paste} do
59 |       conn = put(conn, Routes.paste_path(conn, :update, paste), paste: @update_attrs)
60 |       assert redirected_to(conn) == Routes.paste_path(conn, :show, paste)
61 | 
62 |       conn = get(conn, Routes.paste_path(conn, :show, paste))
63 |       assert html_response(conn, 200) =~ "some updated content"
64 |     end
65 | 
66 |     test "renders errors when data is invalid", %{conn: conn, paste: paste} do
67 |       conn = put(conn, Routes.paste_path(conn, :update, paste), paste: @invalid_attrs)
68 |       assert html_response(conn, 200) =~ "Edit Paste"
69 |     end
70 |   end
71 | 
72 |   describe "delete paste" do
73 |     setup [:create_paste]
74 | 
75 |     test "deletes chosen paste", %{conn: conn, paste: paste} do
76 |       conn = delete(conn, Routes.paste_path(conn, :delete, paste))
77 |       assert redirected_to(conn) == Routes.paste_path(conn, :index)
78 | 
79 |       assert_error_sent 404, fn ->
80 |         get(conn, Routes.paste_path(conn, :show, paste))
81 |       end
82 |     end
83 |   end
84 | 
85 |   defp create_paste(_) do
86 |     paste = fixture(:paste)
87 |     %{paste: paste}
88 |   end
89 | end
90 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/user_session_controller_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserSessionControllerTest do
 2 |   use KetbinWeb.ConnCase, async: true
 3 | 
 4 |   import Ketbin.AccountsFixtures
 5 | 
 6 |   setup do
 7 |     %{user: user_fixture()}
 8 |   end
 9 | 
10 |   describe "GET /users/log_in" do
11 |     test "renders log in page", %{conn: conn} do
12 |       conn = get(conn, Routes.user_session_path(conn, :new))
13 |       response = html_response(conn, 200)
14 |       assert response =~ "<h1>Log in</h1>"
15 |       assert response =~ "Log in</a>"
16 |       assert response =~ "Register</a>"
17 |     end
18 | 
19 |     test "redirects if already logged in", %{conn: conn, user: user} do
20 |       conn = conn |> log_in_user(user) |> get(Routes.user_session_path(conn, :new))
21 |       assert redirected_to(conn) == "/"
22 |     end
23 |   end
24 | 
25 |   describe "POST /users/log_in" do
26 |     test "logs the user in", %{conn: conn, user: user} do
27 |       conn =
28 |         post(conn, Routes.user_session_path(conn, :create), %{
29 |           "user" => %{"email" => user.email, "password" => valid_user_password()}
30 |         })
31 | 
32 |       assert get_session(conn, :user_token)
33 |       assert redirected_to(conn) =~ "/"
34 | 
35 |       # Now do a logged in request and assert on the menu
36 |       conn = get(conn, "/")
37 |       response = html_response(conn, 200)
38 |       assert response =~ user.email
39 |       assert response =~ "Settings</a>"
40 |       assert response =~ "Log out</a>"
41 |     end
42 | 
43 |     test "logs the user in with remember me", %{conn: conn, user: user} do
44 |       conn =
45 |         post(conn, Routes.user_session_path(conn, :create), %{
46 |           "user" => %{
47 |             "email" => user.email,
48 |             "password" => valid_user_password(),
49 |             "remember_me" => "true"
50 |           }
51 |         })
52 | 
53 |       assert conn.resp_cookies["_ketbin_web_user_remember_me"]
54 |       assert redirected_to(conn) =~ "/"
55 |     end
56 | 
57 |     test "logs the user in with return to", %{conn: conn, user: user} do
58 |       conn =
59 |         conn
60 |         |> init_test_session(user_return_to: "/foo/bar")
61 |         |> post(Routes.user_session_path(conn, :create), %{
62 |           "user" => %{
63 |             "email" => user.email,
64 |             "password" => valid_user_password()
65 |           }
66 |         })
67 | 
68 |       assert redirected_to(conn) == "/foo/bar"
69 |     end
70 | 
71 |     test "emits error message with invalid credentials", %{conn: conn, user: user} do
72 |       conn =
73 |         post(conn, Routes.user_session_path(conn, :create), %{
74 |           "user" => %{"email" => user.email, "password" => "invalid_password"}
75 |         })
76 | 
77 |       response = html_response(conn, 200)
78 |       assert response =~ "<h1>Log in</h1>"
79 |       assert response =~ "Invalid email or password"
80 |     end
81 |   end
82 | 
83 |   describe "DELETE /users/log_out" do
84 |     test "logs the user out", %{conn: conn, user: user} do
85 |       conn = conn |> log_in_user(user) |> delete(Routes.user_session_path(conn, :delete))
86 |       assert redirected_to(conn) == "/"
87 |       refute get_session(conn, :user_token)
88 |       assert get_flash(conn, :info) =~ "Logged out successfully"
89 |     end
90 | 
91 |     test "succeeds even if the user is not logged in", %{conn: conn} do
92 |       conn = delete(conn, Routes.user_session_path(conn, :delete))
93 |       assert redirected_to(conn) == "/"
94 |       refute get_session(conn, :user_token)
95 |       assert get_flash(conn, :info) =~ "Logged out successfully"
96 |     end
97 |   end
98 | end
99 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/user_confirmation_controller_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule KetbinWeb.UserConfirmationControllerTest do
 2 |   use KetbinWeb.ConnCase, async: true
 3 | 
 4 |   alias Ketbin.Accounts
 5 |   alias Ketbin.Repo
 6 |   import Ketbin.AccountsFixtures
 7 | 
 8 |   setup do
 9 |     %{user: user_fixture()}
10 |   end
11 | 
12 |   describe "GET /users/confirm" do
13 |     test "renders the confirmation page", %{conn: conn} do
14 |       conn = get(conn, Routes.user_confirmation_path(conn, :new))
15 |       response = html_response(conn, 200)
16 |       assert response =~ "<h1>Resend confirmation instructions</h1>"
17 |     end
18 |   end
19 | 
20 |   describe "POST /users/confirm" do
21 |     @tag :capture_log
22 |     test "sends a new confirmation token", %{conn: conn, user: user} do
23 |       conn =
24 |         post(conn, Routes.user_confirmation_path(conn, :create), %{
25 |           "user" => %{"email" => user.email}
26 |         })
27 | 
28 |       assert redirected_to(conn) == "/"
29 |       assert get_flash(conn, :info) =~ "If your email is in our system"
30 |       assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "confirm"
31 |     end
32 | 
33 |     test "does not send confirmation token if User is confirmed", %{conn: conn, user: user} do
34 |       Repo.update!(Accounts.User.confirm_changeset(user))
35 | 
36 |       conn =
37 |         post(conn, Routes.user_confirmation_path(conn, :create), %{
38 |           "user" => %{"email" => user.email}
39 |         })
40 | 
41 |       assert redirected_to(conn) == "/"
42 |       assert get_flash(conn, :info) =~ "If your email is in our system"
43 |       refute Repo.get_by(Accounts.UserToken, user_id: user.id)
44 |     end
45 | 
46 |     test "does not send confirmation token if email is invalid", %{conn: conn} do
47 |       conn =
48 |         post(conn, Routes.user_confirmation_path(conn, :create), %{
49 |           "user" => %{"email" => "unknown@example.com"}
50 |         })
51 | 
52 |       assert redirected_to(conn) == "/"
53 |       assert get_flash(conn, :info) =~ "If your email is in our system"
54 |       assert Repo.all(Accounts.UserToken) == []
55 |     end
56 |   end
57 | 
58 |   describe "GET /users/confirm/:token" do
59 |     test "confirms the given token once", %{conn: conn, user: user} do
60 |       token =
61 |         extract_user_token(fn url ->
62 |           Accounts.deliver_user_confirmation_instructions(user, url)
63 |         end)
64 | 
65 |       conn = get(conn, Routes.user_confirmation_path(conn, :confirm, token))
66 |       assert redirected_to(conn) == "/"
67 |       assert get_flash(conn, :info) =~ "User confirmed successfully"
68 |       assert Accounts.get_user!(user.id).confirmed_at
69 |       refute get_session(conn, :user_token)
70 |       assert Repo.all(Accounts.UserToken) == []
71 | 
72 |       # When not logged in
73 |       conn = get(conn, Routes.user_confirmation_path(conn, :confirm, token))
74 |       assert redirected_to(conn) == "/"
75 |       assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
76 | 
77 |       # When logged in
78 |       conn =
79 |         build_conn()
80 |         |> log_in_user(user)
81 |         |> get(Routes.user_confirmation_path(conn, :confirm, token))
82 | 
83 |       assert redirected_to(conn) == "/"
84 |       refute get_flash(conn, :error)
85 |     end
86 | 
87 |     test "does not confirm email with invalid token", %{conn: conn, user: user} do
88 |       conn = get(conn, Routes.user_confirmation_path(conn, :confirm, "oops"))
89 |       assert redirected_to(conn) == "/"
90 |       assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
91 |       refute Accounts.get_user!(user.id).confirmed_at
92 |     end
93 |   end
94 | end
95 | 


--------------------------------------------------------------------------------
/assets/css/markdown.css:
--------------------------------------------------------------------------------
  1 | .markdown p {
  2 |   font-family: sans-serif;
  3 |   font-weight: 400;
  4 | }
  5 | 
  6 | .markdown p > * {
  7 |   font-family: sans-serif;
  8 |   font-weight: 400;
  9 | }
 10 | 
 11 | .markdown h1,
 12 | h2,
 13 | h3 {
 14 |   margin-top: 20px;
 15 |   margin-bottom: 10px;
 16 | }
 17 | 
 18 | .markdown h1 {
 19 |   font-size: 2em;
 20 |   @apply text-amber;
 21 | }
 22 | 
 23 | .markdown h2 {
 24 |   font-size: 1.5em;
 25 |   @apply text-amber;
 26 | }
 27 | 
 28 | .markdown h3 {
 29 |   font-size: 1.17em;
 30 |   @apply text-amber;
 31 | }
 32 | 
 33 | .markdown h4 {
 34 |   font-size: 1em;
 35 |   @apply text-amber;
 36 |   margin-bottom: 10px;
 37 | }
 38 | 
 39 | .markdown h5 {
 40 |   font-size: 0.83em;
 41 |   @apply text-amber;
 42 |   margin-bottom: 10px;
 43 | }
 44 | 
 45 | .markdown h6 {
 46 |   font-size: 0.75em;
 47 |   @apply text-amber;
 48 |   margin-bottom: 10px;
 49 | }
 50 | 
 51 | .markdown blockquote {
 52 |   padding: 0 1em;
 53 |   margin: 0 0 20px;
 54 |   font-size: 17.5px;
 55 |   border-left: 4px solid #8b949e;
 56 | }
 57 | 
 58 | .markdown img {
 59 |   max-width: 35%;
 60 |   vertical-align: middle;
 61 |   display: inline;
 62 | }
 63 | 
 64 | .markdown table {
 65 |   width: 100%;
 66 |   max-width: 100%;
 67 |   margin-bottom: 20px;
 68 |   margin-top: 10px;
 69 | }
 70 | tbody > tr:nth-child(odd) > td,
 71 | .table-striped > tbody > tr:nth-child(odd) > th {
 72 |   background-color: #1b1b1b;
 73 | }
 74 | .table-striped > tbody > tr:nth-child(odd) > td,
 75 | .table-striped > tbody > tr:nth-child(odd) > th {
 76 |   background-color: #1b1b1b;
 77 | }
 78 | table > thead > tr > th,
 79 | table > tbody > tr > th,
 80 | table > tfoot > tr > th,
 81 | table > thead > tr > td,
 82 | table > tbody > tr > td,
 83 | table > tfoot > tr > td {
 84 |   padding: 8px;
 85 |   line-height: 1.42857143;
 86 |   vertical-align: top;
 87 |   border: 1px solid #3b434b;
 88 | }
 89 | 
 90 | .markdown hr {
 91 |   margin-top: 20px;
 92 |   margin-bottom: 20px;
 93 |   border: 0;
 94 |   border-top: 1px solid #3b434b;
 95 | }
 96 | 
 97 | .markdown {
 98 |   /* border: 1px solid #3b434b; */
 99 |   border-radius: 6px;
100 |   padding-right: 32px;
101 |   padding-left: 32px;
102 | }
103 | 
104 | .markdown pre {
105 |   padding: 12px;
106 |   overflow: auto;
107 |   font-size: 85%;
108 |   line-height: 1.45;
109 |   background-color: #1b1b1b;
110 |   border-radius: 6px;
111 |   margin: 10px 0;
112 | }
113 | 
114 | .markdown code pre tt {
115 |   font-family: "JetbrainsMono", SFMono-Regular, Consolas, Liberation Mono, Menlo,
116 |     monospace;
117 | }
118 | 
119 | .markdown blockquote > :last-child {
120 |   margin-bottom: 0;
121 | }
122 | 
123 | .markdown blockquote,
124 | .markdown p,
125 | .markdown ol,
126 | .markdown pre,
127 | .markdown table,
128 | .markdown ul {
129 |   margin-top: 0;
130 |   margin-bottom: 16px;
131 | }
132 | 
133 | h1,
134 | h2 {
135 |   padding-bottom: 0.3em;
136 |   border-bottom: 1px solid #3b434b;
137 | }
138 | 
139 | .markdown li {
140 |   display: list-item;
141 |   text-align: -webkit-match-parent;
142 |   font-family: sans-serif;
143 |   font-weight: 400;
144 | }
145 | 
146 | .markdown ol {
147 |   list-style-type: decimal;
148 | }
149 | 
150 | .markdown ol,
151 | ul {
152 |   padding: 0;
153 |   margin-left: 40px;
154 | }
155 | 
156 | .markdown strong {
157 |   font-family: sans-serif;
158 | }
159 | 
160 | .markdown code.inline {
161 |   font-family: "JetBrains Mono", monospace;
162 |   background-color: rgb(240 246 252 / 15%);
163 | 	font-weight: bold;
164 |   border-radius: 4px;
165 |   font-size: 80%;
166 |   margin: 0;
167 |   padding: 0.1em 0.4em;
168 | }
169 | 
170 | .markdown ul {
171 | 	list-style: disc;
172 | }
173 | .markdown ol {
174 | 	list-style: decimal;
175 | }
176 | .markdown ul, ol {
177 | 	padding: 0;
178 | 	margin-left: 40px;
179 | }


--------------------------------------------------------------------------------
/lib/ketbin_web/router.ex:
--------------------------------------------------------------------------------
  1 | defmodule KetbinWeb.Router do
  2 |   use KetbinWeb, :router
  3 | 
  4 |   import KetbinWeb.UserAuth
  5 | 
  6 |   pipeline :browser do
  7 |     plug :accepts, ["html"]
  8 |     plug :fetch_session
  9 |     plug :fetch_flash
 10 |     plug :protect_from_forgery
 11 |     plug :put_secure_browser_headers
 12 |     plug :fetch_current_user
 13 |   end
 14 | 
 15 |   pipeline :api do
 16 |     plug :accepts, ["json"]
 17 |     plug :fetch_session
 18 |     plug :fetch_current_user
 19 |   end
 20 | 
 21 |   # scope to ensure user is authenticated
 22 |   scope "/", KetbinWeb do
 23 |     pipe_through [:browser, :require_authenticated_user]
 24 | 
 25 |     get "/pastes", PageController, :pastes
 26 |   end
 27 | 
 28 |   scope "/", KetbinWeb do
 29 |     pipe_through :browser
 30 | 
 31 |     get "/", PageController, :index
 32 |     get "/:id/raw", PageController, :raw
 33 | 
 34 |     post "/", PageController, :create
 35 |   end
 36 | 
 37 |   # scope to check if user is owner of paste
 38 |   scope "/", KetbinWeb do
 39 |     pipe_through [:browser, :owns_paste]
 40 | 
 41 |     get "/:id", PageController, :show
 42 |     get "/v/:id", PageController, :showlink
 43 |   end
 44 | 
 45 |   # scope to ensure user is owner of paste
 46 |   scope "/", KetbinWeb do
 47 |     pipe_through [:browser, :ensure_owns_paste]
 48 | 
 49 |     get "/edit/:id", PageController, :edit
 50 |     patch "/:id", PageController, :update
 51 |     put "/:id", PageController, :update
 52 |   end
 53 | 
 54 |   scope "/api", KetbinWeb.Api, as: :api do
 55 |     pipe_through :api
 56 | 
 57 |     resources "/paste", PasteController, only: [:show, :index, :create]
 58 |   end
 59 | 
 60 |   # Other scopes may use custom stacks.
 61 |   # scope "/api", KetbinWeb do
 62 |   #   pipe_through :api
 63 |   # end
 64 | 
 65 |   # Enables LiveDashboard only for development
 66 |   #
 67 |   # If you want to use the LiveDashboard in production, you should put
 68 |   # it behind authentication and allow only admins to access it.
 69 |   # If your application does not have an admins-only section yet,
 70 |   # you can use Plug.BasicAuth to set up some basic authentication
 71 |   # as long as you are also using SSL (which you should anyway).
 72 |   if Mix.env() in [:dev, :test] do
 73 |     import Phoenix.LiveDashboard.Router
 74 | 
 75 |     scope "/" do
 76 |       pipe_through :browser
 77 | 
 78 |       live_dashboard "/dashboard", metrics: KetbinWeb.Telemetry
 79 |       forward "/mailbox", Plug.Swoosh.MailboxPreview
 80 |     end
 81 |   end
 82 | 
 83 |   ## Authentication routes
 84 | 
 85 |   scope "/", KetbinWeb do
 86 |     pipe_through [:browser, :redirect_if_user_is_authenticated]
 87 | 
 88 |     get "/users/register", UserRegistrationController, :new
 89 |     post "/users/register", UserRegistrationController, :create
 90 |     get "/users/log_in", UserSessionController, :new
 91 |     post "/users/log_in", UserSessionController, :create
 92 |     get "/users/reset_password", UserResetPasswordController, :new
 93 |     post "/users/reset_password", UserResetPasswordController, :create
 94 |     get "/users/reset_password/:token", UserResetPasswordController, :edit
 95 |     put "/users/reset_password/:token", UserResetPasswordController, :update
 96 |   end
 97 | 
 98 |   scope "/", KetbinWeb do
 99 |     pipe_through [:browser, :require_authenticated_user]
100 | 
101 |     get "/users/settings", UserSettingsController, :edit
102 |     put "/users/settings", UserSettingsController, :update
103 |     get "/users/settings/confirm_email/:token", UserSettingsController, :confirm_email
104 |   end
105 | 
106 |   scope "/", KetbinWeb do
107 |     pipe_through [:browser]
108 | 
109 |     delete "/users/log_out", UserSessionController, :delete
110 |     get "/users/confirm", UserConfirmationController, :new
111 |     post "/users/confirm", UserConfirmationController, :create
112 |     get "/users/confirm/:token", UserConfirmationController, :confirm
113 | 
114 |   end
115 | end
116 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/user_reset_password_controller_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule KetbinWeb.UserResetPasswordControllerTest do
  2 |   use KetbinWeb.ConnCase, async: true
  3 | 
  4 |   alias Ketbin.Accounts
  5 |   alias Ketbin.Repo
  6 |   import Ketbin.AccountsFixtures
  7 | 
  8 |   setup do
  9 |     %{user: user_fixture()}
 10 |   end
 11 | 
 12 |   describe "GET /users/reset_password" do
 13 |     test "renders the reset password page", %{conn: conn} do
 14 |       conn = get(conn, Routes.user_reset_password_path(conn, :new))
 15 |       response = html_response(conn, 200)
 16 |       assert response =~ "<h1>Forgot your password?</h1>"
 17 |     end
 18 |   end
 19 | 
 20 |   describe "POST /users/reset_password" do
 21 |     @tag :capture_log
 22 |     test "sends a new reset password token", %{conn: conn, user: user} do
 23 |       conn =
 24 |         post(conn, Routes.user_reset_password_path(conn, :create), %{
 25 |           "user" => %{"email" => user.email}
 26 |         })
 27 | 
 28 |       assert redirected_to(conn) == "/"
 29 |       assert get_flash(conn, :info) =~ "If your email is in our system"
 30 |       assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "reset_password"
 31 |     end
 32 | 
 33 |     test "does not send reset password token if email is invalid", %{conn: conn} do
 34 |       conn =
 35 |         post(conn, Routes.user_reset_password_path(conn, :create), %{
 36 |           "user" => %{"email" => "unknown@example.com"}
 37 |         })
 38 | 
 39 |       assert redirected_to(conn) == "/"
 40 |       assert get_flash(conn, :info) =~ "If your email is in our system"
 41 |       assert Repo.all(Accounts.UserToken) == []
 42 |     end
 43 |   end
 44 | 
 45 |   describe "GET /users/reset_password/:token" do
 46 |     setup %{user: user} do
 47 |       token =
 48 |         extract_user_token(fn url ->
 49 |           Accounts.deliver_user_reset_password_instructions(user, url)
 50 |         end)
 51 | 
 52 |       %{token: token}
 53 |     end
 54 | 
 55 |     test "renders reset password", %{conn: conn, token: token} do
 56 |       conn = get(conn, Routes.user_reset_password_path(conn, :edit, token))
 57 |       assert html_response(conn, 200) =~ "<h1>Reset password</h1>"
 58 |     end
 59 | 
 60 |     test "does not render reset password with invalid token", %{conn: conn} do
 61 |       conn = get(conn, Routes.user_reset_password_path(conn, :edit, "oops"))
 62 |       assert redirected_to(conn) == "/"
 63 |       assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired"
 64 |     end
 65 |   end
 66 | 
 67 |   describe "PUT /users/reset_password/:token" do
 68 |     setup %{user: user} do
 69 |       token =
 70 |         extract_user_token(fn url ->
 71 |           Accounts.deliver_user_reset_password_instructions(user, url)
 72 |         end)
 73 | 
 74 |       %{token: token}
 75 |     end
 76 | 
 77 |     test "resets password once", %{conn: conn, user: user, token: token} do
 78 |       conn =
 79 |         put(conn, Routes.user_reset_password_path(conn, :update, token), %{
 80 |           "user" => %{
 81 |             "password" => "new valid password",
 82 |             "password_confirmation" => "new valid password"
 83 |           }
 84 |         })
 85 | 
 86 |       assert redirected_to(conn) == Routes.user_session_path(conn, :new)
 87 |       refute get_session(conn, :user_token)
 88 |       assert get_flash(conn, :info) =~ "Password reset successfully"
 89 |       assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
 90 |     end
 91 | 
 92 |     test "does not reset password on invalid data", %{conn: conn, token: token} do
 93 |       conn =
 94 |         put(conn, Routes.user_reset_password_path(conn, :update, token), %{
 95 |           "user" => %{
 96 |             "password" => "too short",
 97 |             "password_confirmation" => "does not match"
 98 |           }
 99 |         })
100 | 
101 |       response = html_response(conn, 200)
102 |       assert response =~ "<h1>Reset password</h1>"
103 |       assert response =~ "should be at least 12 character(s)"
104 |       assert response =~ "does not match password"
105 |     end
106 | 
107 |     test "does not reset password with invalid token", %{conn: conn} do
108 |       conn = put(conn, Routes.user_reset_password_path(conn, :update, "oops"))
109 |       assert redirected_to(conn) == "/"
110 |       assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired"
111 |     end
112 |   end
113 | end
114 | 


--------------------------------------------------------------------------------
/assets/css/highlight.css:
--------------------------------------------------------------------------------
  1 | .code {
  2 |   color: #c0c5ce;
  3 |   background-color: #2b303b;
  4 | }
  5 | .variable.parameter.function {
  6 |   color: #c0c5ce;
  7 | }
  8 | .comment {
  9 |   color: #65737e;
 10 | }
 11 | .punctuation.definition.comment {
 12 |   color: #65737e;
 13 | }
 14 | .punctuation.definition.string {
 15 |   color: #c0c5ce;
 16 | }
 17 | .punctuation.definition.variable {
 18 |   color: #c0c5ce;
 19 | }
 20 | .punctuation.definition.string {
 21 |   color: #c0c5ce;
 22 | }
 23 | .punctuation.definition.parameters {
 24 |   color: #c0c5ce;
 25 | }
 26 | .punctuation.definition.string {
 27 |   color: #c0c5ce;
 28 | }
 29 | .punctuation.definition.array {
 30 |   color: #c0c5ce;
 31 | }
 32 | .none {
 33 |   color: #c0c5ce;
 34 | }
 35 | .keyword.operator {
 36 |   color: #c0c5ce;
 37 | }
 38 | .keyword {
 39 |   color: #b48ead;
 40 | }
 41 | .variable {
 42 |   color: #bf616a;
 43 | }
 44 | .variable.other.dollar.only.js {
 45 |   color: #bf616a;
 46 | }
 47 | .entity.name.function {
 48 |   color: #8fa1b3;
 49 | }
 50 | .meta.require {
 51 |   color: #8fa1b3;
 52 | }
 53 | .support.function.any-method {
 54 |   color: #8fa1b3;
 55 | }
 56 | .variable.function {
 57 |   color: #8fa1b3;
 58 | }
 59 | .support.class {
 60 |   color: #ebcb8b;
 61 | }
 62 | .entity.name.class {
 63 |   color: #ebcb8b;
 64 | }
 65 | .entity.name.type.class {
 66 |   color: #ebcb8b;
 67 | }
 68 | .meta.class {
 69 |   color: #eff1f5;
 70 | }
 71 | .keyword.other.special-method {
 72 |   color: #8fa1b3;
 73 | }
 74 | .storage {
 75 |   color: #b48ead;
 76 | }
 77 | .support.function {
 78 |   color: #96b5b4;
 79 | }
 80 | .string {
 81 |   color: #a3be8c;
 82 | }
 83 | .constant.other.symbol {
 84 |   color: #a3be8c;
 85 | }
 86 | .entity.other.inherited-class {
 87 |   color: #a3be8c;
 88 | }
 89 | .constant.numeric {
 90 |   color: #d08770;
 91 | }
 92 | .none {
 93 |   color: #d08770;
 94 | }
 95 | .none {
 96 |   color: #d08770;
 97 | }
 98 | .constant {
 99 |   color: #d08770;
100 | }
101 | .entity.name.tag {
102 |   color: #bf616a;
103 | }
104 | .entity.other.attribute-name {
105 |   color: #d08770;
106 | }
107 | .entity.other.attribute-name.id {
108 |   color: #8fa1b3;
109 | }
110 | .punctuation.definition.entity {
111 |   color: #8fa1b3;
112 | }
113 | .meta.selector {
114 |   color: #b48ead;
115 | }
116 | .none {
117 |   color: #d08770;
118 | }
119 | .markup.heading {
120 |   color: #8fa1b3;
121 | }
122 | .punctuation.definition.heading {
123 |   color: #8fa1b3;
124 | }
125 | .entity.name.section {
126 |   color: #8fa1b3;
127 | }
128 | .keyword.other.unit {
129 |   color: #d08770;
130 | }
131 | .markup.bold {
132 |   color: #ebcb8b;
133 |   font-weight: 700;
134 | }
135 | .punctuation.definition.bold {
136 |   color: #ebcb8b;
137 |   font-weight: 700;
138 | }
139 | .markup.italic {
140 |   color: #b48ead;
141 |   font-style: italic;
142 | }
143 | .punctuation.definition.italic {
144 |   color: #b48ead;
145 |   font-style: italic;
146 | }
147 | .markup.raw.inline {
148 |   color: #a3be8c;
149 | }
150 | .string.other.link {
151 |   color: #bf616a;
152 | }
153 | .meta.link {
154 |   color: #d08770;
155 | }
156 | .meta.image {
157 |   color: #d08770;
158 | }
159 | .markup.list {
160 |   color: #bf616a;
161 | }
162 | .markup.quote {
163 |   color: #d08770;
164 | }
165 | .meta.separator {
166 |   color: #c0c5ce;
167 |   background-color: #4f5b66;
168 | }
169 | .markup.inserted {
170 |   color: #a3be8c;
171 | }
172 | .markup.inserted.git_gutter {
173 |   color: #a3be8c;
174 | }
175 | .markup.deleted {
176 |   color: #bf616a;
177 | }
178 | .markup.deleted.git_gutter {
179 |   color: #bf616a;
180 | }
181 | .markup.changed {
182 |   color: #b48ead;
183 | }
184 | .markup.changed.git_gutter {
185 |   color: #b48ead;
186 | }
187 | .markup.ignored {
188 |   color: #4f5b66;
189 | }
190 | .markup.ignored.git_gutter {
191 |   color: #4f5b66;
192 | }
193 | .markup.untracked {
194 |   color: #4f5b66;
195 | }
196 | .markup.untracked.git_gutter {
197 |   color: #4f5b66;
198 | }
199 | .constant.other.color {
200 |   color: #96b5b4;
201 | }
202 | .string.regexp {
203 |   color: #96b5b4;
204 | }
205 | .constant.character.escape {
206 |   color: #96b5b4;
207 | }
208 | .punctuation.section.embedded {
209 |   color: #ab7967;
210 | }
211 | .variable.interpolation {
212 |   color: #ab7967;
213 | }
214 | .invalid.illegal {
215 |   color: #2b303b;
216 |   background-color: #bf616a;
217 | }
218 | .markup.deleted.git_gutter {
219 |   color: #f92672;
220 | }
221 | .markup.inserted.git_gutter {
222 |   color: #a6e22e;
223 | }
224 | .markup.changed.git_gutter {
225 |   color: #967efb;
226 | }
227 | .markup.ignored.git_gutter {
228 |   color: #565656;
229 | }
230 | .markup.untracked.git_gutter {
231 |   color: #565656;
232 | }
233 | .source .block {
234 |   display: inline;
235 | }
236 | 
237 | span .block {
238 | 	display: inline;
239 | }


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
  1 | defmodule KetbinWeb.PageController do
  2 |   require Logger
  3 | 
  4 |   use KetbinWeb, :controller
  5 | 
  6 |   alias Ketbin.Pastes
  7 |   alias Ketbin.Pastes.Paste
  8 |   alias Ketbin.Pastes.Utils
  9 | 
 10 |   def index(conn, _params) do
 11 |     changeset = Pastes.change_paste(%Paste{})
 12 |     render(conn, "index.html", changeset: changeset)
 13 |   end
 14 | 
 15 |   def show(%{assigns: %{show_edit: show_edit}} = conn, %{"id" => id}) do
 16 |     [head | tail] = String.split(id, ".")
 17 | 
 18 |     # fetch paste from db
 19 |     paste =
 20 |       try do
 21 |         Pastes.get_paste!(head)
 22 |       rescue
 23 |         Ecto.NoResultsError ->
 24 |           Pastes.get_paste!(id)
 25 |       end
 26 | 
 27 |     # paste is a url, redirect
 28 |     # regular paste, show content
 29 |     if paste.is_url do
 30 |       redirect(conn,
 31 |         external: paste.content |> String.replace("\r", "") |> String.replace("\n", "")
 32 |       )
 33 |     else
 34 |       render(conn, "show.html",
 35 |         paste: paste,
 36 |         show_edit: show_edit,
 37 |         extension: List.first(tail) || "",
 38 |         page_title: paste.id
 39 |       )
 40 |     end
 41 |   end
 42 | 
 43 |   def showlink(%{assigns: %{show_edit: show_edit}} = conn, %{"id" => id}) do
 44 |     [head | tail] = String.split(id, ".")
 45 |     paste = Pastes.get_paste!(head)
 46 | 
 47 |     render(conn, "shorten.html",
 48 |       paste: paste,
 49 |       show_edit: show_edit,
 50 |       extension: if(tail == [], do: "", else: tail),
 51 |       page_title: paste.id
 52 |     )
 53 |   end
 54 | 
 55 |   def raw(conn, %{"id" => id}) do
 56 |     paste = Pastes.get_paste!(id)
 57 |     text(conn, paste.content)
 58 |   end
 59 | 
 60 |   def create(%{assigns: %{current_user: current_user}} = conn, %{"paste" => paste_params}) do
 61 |     # if custom url exists, use it as id, else generate phonetic id
 62 |     id =
 63 |       case Map.get(paste_params, "custom_url", "") do
 64 |         custom_url when custom_url != "" -> custom_url
 65 |         _ -> Utils.generate_key()
 66 |       end
 67 | 
 68 |     # check if content is a url
 69 |     is_url =
 70 |       Map.get(paste_params, "content")
 71 |       |> Utils.is_url?()
 72 | 
 73 |     # put id and is_url values into changeset
 74 |     paste_params =
 75 |       Map.put(paste_params, "id", id)
 76 |       |> Map.put("is_url", is_url)
 77 |       |> Map.put("belongs_to", current_user && current_user.id)
 78 | 
 79 |     # attempt to create a paste
 80 |     case Pastes.create_paste(paste_params) do
 81 |       # all good, redirect
 82 |       {:ok, paste} ->
 83 |         unless is_url do
 84 |           conn
 85 |           # is a regular paste, take to regular route
 86 |           |> redirect(to: Routes.page_path(conn, :show, paste))
 87 |         else
 88 |           conn
 89 |           # is a url, take to route with /v/ prefix
 90 |           |> redirect(to: Routes.page_path(conn, :showlink, paste))
 91 |         end
 92 | 
 93 |       # something went wrong, bail
 94 |       {:error, %Ecto.Changeset{} = changeset} ->
 95 |         case changeset.errors[:id] do
 96 |           {"has already been taken", _} ->
 97 |             render(conn, "index.html", changeset: changeset, already_taken: true)
 98 | 
 99 |           _ ->
100 |             render(conn, "index.html", changeset: changeset)
101 |         end
102 |     end
103 |   end
104 | 
105 |   def edit(conn, %{"id" => id}) do
106 |     paste = Pastes.get_paste!(id)
107 |     changeset = Pastes.change_paste(paste)
108 |     render(conn, "edit.html", paste: paste, changeset: changeset)
109 |   end
110 | 
111 |   def update(conn, %{"id" => id, "paste" => paste_params}) do
112 |     paste = Pastes.get_paste!(id)
113 | 
114 |     # check if content is a url
115 |     is_url =
116 |       Map.get(paste_params, "content")
117 |       |> Utils.is_url?()
118 | 
119 |     paste_params = Map.put(paste_params, "is_url", is_url)
120 | 
121 |     case Pastes.update_paste(paste, paste_params) do
122 |       {:ok, paste} ->
123 |         unless is_url do
124 |           conn
125 |           |> put_flash(:info, "Paste updated successfully.")
126 |           |> redirect(to: Routes.page_path(conn, :show, paste))
127 |         else
128 |           conn
129 |           |> put_flash(:info, "Paste updated successfully.")
130 |           |> redirect(to: Routes.page_path(conn, :showlink, paste))
131 |         end
132 | 
133 |       {:error, %Ecto.Changeset{} = changeset} ->
134 |         render(conn, "edit.html", paste: paste, changeset: changeset)
135 |     end
136 |   end
137 | 
138 |   def pastes(%{assigns: %{current_user: current_user}} = conn, _params) do
139 |     pastes = Pastes.list_pastes_by_user(current_user.id)
140 |     render(conn, "pastes.html", pastes: pastes)
141 |   end
142 | end
143 | 


--------------------------------------------------------------------------------
/lib/ketbin/accounts/user_token.ex:
--------------------------------------------------------------------------------
  1 | defmodule Ketbin.Accounts.UserToken do
  2 |   use Ecto.Schema
  3 |   import Ecto.Query
  4 | 
  5 |   @hash_algorithm :sha256
  6 |   @rand_size 32
  7 | 
  8 |   # It is very important to keep the reset password token expiry short,
  9 |   # since someone with access to the email may take over the account.
 10 |   @reset_password_validity_in_days 1
 11 |   @confirm_validity_in_days 7
 12 |   @change_email_validity_in_days 7
 13 |   @session_validity_in_days 60
 14 | 
 15 |   schema "users_tokens" do
 16 |     field :token, :binary
 17 |     field :context, :string
 18 |     field :sent_to, :string
 19 |     belongs_to :user, Ketbin.Accounts.User
 20 | 
 21 |     timestamps(updated_at: false)
 22 |   end
 23 | 
 24 |   @doc """
 25 |   Generates a token that will be stored in a signed place,
 26 |   such as session or cookie. As they are signed, those
 27 |   tokens do not need to be hashed.
 28 |   """
 29 |   def build_session_token(user) do
 30 |     token = :crypto.strong_rand_bytes(@rand_size)
 31 |     {token, %Ketbin.Accounts.UserToken{token: token, context: "session", user_id: user.id}}
 32 |   end
 33 | 
 34 |   @doc """
 35 |   Checks if the token is valid and returns its underlying lookup query.
 36 | 
 37 |   The query returns the user found by the token.
 38 |   """
 39 |   def verify_session_token_query(token) do
 40 |     query =
 41 |       from token in token_and_context_query(token, "session"),
 42 |         join: user in assoc(token, :user),
 43 |         where: token.inserted_at > ago(@session_validity_in_days, "day"),
 44 |         select: user
 45 | 
 46 |     {:ok, query}
 47 |   end
 48 | 
 49 |   @doc """
 50 |   Builds a token with a hashed counter part.
 51 | 
 52 |   The non-hashed token is sent to the user email while the
 53 |   hashed part is stored in the database, to avoid reconstruction.
 54 |   The token is valid for a week as long as users don't change
 55 |   their email.
 56 |   """
 57 |   def build_email_token(user, context) do
 58 |     build_hashed_token(user, context, user.email)
 59 |   end
 60 | 
 61 |   defp build_hashed_token(user, context, sent_to) do
 62 |     token = :crypto.strong_rand_bytes(@rand_size)
 63 |     hashed_token = :crypto.hash(@hash_algorithm, token)
 64 | 
 65 |     {Base.url_encode64(token, padding: false),
 66 |      %Ketbin.Accounts.UserToken{
 67 |        token: hashed_token,
 68 |        context: context,
 69 |        sent_to: sent_to,
 70 |        user_id: user.id
 71 |      }}
 72 |   end
 73 | 
 74 |   @doc """
 75 |   Checks if the token is valid and returns its underlying lookup query.
 76 | 
 77 |   The query returns the user found by the token.
 78 |   """
 79 |   def verify_email_token_query(token, context) do
 80 |     case Base.url_decode64(token, padding: false) do
 81 |       {:ok, decoded_token} ->
 82 |         hashed_token = :crypto.hash(@hash_algorithm, decoded_token)
 83 |         days = days_for_context(context)
 84 | 
 85 |         query =
 86 |           from token in token_and_context_query(hashed_token, context),
 87 |             join: user in assoc(token, :user),
 88 |             where: token.inserted_at > ago(^days, "day") and token.sent_to == user.email,
 89 |             select: user
 90 | 
 91 |         {:ok, query}
 92 | 
 93 |       :error ->
 94 |         :error
 95 |     end
 96 |   end
 97 | 
 98 |   defp days_for_context("confirm"), do: @confirm_validity_in_days
 99 |   defp days_for_context("reset_password"), do: @reset_password_validity_in_days
100 | 
101 |   @doc """
102 |   Checks if the token is valid and returns its underlying lookup query.
103 | 
104 |   The query returns the user token record.
105 |   """
106 |   def verify_change_email_token_query(token, context) do
107 |     case Base.url_decode64(token, padding: false) do
108 |       {:ok, decoded_token} ->
109 |         hashed_token = :crypto.hash(@hash_algorithm, decoded_token)
110 | 
111 |         query =
112 |           from token in token_and_context_query(hashed_token, context),
113 |             where: token.inserted_at > ago(@change_email_validity_in_days, "day")
114 | 
115 |         {:ok, query}
116 | 
117 |       :error ->
118 |         :error
119 |     end
120 |   end
121 | 
122 |   @doc """
123 |   Returns the given token with the given context.
124 |   """
125 |   def token_and_context_query(token, context) do
126 |     from Ketbin.Accounts.UserToken, where: [token: ^token, context: ^context]
127 |   end
128 | 
129 |   @doc """
130 |   Gets all tokens for the given user for the given contexts.
131 |   """
132 |   def user_and_contexts_query(user, :all) do
133 |     from t in Ketbin.Accounts.UserToken, where: t.user_id == ^user.id
134 |   end
135 | 
136 |   def user_and_contexts_query(user, [_ | _] = contexts) do
137 |     from t in Ketbin.Accounts.UserToken, where: t.user_id == ^user.id and t.context in ^contexts
138 |   end
139 | end
140 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/templates/layout/app.html.heex:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 |   <head>
  4 |     <meta charset="utf-8"/>
  5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  7 |     <%= if Map.has_key?(assigns, :page_title) do %>
  8 |       <title>Katbin - <%= @page_title %></title>
  9 |     <% else %>
 10 |       <title>Katbin</title>
 11 |     <% end %>
 12 |     <title itemprop="name">Katbin</title>
 13 | 
 14 |     <meta property="og:type" content="object">
 15 |     <meta property="og:title" content="Katbin">
 16 |     <meta property="og:image" content="/favicon.ico">
 17 | 
 18 |     <meta name="twitter:title" content="Katbin">
 19 |     <meta itemprop="name" content="Katbin">
 20 |     <meta name="application-name" content="Katbin">
 21 |     <meta property="og:site_name" content="Katbin">
 22 |     <meta name="theme-color" content="#1a1a1a">
 23 |     <meta property="og:locale" content="en">
 24 |     <meta name="language" content="en">
 25 |     <meta name="twitter:card" content="summary">
 26 |     <meta name="twitter:site" content="@Spherical_Kat">
 27 |     <meta name="twitter:image" content="/favicon.ico">
 28 | 
 29 |     <meta name="robots" content="index,follow">
 30 |     <meta name="googlebot" content="index,follow">
 31 |     <meta name="keywords" content="paste,pastebin,url,urlshortener,url-shortener,code,programming,bin,cat,kat,paste,share,save,login">
 32 |     <meta name="coverage" content="Worldwide">
 33 |     <meta name="distribution" content="Global">
 34 |     <meta name="HandheldFriendly" content="True">
 35 |     <meta name="HandheldFriendly" content="True">
 36 |     <meta name="apple-mobile-web-app-title" content="Katbin">
 37 |     <meta name="apple-mobile-web-app-capable" content="yes">
 38 |     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
 39 |     <meta name="apple-touch-fullscreen" content="yes">
 40 | 
 41 |     <%= if assigns[:paste] do %>
 42 |         <meta name="description" content={@paste.content}>
 43 |         <meta itemprop="description" content={@paste.content}>
 44 |         <meta property="og:description" content={@paste.content}>
 45 |         <meta name="twitter:description" content={@paste.content}>
 46 | 
 47 |         <meta name="url" content={"https://katb.in/#{@paste.id}"}>
 48 |         <meta name="twitter:url" content={"https://katb.in/#{@paste.id}"}>
 49 |         <meta property="og:url" content={"https://katb.in/#{@paste.id}"}>
 50 |     <% else %>
 51 |         <meta name="description" content="Paste, save, share! A pastebin and URL shortener for all your needs.">
 52 |         <meta property="og:description" content="Paste, save, share! A pastebin and URL shortener for all your needs.">
 53 |         <meta itemprop="og:description" content="Paste, save, share! A pastebin and URL shortener for all your needs.">
 54 |         <meta name="twitter:description" content="Paste, save, share! A pastebin and URL shortener for all your needs.">
 55 | 
 56 |         <meta name="url" content="https://katb.in">
 57 |         <meta name="twitter:url" content="https://katb.in">
 58 |         <meta property="og:url" content="https://katb.in">
 59 |     <% end %>
 60 | 
 61 |     <link rel="stylesheet" href={ Routes.static_path(@conn, "/assets/app.css") }/>
 62 |     <script defer type="text/javascript" src={ Routes.static_path(@conn, "/assets/app.js") }></script>
 63 |   </head>
 64 |   <body class="flex flex-col ">
 65 |     <header class="flex w-full justify-between items-center py-3 px-6">
 66 |      <a href={ Routes.page_path(@conn, :index) }>
 67 |         <span class="font-semibold text-xl tracking-tight">
 68 |           <span class="text-amber text-xl">&lt;Kat</span>bin/&gt;
 69 |         </span>
 70 |       </a>
 71 | 
 72 |       <nav role="navigation">
 73 |         <ul>
 74 |           <%= if function_exported?(Routes, :live_dashboard_path, 2) do %>
 75 |             <li>
 76 |             <%# <%= link "LiveDashboard", to: Routes.live_dashboard_path(@conn, :home) %>
 77 |             </li>
 78 |           <% end %>
 79 |         </ul>
 80 |         <%= render "_user_menu.html", assigns %>
 81 |       </nav>
 82 | 
 83 |     </header>
 84 |     <main class="flex flex-col w-full h-full max-h-full overflow-hidden bg-light-grey" role="main">
 85 |       <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
 86 |       <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
 87 |       <%= @inner_content %>
 88 |     </main>
 89 |     <footer class="font-bold">
 90 |     <div class="flex px-4 py-1 text-xs sm:text-base justify-between text-amber" style="background: #1a1a1a; font-family: JetbrainsMono">
 91 |       <a href="https://kat.bio">
 92 |         © <%= DateTime.utc_now().year %> SphericalKat
 93 |       </a>
 94 |       <a href="https://github.com/sphericalkat/katbin">
 95 |         Fork me!
 96 |       </a>
 97 |       </div>
 98 |     </footer>
 99 |   </body>
100 | </html>
101 | 


--------------------------------------------------------------------------------
/lib/ketbin/accounts/user.ex:
--------------------------------------------------------------------------------
  1 | defmodule Ketbin.Accounts.User do
  2 |   use Ecto.Schema
  3 |   import Ecto.Changeset
  4 | 
  5 |   @derive {Inspect, except: [:password]}
  6 |   schema "users" do
  7 |     field :email, :string
  8 |     field :password, :string, virtual: true
  9 |     field :hashed_password, :string
 10 |     field :confirmed_at, :naive_datetime
 11 | 
 12 |     timestamps()
 13 |   end
 14 | 
 15 |   @doc """
 16 |   A user changeset for registration.
 17 | 
 18 |   It is important to validate the length of both email and password.
 19 |   Otherwise databases may truncate the email without warnings, which
 20 |   could lead to unpredictable or insecure behaviour. Long passwords may
 21 |   also be very expensive to hash for certain algorithms.
 22 | 
 23 |   ## Options
 24 | 
 25 |     * `:hash_password` - Hashes the password so it can be stored securely
 26 |       in the database and ensures the password field is cleared to prevent
 27 |       leaks in the logs. If password hashing is not needed and clearing the
 28 |       password field is not desired (like when using this changeset for
 29 |       validations on a LiveView form), this option can be set to `false`.
 30 |       Defaults to `true`.
 31 |   """
 32 |   def registration_changeset(user, attrs, opts \\ []) do
 33 |     user
 34 |     |> cast(attrs, [:email, :password])
 35 |     |> validate_email()
 36 |     |> validate_password(opts)
 37 |   end
 38 | 
 39 |   defp validate_email(changeset) do
 40 |     changeset
 41 |     |> validate_required([:email])
 42 |     |> validate_format(:email, ~r/^[^\s]+@[^\s]+$/, message: "must have the @ sign and no spaces")
 43 |     |> validate_length(:email, max: 160)
 44 |     |> unsafe_validate_unique(:email, Ketbin.Repo)
 45 |     |> unique_constraint(:email)
 46 |   end
 47 | 
 48 |   defp validate_password(changeset, opts) do
 49 |     changeset
 50 |     |> validate_required([:password])
 51 |     |> validate_length(:password, min: 8, max: 80)
 52 |     # |> validate_format(:password, ~r/[a-z]/, message: "at least one lower case character")
 53 |     # |> validate_format(:password, ~r/[A-Z]/, message: "at least one upper case character")
 54 |     # |> validate_format(:password, ~r/[!?@#$%^&*_0-9]/, message: "at least one digit or punctuation character")
 55 |     |> maybe_hash_password(opts)
 56 |   end
 57 | 
 58 |   defp maybe_hash_password(changeset, opts) do
 59 |     hash_password? = Keyword.get(opts, :hash_password, true)
 60 |     password = get_change(changeset, :password)
 61 | 
 62 |     if hash_password? && password && changeset.valid? do
 63 |       changeset
 64 |       |> put_change(:hashed_password, Bcrypt.hash_pwd_salt(password))
 65 |       |> delete_change(:password)
 66 |     else
 67 |       changeset
 68 |     end
 69 |   end
 70 | 
 71 |   @doc """
 72 |   A user changeset for changing the email.
 73 | 
 74 |   It requires the email to change otherwise an error is added.
 75 |   """
 76 |   def email_changeset(user, attrs) do
 77 |     user
 78 |     |> cast(attrs, [:email])
 79 |     |> validate_email()
 80 |     |> case do
 81 |       %{changes: %{email: _}} = changeset -> changeset
 82 |       %{} = changeset -> add_error(changeset, :email, "did not change")
 83 |     end
 84 |   end
 85 | 
 86 |   @doc """
 87 |   A user changeset for changing the password.
 88 | 
 89 |   ## Options
 90 | 
 91 |     * `:hash_password` - Hashes the password so it can be stored securely
 92 |       in the database and ensures the password field is cleared to prevent
 93 |       leaks in the logs. If password hashing is not needed and clearing the
 94 |       password field is not desired (like when using this changeset for
 95 |       validations on a LiveView form), this option can be set to `false`.
 96 |       Defaults to `true`.
 97 |   """
 98 |   def password_changeset(user, attrs, opts \\ []) do
 99 |     user
100 |     |> cast(attrs, [:password])
101 |     |> validate_confirmation(:password, message: "does not match password")
102 |     |> validate_password(opts)
103 |   end
104 | 
105 |   @doc """
106 |   Confirms the account by setting `confirmed_at`.
107 |   """
108 |   def confirm_changeset(user) do
109 |     now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
110 |     change(user, confirmed_at: now)
111 |   end
112 | 
113 |   @doc """
114 |   Verifies the password.
115 | 
116 |   If there is no user or the user doesn't have a password, we call
117 |   `Bcrypt.no_user_verify/0` to avoid timing attacks.
118 |   """
119 |   def valid_password?(%Ketbin.Accounts.User{hashed_password: hashed_password}, password)
120 |       when is_binary(hashed_password) and byte_size(password) > 0 do
121 |     Bcrypt.verify_pass(password, hashed_password)
122 |   end
123 | 
124 |   def valid_password?(_, _) do
125 |     Bcrypt.no_user_verify()
126 |     false
127 |   end
128 | 
129 |   @doc """
130 |   Validates the current password otherwise adds an error to the changeset.
131 |   """
132 |   def validate_current_password(changeset, password) do
133 |     if valid_password?(changeset.data, password) do
134 |       changeset
135 |     else
136 |       add_error(changeset, :current_password, "is not valid")
137 |     end
138 |   end
139 | end
140 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/user_settings_controller_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule KetbinWeb.UserSettingsControllerTest do
  2 |   use KetbinWeb.ConnCase, async: true
  3 | 
  4 |   alias Ketbin.Accounts
  5 |   import Ketbin.AccountsFixtures
  6 | 
  7 |   setup :register_and_log_in_user
  8 | 
  9 |   describe "GET /users/settings" do
 10 |     test "renders settings page", %{conn: conn} do
 11 |       conn = get(conn, Routes.user_settings_path(conn, :edit))
 12 |       response = html_response(conn, 200)
 13 |       assert response =~ "<h1>Settings</h1>"
 14 |     end
 15 | 
 16 |     test "redirects if user is not logged in" do
 17 |       conn = build_conn()
 18 |       conn = get(conn, Routes.user_settings_path(conn, :edit))
 19 |       assert redirected_to(conn) == Routes.user_session_path(conn, :new)
 20 |     end
 21 |   end
 22 | 
 23 |   describe "PUT /users/settings (change password form)" do
 24 |     test "updates the user password and resets tokens", %{conn: conn, user: user} do
 25 |       new_password_conn =
 26 |         put(conn, Routes.user_settings_path(conn, :update), %{
 27 |           "action" => "update_password",
 28 |           "current_password" => valid_user_password(),
 29 |           "user" => %{
 30 |             "password" => "new valid password",
 31 |             "password_confirmation" => "new valid password"
 32 |           }
 33 |         })
 34 | 
 35 |       assert redirected_to(new_password_conn) == Routes.user_settings_path(conn, :edit)
 36 |       assert get_session(new_password_conn, :user_token) != get_session(conn, :user_token)
 37 |       assert get_flash(new_password_conn, :info) =~ "Password updated successfully"
 38 |       assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
 39 |     end
 40 | 
 41 |     test "does not update password on invalid data", %{conn: conn} do
 42 |       old_password_conn =
 43 |         put(conn, Routes.user_settings_path(conn, :update), %{
 44 |           "action" => "update_password",
 45 |           "current_password" => "invalid",
 46 |           "user" => %{
 47 |             "password" => "too short",
 48 |             "password_confirmation" => "does not match"
 49 |           }
 50 |         })
 51 | 
 52 |       response = html_response(old_password_conn, 200)
 53 |       assert response =~ "<h1>Settings</h1>"
 54 |       assert response =~ "should be at least 12 character(s)"
 55 |       assert response =~ "does not match password"
 56 |       assert response =~ "is not valid"
 57 | 
 58 |       assert get_session(old_password_conn, :user_token) == get_session(conn, :user_token)
 59 |     end
 60 |   end
 61 | 
 62 |   describe "PUT /users/settings (change email form)" do
 63 |     @tag :capture_log
 64 |     test "updates the user email", %{conn: conn, user: user} do
 65 |       conn =
 66 |         put(conn, Routes.user_settings_path(conn, :update), %{
 67 |           "action" => "update_email",
 68 |           "current_password" => valid_user_password(),
 69 |           "user" => %{"email" => unique_user_email()}
 70 |         })
 71 | 
 72 |       assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
 73 |       assert get_flash(conn, :info) =~ "A link to confirm your email"
 74 |       assert Accounts.get_user_by_email(user.email)
 75 |     end
 76 | 
 77 |     test "does not update email on invalid data", %{conn: conn} do
 78 |       conn =
 79 |         put(conn, Routes.user_settings_path(conn, :update), %{
 80 |           "action" => "update_email",
 81 |           "current_password" => "invalid",
 82 |           "user" => %{"email" => "with spaces"}
 83 |         })
 84 | 
 85 |       response = html_response(conn, 200)
 86 |       assert response =~ "<h1>Settings</h1>"
 87 |       assert response =~ "must have the @ sign and no spaces"
 88 |       assert response =~ "is not valid"
 89 |     end
 90 |   end
 91 | 
 92 |   describe "GET /users/settings/confirm_email/:token" do
 93 |     setup %{user: user} do
 94 |       email = unique_user_email()
 95 | 
 96 |       token =
 97 |         extract_user_token(fn url ->
 98 |           Accounts.deliver_update_email_instructions(%{user | email: email}, user.email, url)
 99 |         end)
100 | 
101 |       %{token: token, email: email}
102 |     end
103 | 
104 |     test "updates the user email once", %{conn: conn, user: user, token: token, email: email} do
105 |       conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
106 |       assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
107 |       assert get_flash(conn, :info) =~ "Email changed successfully"
108 |       refute Accounts.get_user_by_email(user.email)
109 |       assert Accounts.get_user_by_email(email)
110 | 
111 |       conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
112 |       assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
113 |       assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired"
114 |     end
115 | 
116 |     test "does not update email with invalid token", %{conn: conn, user: user} do
117 |       conn = get(conn, Routes.user_settings_path(conn, :confirm_email, "oops"))
118 |       assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
119 |       assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired"
120 |       assert Accounts.get_user_by_email(user.email)
121 |     end
122 | 
123 |     test "redirects if user is not logged in", %{token: token} do
124 |       conn = build_conn()
125 |       conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
126 |       assert redirected_to(conn) == Routes.user_session_path(conn, :new)
127 |     end
128 |   end
129 | end
130 | 


--------------------------------------------------------------------------------
/lib/ketbin_web/controllers/user_auth.ex:
--------------------------------------------------------------------------------
  1 | defmodule KetbinWeb.UserAuth do
  2 |   import Plug.Conn
  3 |   import Phoenix.Controller
  4 | 
  5 |   alias Ketbin.Accounts
  6 |   alias Ketbin.Pastes
  7 |   alias KetbinWeb.Router.Helpers, as: Routes
  8 | 
  9 |   # Make the remember me cookie valid for 60 days.
 10 |   # If you want bump or reduce this value, also change
 11 |   # the token expiry itself in UserToken.
 12 |   @max_age 60 * 60 * 24 * 60
 13 |   @remember_me_cookie "_ketbin_web_user_remember_me"
 14 |   @remember_me_options [sign: true, max_age: @max_age, same_site: "Lax"]
 15 | 
 16 |   @doc """
 17 |   Logs the user in.
 18 | 
 19 |   It renews the session ID and clears the whole session
 20 |   to avoid fixation attacks. See the renew_session
 21 |   function to customize this behaviour.
 22 | 
 23 |   It also sets a `:live_socket_id` key in the session,
 24 |   so LiveView sessions are identified and automatically
 25 |   disconnected on log out. The line can be safely removed
 26 |   if you are not using LiveView.
 27 |   """
 28 |   def log_in_user(conn, user, params \\ %{}) do
 29 |     token = Accounts.generate_user_session_token(user)
 30 |     user_return_to = get_session(conn, :user_return_to)
 31 | 
 32 |     conn
 33 |     |> renew_session()
 34 |     |> put_session(:user_token, token)
 35 |     |> put_session(:live_socket_id, "users_sessions:#{Base.url_encode64(token)}")
 36 |     |> maybe_write_remember_me_cookie(token, params)
 37 |     |> put_flash(:info, "Logged in successfully!")
 38 |     |> redirect(to: user_return_to || signed_in_path(conn))
 39 |   end
 40 | 
 41 |   defp maybe_write_remember_me_cookie(conn, token, %{"remember_me" => "true"}) do
 42 |     put_resp_cookie(conn, @remember_me_cookie, token, @remember_me_options)
 43 |   end
 44 | 
 45 |   defp maybe_write_remember_me_cookie(conn, _token, _params) do
 46 |     conn
 47 |   end
 48 | 
 49 |   # This function renews the session ID and erases the whole
 50 |   # session to avoid fixation attacks. If there is any data
 51 |   # in the session you may want to preserve after log in/log out,
 52 |   # you must explicitly fetch the session data before clearing
 53 |   # and then immediately set it after clearing, for example:
 54 |   #
 55 |   #     defp renew_session(conn) do
 56 |   #       preferred_locale = get_session(conn, :preferred_locale)
 57 |   #
 58 |   #       conn
 59 |   #       |> configure_session(renew: true)
 60 |   #       |> clear_session()
 61 |   #       |> put_session(:preferred_locale, preferred_locale)
 62 |   #     end
 63 |   #
 64 |   defp renew_session(conn) do
 65 |     conn
 66 |     |> configure_session(renew: true)
 67 |     |> clear_session()
 68 |   end
 69 | 
 70 |   @doc """
 71 |   Logs the user out.
 72 | 
 73 |   It clears all session data for safety. See renew_session.
 74 |   """
 75 |   def log_out_user(conn) do
 76 |     user_token = get_session(conn, :user_token)
 77 |     user_token && Accounts.delete_session_token(user_token)
 78 | 
 79 |     if live_socket_id = get_session(conn, :live_socket_id) do
 80 |       KetbinWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})
 81 |     end
 82 | 
 83 |     conn
 84 |     |> renew_session()
 85 |     |> delete_resp_cookie(@remember_me_cookie)
 86 |     |> redirect(to: "/")
 87 |   end
 88 | 
 89 |   @doc """
 90 |   Authenticates the user by looking into the session
 91 |   and remember me token.
 92 |   """
 93 |   def fetch_current_user(conn, _opts) do
 94 |     {user_token, conn} = ensure_user_token(conn)
 95 |     user = user_token && Accounts.get_user_by_session_token(user_token)
 96 |     assign(conn, :current_user, user)
 97 |   end
 98 | 
 99 |   def owns_paste(%{params: %{"id" => id}, assigns: %{current_user: user}} = conn, _params) do
100 |     [head | _tail] = String.split(id, ".")
101 | 
102 |     paste =
103 |       try do
104 |         Pastes.get_paste!(head)
105 |       rescue
106 |         Ecto.NoResultsError ->
107 |           Pastes.get_paste!(id)
108 |       end
109 | 
110 |     assign(conn, :show_edit, (user && user.id == paste.belongs_to) || false)
111 |   end
112 | 
113 |   def ensure_owns_paste(%{params: %{"id" => id}, assigns: %{current_user: user}} = conn, _params) do
114 |     [head | _tail] = String.split(id, ".")
115 |     paste = Pastes.get_paste!(head)
116 |     allow_edit = (user && user.id == paste.belongs_to) || false
117 | 
118 |     unless allow_edit do
119 |       conn
120 |       |> put_flash(:error, "You don't own this paste!")
121 |       |> redirect(to: Routes.page_path(conn, :show, id))
122 |     else
123 |       conn
124 |     end
125 |   end
126 | 
127 |   defp ensure_user_token(conn) do
128 |     if user_token = get_session(conn, :user_token) do
129 |       {user_token, conn}
130 |     else
131 |       conn = fetch_cookies(conn, signed: [@remember_me_cookie])
132 | 
133 |       if user_token = conn.cookies[@remember_me_cookie] do
134 |         {user_token, put_session(conn, :user_token, user_token)}
135 |       else
136 |         {nil, conn}
137 |       end
138 |     end
139 |   end
140 | 
141 |   @doc """
142 |   Used for routes that require the user to not be authenticated.
143 |   """
144 |   def redirect_if_user_is_authenticated(conn, _opts) do
145 |     if conn.assigns[:current_user] do
146 |       conn
147 |       |> redirect(to: signed_in_path(conn))
148 |       |> halt()
149 |     else
150 |       conn
151 |     end
152 |   end
153 | 
154 |   @doc """
155 |   Used for routes that require the user to be authenticated.
156 | 
157 |   If you want to enforce the user email is confirmed before
158 |   they use the application at all, here would be a good place.
159 |   """
160 |   def require_authenticated_user(conn, _opts) do
161 |     if conn.assigns[:current_user] do
162 |       conn
163 |     else
164 |       conn
165 |       |> put_flash(:error, "You must log in to access this page.")
166 |       |> maybe_store_return_to()
167 |       |> redirect(to: Routes.user_session_path(conn, :new))
168 |       |> halt()
169 |     end
170 |   end
171 | 
172 |   defp maybe_store_return_to(%{method: "GET"} = conn) do
173 |     put_session(conn, :user_return_to, current_path(conn))
174 |   end
175 | 
176 |   defp maybe_store_return_to(conn), do: conn
177 | 
178 |   defp signed_in_path(_conn), do: "/"
179 | end
180 | 


--------------------------------------------------------------------------------
/priv/repo/structure.sql:
--------------------------------------------------------------------------------
  1 | --
  2 | -- PostgreSQL database dump
  3 | --
  4 | 
  5 | -- Dumped from database version 13.4 (Debian 13.4-1.pgdg100+1)
  6 | -- Dumped by pg_dump version 13.4
  7 | 
  8 | SET statement_timeout = 0;
  9 | SET lock_timeout = 0;
 10 | SET idle_in_transaction_session_timeout = 0;
 11 | SET client_encoding = 'UTF8';
 12 | SET standard_conforming_strings = on;
 13 | SELECT pg_catalog.set_config('search_path', '', false);
 14 | SET check_function_bodies = false;
 15 | SET xmloption = content;
 16 | SET client_min_messages = warning;
 17 | SET row_security = off;
 18 | 
 19 | --
 20 | -- Name: citext; Type: EXTENSION; Schema: -; Owner: -
 21 | --
 22 | 
 23 | CREATE EXTENSION IF NOT EXISTS citext WITH SCHEMA public;
 24 | 
 25 | 
 26 | --
 27 | -- Name: EXTENSION citext; Type: COMMENT; Schema: -; Owner: -
 28 | --
 29 | 
 30 | COMMENT ON EXTENSION citext IS 'data type for case-insensitive character strings';
 31 | 
 32 | 
 33 | SET default_tablespace = '';
 34 | 
 35 | SET default_table_access_method = heap;
 36 | 
 37 | --
 38 | -- Name: pastes; Type: TABLE; Schema: public; Owner: -
 39 | --
 40 | 
 41 | CREATE TABLE public.pastes (
 42 |     id character varying(255) NOT NULL,
 43 |     is_url boolean DEFAULT false NOT NULL,
 44 |     content text NOT NULL,
 45 |     belongs_to bigint
 46 | );
 47 | 
 48 | 
 49 | --
 50 | -- Name: schema_migrations; Type: TABLE; Schema: public; Owner: -
 51 | --
 52 | 
 53 | CREATE TABLE public.schema_migrations (
 54 |     version bigint NOT NULL,
 55 |     inserted_at timestamp(0) without time zone
 56 | );
 57 | 
 58 | 
 59 | --
 60 | -- Name: users; Type: TABLE; Schema: public; Owner: -
 61 | --
 62 | 
 63 | CREATE TABLE public.users (
 64 |     id bigint NOT NULL,
 65 |     email public.citext NOT NULL,
 66 |     hashed_password character varying(255) NOT NULL,
 67 |     confirmed_at timestamp(0) without time zone,
 68 |     inserted_at timestamp(0) without time zone NOT NULL,
 69 |     updated_at timestamp(0) without time zone NOT NULL
 70 | );
 71 | 
 72 | 
 73 | --
 74 | -- Name: users_id_seq; Type: SEQUENCE; Schema: public; Owner: -
 75 | --
 76 | 
 77 | CREATE SEQUENCE public.users_id_seq
 78 |     START WITH 1
 79 |     INCREMENT BY 1
 80 |     NO MINVALUE
 81 |     NO MAXVALUE
 82 |     CACHE 1;
 83 | 
 84 | 
 85 | --
 86 | -- Name: users_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
 87 | --
 88 | 
 89 | ALTER SEQUENCE public.users_id_seq OWNED BY public.users.id;
 90 | 
 91 | 
 92 | --
 93 | -- Name: users_tokens; Type: TABLE; Schema: public; Owner: -
 94 | --
 95 | 
 96 | CREATE TABLE public.users_tokens (
 97 |     id bigint NOT NULL,
 98 |     user_id bigint NOT NULL,
 99 |     token bytea NOT NULL,
100 |     context character varying(255) NOT NULL,
101 |     sent_to character varying(255),
102 |     inserted_at timestamp(0) without time zone NOT NULL
103 | );
104 | 
105 | 
106 | --
107 | -- Name: users_tokens_id_seq; Type: SEQUENCE; Schema: public; Owner: -
108 | --
109 | 
110 | CREATE SEQUENCE public.users_tokens_id_seq
111 |     START WITH 1
112 |     INCREMENT BY 1
113 |     NO MINVALUE
114 |     NO MAXVALUE
115 |     CACHE 1;
116 | 
117 | 
118 | --
119 | -- Name: users_tokens_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
120 | --
121 | 
122 | ALTER SEQUENCE public.users_tokens_id_seq OWNED BY public.users_tokens.id;
123 | 
124 | 
125 | --
126 | -- Name: users id; Type: DEFAULT; Schema: public; Owner: -
127 | --
128 | 
129 | ALTER TABLE ONLY public.users ALTER COLUMN id SET DEFAULT nextval('public.users_id_seq'::regclass);
130 | 
131 | 
132 | --
133 | -- Name: users_tokens id; Type: DEFAULT; Schema: public; Owner: -
134 | --
135 | 
136 | ALTER TABLE ONLY public.users_tokens ALTER COLUMN id SET DEFAULT nextval('public.users_tokens_id_seq'::regclass);
137 | 
138 | 
139 | --
140 | -- Name: pastes pastes_pkey; Type: CONSTRAINT; Schema: public; Owner: -
141 | --
142 | 
143 | ALTER TABLE ONLY public.pastes
144 |     ADD CONSTRAINT pastes_pkey PRIMARY KEY (id);
145 | 
146 | 
147 | --
148 | -- Name: schema_migrations schema_migrations_pkey; Type: CONSTRAINT; Schema: public; Owner: -
149 | --
150 | 
151 | ALTER TABLE ONLY public.schema_migrations
152 |     ADD CONSTRAINT schema_migrations_pkey PRIMARY KEY (version);
153 | 
154 | 
155 | --
156 | -- Name: users users_pkey; Type: CONSTRAINT; Schema: public; Owner: -
157 | --
158 | 
159 | ALTER TABLE ONLY public.users
160 |     ADD CONSTRAINT users_pkey PRIMARY KEY (id);
161 | 
162 | 
163 | --
164 | -- Name: users_tokens users_tokens_pkey; Type: CONSTRAINT; Schema: public; Owner: -
165 | --
166 | 
167 | ALTER TABLE ONLY public.users_tokens
168 |     ADD CONSTRAINT users_tokens_pkey PRIMARY KEY (id);
169 | 
170 | 
171 | --
172 | -- Name: pastes_belongs_to_index; Type: INDEX; Schema: public; Owner: -
173 | --
174 | 
175 | CREATE INDEX pastes_belongs_to_index ON public.pastes USING btree (belongs_to);
176 | 
177 | 
178 | --
179 | -- Name: users_email_index; Type: INDEX; Schema: public; Owner: -
180 | --
181 | 
182 | CREATE UNIQUE INDEX users_email_index ON public.users USING btree (email);
183 | 
184 | 
185 | --
186 | -- Name: users_tokens_context_token_index; Type: INDEX; Schema: public; Owner: -
187 | --
188 | 
189 | CREATE UNIQUE INDEX users_tokens_context_token_index ON public.users_tokens USING btree (context, token);
190 | 
191 | 
192 | --
193 | -- Name: users_tokens_user_id_index; Type: INDEX; Schema: public; Owner: -
194 | --
195 | 
196 | CREATE INDEX users_tokens_user_id_index ON public.users_tokens USING btree (user_id);
197 | 
198 | 
199 | --
200 | -- Name: pastes pastes_belongs_to_fkey; Type: FK CONSTRAINT; Schema: public; Owner: -
201 | --
202 | 
203 | ALTER TABLE ONLY public.pastes
204 |     ADD CONSTRAINT pastes_belongs_to_fkey FOREIGN KEY (belongs_to) REFERENCES public.users(id) ON DELETE CASCADE;
205 | 
206 | 
207 | --
208 | -- Name: users_tokens users_tokens_user_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: -
209 | --
210 | 
211 | ALTER TABLE ONLY public.users_tokens
212 |     ADD CONSTRAINT users_tokens_user_id_fkey FOREIGN KEY (user_id) REFERENCES public.users(id) ON DELETE CASCADE;
213 | 
214 | 
215 | --
216 | -- PostgreSQL database dump complete
217 | --
218 | 
219 | INSERT INTO public."schema_migrations" (version) VALUES (20210811065554);
220 | INSERT INTO public."schema_migrations" (version) VALUES (20210811213141);
221 | 


--------------------------------------------------------------------------------
/test/ketbin_web/controllers/user_auth_test.exs:
--------------------------------------------------------------------------------
  1 | defmodule KetbinWeb.UserAuthTest do
  2 |   use KetbinWeb.ConnCase, async: true
  3 | 
  4 |   alias Ketbin.Accounts
  5 |   alias KetbinWeb.UserAuth
  6 |   import Ketbin.AccountsFixtures
  7 | 
  8 |   @remember_me_cookie "_ketbin_web_user_remember_me"
  9 | 
 10 |   setup %{conn: conn} do
 11 |     conn =
 12 |       conn
 13 |       |> Map.replace!(:secret_key_base, KetbinWeb.Endpoint.config(:secret_key_base))
 14 |       |> init_test_session(%{})
 15 | 
 16 |     %{user: user_fixture(), conn: conn}
 17 |   end
 18 | 
 19 |   describe "log_in_user/3" do
 20 |     test "stores the user token in the session", %{conn: conn, user: user} do
 21 |       conn = UserAuth.log_in_user(conn, user)
 22 |       assert token = get_session(conn, :user_token)
 23 |       assert get_session(conn, :live_socket_id) == "users_sessions:#{Base.url_encode64(token)}"
 24 |       assert redirected_to(conn) == "/"
 25 |       assert Accounts.get_user_by_session_token(token)
 26 |     end
 27 | 
 28 |     test "clears everything previously stored in the session", %{conn: conn, user: user} do
 29 |       conn = conn |> put_session(:to_be_removed, "value") |> UserAuth.log_in_user(user)
 30 |       refute get_session(conn, :to_be_removed)
 31 |     end
 32 | 
 33 |     test "redirects to the configured path", %{conn: conn, user: user} do
 34 |       conn = conn |> put_session(:user_return_to, "/hello") |> UserAuth.log_in_user(user)
 35 |       assert redirected_to(conn) == "/hello"
 36 |     end
 37 | 
 38 |     test "writes a cookie if remember_me is configured", %{conn: conn, user: user} do
 39 |       conn = conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
 40 |       assert get_session(conn, :user_token) == conn.cookies[@remember_me_cookie]
 41 | 
 42 |       assert %{value: signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie]
 43 |       assert signed_token != get_session(conn, :user_token)
 44 |       assert max_age == 5_184_000
 45 |     end
 46 |   end
 47 | 
 48 |   describe "logout_user/1" do
 49 |     test "erases session and cookies", %{conn: conn, user: user} do
 50 |       user_token = Accounts.generate_user_session_token(user)
 51 | 
 52 |       conn =
 53 |         conn
 54 |         |> put_session(:user_token, user_token)
 55 |         |> put_req_cookie(@remember_me_cookie, user_token)
 56 |         |> fetch_cookies()
 57 |         |> UserAuth.log_out_user()
 58 | 
 59 |       refute get_session(conn, :user_token)
 60 |       refute conn.cookies[@remember_me_cookie]
 61 |       assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie]
 62 |       assert redirected_to(conn) == "/"
 63 |       refute Accounts.get_user_by_session_token(user_token)
 64 |     end
 65 | 
 66 |     test "broadcasts to the given live_socket_id", %{conn: conn} do
 67 |       live_socket_id = "users_sessions:abcdef-token"
 68 |       KetbinWeb.Endpoint.subscribe(live_socket_id)
 69 | 
 70 |       conn
 71 |       |> put_session(:live_socket_id, live_socket_id)
 72 |       |> UserAuth.log_out_user()
 73 | 
 74 |       assert_receive %Phoenix.Socket.Broadcast{
 75 |         event: "disconnect",
 76 |         topic: "users_sessions:abcdef-token"
 77 |       }
 78 |     end
 79 | 
 80 |     test "works even if user is already logged out", %{conn: conn} do
 81 |       conn = conn |> fetch_cookies() |> UserAuth.log_out_user()
 82 |       refute get_session(conn, :user_token)
 83 |       assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie]
 84 |       assert redirected_to(conn) == "/"
 85 |     end
 86 |   end
 87 | 
 88 |   describe "fetch_current_user/2" do
 89 |     test "authenticates user from session", %{conn: conn, user: user} do
 90 |       user_token = Accounts.generate_user_session_token(user)
 91 |       conn = conn |> put_session(:user_token, user_token) |> UserAuth.fetch_current_user([])
 92 |       assert conn.assigns.current_user.id == user.id
 93 |     end
 94 | 
 95 |     test "authenticates user from cookies", %{conn: conn, user: user} do
 96 |       logged_in_conn =
 97 |         conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
 98 | 
 99 |       user_token = logged_in_conn.cookies[@remember_me_cookie]
100 |       %{value: signed_token} = logged_in_conn.resp_cookies[@remember_me_cookie]
101 | 
102 |       conn =
103 |         conn
104 |         |> put_req_cookie(@remember_me_cookie, signed_token)
105 |         |> UserAuth.fetch_current_user([])
106 | 
107 |       assert get_session(conn, :user_token) == user_token
108 |       assert conn.assigns.current_user.id == user.id
109 |     end
110 | 
111 |     test "does not authenticate if data is missing", %{conn: conn, user: user} do
112 |       _ = Accounts.generate_user_session_token(user)
113 |       conn = UserAuth.fetch_current_user(conn, [])
114 |       refute get_session(conn, :user_token)
115 |       refute conn.assigns.current_user
116 |     end
117 |   end
118 | 
119 |   describe "redirect_if_user_is_authenticated/2" do
120 |     test "redirects if user is authenticated", %{conn: conn, user: user} do
121 |       conn = conn |> assign(:current_user, user) |> UserAuth.redirect_if_user_is_authenticated([])
122 |       assert conn.halted
123 |       assert redirected_to(conn) == "/"
124 |     end
125 | 
126 |     test "does not redirect if user is not authenticated", %{conn: conn} do
127 |       conn = UserAuth.redirect_if_user_is_authenticated(conn, [])
128 |       refute conn.halted
129 |       refute conn.status
130 |     end
131 |   end
132 | 
133 |   describe "require_authenticated_user/2" do
134 |     test "redirects if user is not authenticated", %{conn: conn} do
135 |       conn = conn |> fetch_flash() |> UserAuth.require_authenticated_user([])
136 |       assert conn.halted
137 |       assert redirected_to(conn) == Routes.user_session_path(conn, :new)
138 |       assert get_flash(conn, :error) == "You must log in to access this page."
139 |     end
140 | 
141 |     test "stores the path to redirect to on GET", %{conn: conn} do
142 |       halted_conn =
143 |         %{conn | request_path: "/foo", query_string: ""}
144 |         |> fetch_flash()
145 |         |> UserAuth.require_authenticated_user([])
146 | 
147 |       assert halted_conn.halted
148 |       assert get_session(halted_conn, :user_return_to) == "/foo"
149 | 
150 |       halted_conn =
151 |         %{conn | request_path: "/foo", query_string: "bar=baz"}
152 |         |> fetch_flash()
153 |         |> UserAuth.require_authenticated_user([])
154 | 
155 |       assert halted_conn.halted
156 |       assert get_session(halted_conn, :user_return_to) == "/foo?bar=baz"
157 | 
158 |       halted_conn =
159 |         %{conn | request_path: "/foo?bar", method: "POST"}
160 |         |> fetch_flash()
161 |         |> UserAuth.require_authenticated_user([])
162 | 
163 |       assert halted_conn.halted
164 |       refute get_session(halted_conn, :user_return_to)
165 |     end
166 | 
167 |     test "does not redirect if user is authenticated", %{conn: conn, user: user} do
168 |       conn = conn |> assign(:current_user, user) |> UserAuth.require_authenticated_user([])
169 |       refute conn.halted
170 |       refute conn.status
171 |     end
172 |   end
173 | end
174 | 


--------------------------------------------------------------------------------
/lib/ketbin/accounts.ex:
--------------------------------------------------------------------------------
  1 | defmodule Ketbin.Accounts do
  2 |   @moduledoc """
  3 |   The Accounts context.
  4 |   """
  5 | 
  6 |   import Ecto.Query, warn: false
  7 |   alias Ketbin.Repo
  8 |   alias Ketbin.Accounts.{User, UserToken, UserNotifier}
  9 | 
 10 |   ## Database getters
 11 | 
 12 |   @doc """
 13 |   Gets a user by email.
 14 | 
 15 |   ## Examples
 16 | 
 17 |       iex> get_user_by_email("foo@example.com")
 18 |       %User{}
 19 | 
 20 |       iex> get_user_by_email("unknown@example.com")
 21 |       nil
 22 | 
 23 |   """
 24 |   def get_user_by_email(email) when is_binary(email) do
 25 |     Repo.get_by(User, email: email)
 26 |   end
 27 | 
 28 |   @doc """
 29 |   Gets a user by email and password.
 30 | 
 31 |   ## Examples
 32 | 
 33 |       iex> get_user_by_email_and_password("foo@example.com", "correct_password")
 34 |       %User{}
 35 | 
 36 |       iex> get_user_by_email_and_password("foo@example.com", "invalid_password")
 37 |       nil
 38 | 
 39 |   """
 40 |   def get_user_by_email_and_password(email, password)
 41 |       when is_binary(email) and is_binary(password) do
 42 |     user = Repo.get_by(User, email: email)
 43 |     if User.valid_password?(user, password), do: user
 44 |   end
 45 | 
 46 |   @doc """
 47 |   Gets a single user.
 48 | 
 49 |   Raises `Ecto.NoResultsError` if the User does not exist.
 50 | 
 51 |   ## Examples
 52 | 
 53 |       iex> get_user!(123)
 54 |       %User{}
 55 | 
 56 |       iex> get_user!(456)
 57 |       ** (Ecto.NoResultsError)
 58 | 
 59 |   """
 60 |   def get_user!(id), do: Repo.get!(User, id)
 61 | 
 62 |   ## User registration
 63 | 
 64 |   @doc """
 65 |   Registers a user.
 66 | 
 67 |   ## Examples
 68 | 
 69 |       iex> register_user(%{field: value})
 70 |       {:ok, %User{}}
 71 | 
 72 |       iex> register_user(%{field: bad_value})
 73 |       {:error, %Ecto.Changeset{}}
 74 | 
 75 |   """
 76 |   def register_user(attrs) do
 77 |     %User{}
 78 |     |> User.registration_changeset(attrs)
 79 |     |> Repo.insert()
 80 |   end
 81 | 
 82 |   @doc """
 83 |   Returns an `%Ecto.Changeset{}` for tracking user changes.
 84 | 
 85 |   ## Examples
 86 | 
 87 |       iex> change_user_registration(user)
 88 |       %Ecto.Changeset{data: %User{}}
 89 | 
 90 |   """
 91 |   def change_user_registration(%User{} = user, attrs \\ %{}) do
 92 |     User.registration_changeset(user, attrs, hash_password: false)
 93 |   end
 94 | 
 95 |   ## Settings
 96 | 
 97 |   @doc """
 98 |   Returns an `%Ecto.Changeset{}` for changing the user email.
 99 | 
100 |   ## Examples
101 | 
102 |       iex> change_user_email(user)
103 |       %Ecto.Changeset{data: %User{}}
104 | 
105 |   """
106 |   def change_user_email(user, attrs \\ %{}) do
107 |     User.email_changeset(user, attrs)
108 |   end
109 | 
110 |   @doc """
111 |   Emulates that the email will change without actually changing
112 |   it in the database.
113 | 
114 |   ## Examples
115 | 
116 |       iex> apply_user_email(user, "valid password", %{email: ...})
117 |       {:ok, %User{}}
118 | 
119 |       iex> apply_user_email(user, "invalid password", %{email: ...})
120 |       {:error, %Ecto.Changeset{}}
121 | 
122 |   """
123 |   def apply_user_email(user, password, attrs) do
124 |     user
125 |     |> User.email_changeset(attrs)
126 |     |> User.validate_current_password(password)
127 |     |> Ecto.Changeset.apply_action(:update)
128 |   end
129 | 
130 |   @doc """
131 |   Updates the user email using the given token.
132 | 
133 |   If the token matches, the user email is updated and the token is deleted.
134 |   The confirmed_at date is also updated to the current time.
135 |   """
136 |   def update_user_email(user, token) do
137 |     context = "change:#{user.email}"
138 | 
139 |     with {:ok, query} <- UserToken.verify_change_email_token_query(token, context),
140 |          %UserToken{sent_to: email} <- Repo.one(query),
141 |          {:ok, _} <- Repo.transaction(user_email_multi(user, email, context)) do
142 |       :ok
143 |     else
144 |       _ -> :error
145 |     end
146 |   end
147 | 
148 |   defp user_email_multi(user, email, context) do
149 |     changeset = user |> User.email_changeset(%{email: email}) |> User.confirm_changeset()
150 | 
151 |     Ecto.Multi.new()
152 |     |> Ecto.Multi.update(:user, changeset)
153 |     |> Ecto.Multi.delete_all(:tokens, UserToken.user_and_contexts_query(user, [context]))
154 |   end
155 | 
156 |   @doc """
157 |   Delivers the update email instructions to the given user.
158 | 
159 |   ## Examples
160 | 
161 |       iex> deliver_update_email_instructions(user, current_email, &Routes.user_update_email_url(conn, :edit, &1))
162 |       {:ok, %{to: ..., body: ...}}
163 | 
164 |   """
165 |   def deliver_update_email_instructions(%User{} = user, current_email, update_email_url_fun)
166 |       when is_function(update_email_url_fun, 1) do
167 |     {encoded_token, user_token} = UserToken.build_email_token(user, "change:#{current_email}")
168 | 
169 |     Repo.insert!(user_token)
170 |     UserNotifier.deliver_update_email_instructions(user, update_email_url_fun.(encoded_token))
171 |   end
172 | 
173 |   @doc """
174 |   Returns an `%Ecto.Changeset{}` for changing the user password.
175 | 
176 |   ## Examples
177 | 
178 |       iex> change_user_password(user)
179 |       %Ecto.Changeset{data: %User{}}
180 | 
181 |   """
182 |   def change_user_password(user, attrs \\ %{}) do
183 |     User.password_changeset(user, attrs, hash_password: false)
184 |   end
185 | 
186 |   @doc """
187 |   Updates the user password.
188 | 
189 |   ## Examples
190 | 
191 |       iex> update_user_password(user, "valid password", %{password: ...})
192 |       {:ok, %User{}}
193 | 
194 |       iex> update_user_password(user, "invalid password", %{password: ...})
195 |       {:error, %Ecto.Changeset{}}
196 | 
197 |   """
198 |   def update_user_password(user, password, attrs) do
199 |     changeset =
200 |       user
201 |       |> User.password_changeset(attrs)
202 |       |> User.validate_current_password(password)
203 | 
204 |     Ecto.Multi.new()
205 |     |> Ecto.Multi.update(:user, changeset)
206 |     |> Ecto.Multi.delete_all(:tokens, UserToken.user_and_contexts_query(user, :all))
207 |     |> Repo.transaction()
208 |     |> case do
209 |       {:ok, %{user: user}} -> {:ok, user}
210 |       {:error, :user, changeset, _} -> {:error, changeset}
211 |     end
212 |   end
213 | 
214 |   ## Session
215 | 
216 |   @doc """
217 |   Generates a session token.
218 |   """
219 |   def generate_user_session_token(user) do
220 |     {token, user_token} = UserToken.build_session_token(user)
221 |     Repo.insert!(user_token)
222 |     token
223 |   end
224 | 
225 |   @doc """
226 |   Gets the user with the given signed token.
227 |   """
228 |   def get_user_by_session_token(token) do
229 |     {:ok, query} = UserToken.verify_session_token_query(token)
230 |     Repo.one(query)
231 |   end
232 | 
233 |   @doc """
234 |   Deletes the signed token with the given context.
235 |   """
236 |   def delete_session_token(token) do
237 |     Repo.delete_all(UserToken.token_and_context_query(token, "session"))
238 |     :ok
239 |   end
240 | 
241 |   ## Confirmation
242 | 
243 |   @doc """
244 |   Delivers the confirmation email instructions to the given user.
245 | 
246 |   ## Examples
247 | 
248 |       iex> deliver_user_confirmation_instructions(user, &Routes.user_confirmation_url(conn, :confirm, &1))
249 |       {:ok, %{to: ..., body: ...}}
250 | 
251 |       iex> deliver_user_confirmation_instructions(confirmed_user, &Routes.user_confirmation_url(conn, :confirm, &1))
252 |       {:error, :already_confirmed}
253 | 
254 |   """
255 |   def deliver_user_confirmation_instructions(%User{} = user, confirmation_url_fun)
256 |       when is_function(confirmation_url_fun, 1) do
257 |     if user.confirmed_at do
258 |       {:error, :already_confirmed}
259 |     else
260 |       {encoded_token, user_token} = UserToken.build_email_token(user, "confirm")
261 |       Repo.insert!(user_token)
262 |       UserNotifier.deliver_confirmation_instructions(user, confirmation_url_fun.(encoded_token))
263 |     end
264 |   end
265 | 
266 |   @doc """
267 |   Confirms a user by the given token.
268 | 
269 |   If the token matches, the user account is marked as confirmed
270 |   and the token is deleted.
271 |   """
272 |   def confirm_user(token) do
273 |     with {:ok, query} <- UserToken.verify_email_token_query(token, "confirm"),
274 |          %User{} = user <- Repo.one(query),
275 |          {:ok, %{user: user}} <- Repo.transaction(confirm_user_multi(user)) do
276 |       {:ok, user}
277 |     else
278 |       _ -> :error
279 |     end
280 |   end
281 | 
282 |   defp confirm_user_multi(user) do
283 |     Ecto.Multi.new()
284 |     |> Ecto.Multi.update(:user, User.confirm_changeset(user))
285 |     |> Ecto.Multi.delete_all(:tokens, UserToken.user_and_contexts_query(user, ["confirm"]))
286 |   end
287 | 
288 |   ## Reset password
289 | 
290 |   @doc """
291 |   Delivers the reset password email to the given user.
292 | 
293 |   ## Examples
294 | 
295 |       iex> deliver_user_reset_password_instructions(user, &Routes.user_reset_password_url(conn, :edit, &1))
296 |       {:ok, %{to: ..., body: ...}}
297 | 
298 |   """
299 |   def deliver_user_reset_password_instructions(%User{} = user, reset_password_url_fun)
300 |       when is_function(reset_password_url_fun, 1) do
301 |     {encoded_token, user_token} = UserToken.build_email_token(user, "reset_password")
302 |     Repo.insert!(user_token)
303 |     UserNotifier.deliver_reset_password_instructions(user, reset_password_url_fun.(encoded_token))
304 |   end
305 | 
306 |   @doc """
307 |   Gets the user by reset password token.
308 | 
309 |   ## Examples
310 | 
311 |       iex> get_user_by_reset_password_token("validtoken")
312 |       %User{}
313 | 
314 |       iex> get_user_by_reset_password_token("invalidtoken")
315 |       nil
316 | 
317 |   """
318 |   def get_user_by_reset_password_token(token) do
319 |     with {:ok, query} <- UserToken.verify_email_token_query(token, "reset_password"),
320 |          %User{} = user <- Repo.one(query) do
321 |       user
322 |     else
323 |       _ -> nil
324 |     end
325 |   end
326 | 
327 |   @doc """
328 |   Resets the user password.
329 | 
330 |   ## Examples
331 | 
332 |       iex> reset_user_password(user, %{password: "new long password", password_confirmation: "new long password"})
333 |       {:ok, %User{}}
334 | 
335 |       iex> reset_user_password(user, %{password: "valid", password_confirmation: "not the same"})
336 |       {:error, %Ecto.Changeset{}}
337 | 
338 |   """
339 |   def reset_user_password(user, attrs) do
340 |     Ecto.Multi.new()
341 |     |> Ecto.Multi.update(:user, User.password_changeset(user, attrs))
342 |     |> Ecto.Multi.delete_all(:tokens, UserToken.user_and_contexts_query(user, :all))
343 |     |> Repo.transaction()
344 |     |> case do
345 |       {:ok, %{user: user}} -> {:ok, user}
346 |       {:error, :user, changeset, _} -> {:error, changeset}
347 |     end
348 |   end
349 | end
350 | 


--------------------------------------------------------------------------------
/native/ketbin_utils_syntax/Cargo.lock:
--------------------------------------------------------------------------------
  1 | # This file is automatically @generated by Cargo.
  2 | # It is not intended for manual editing.
  3 | version = 3
  4 | 
  5 | [[package]]
  6 | name = "adler"
  7 | version = "1.0.2"
  8 | source = "registry+https://github.com/rust-lang/crates.io-index"
  9 | checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 10 | 
 11 | [[package]]
 12 | name = "aho-corasick"
 13 | version = "1.0.2"
 14 | source = "registry+https://github.com/rust-lang/crates.io-index"
 15 | checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"
 16 | dependencies = [
 17 |  "memchr",
 18 | ]
 19 | 
 20 | [[package]]
 21 | name = "autocfg"
 22 | version = "1.1.0"
 23 | source = "registry+https://github.com/rust-lang/crates.io-index"
 24 | checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 25 | 
 26 | [[package]]
 27 | name = "base64"
 28 | version = "0.21.2"
 29 | source = "registry+https://github.com/rust-lang/crates.io-index"
 30 | checksum = "604178f6c5c21f02dc555784810edfb88d34ac2c73b2eae109655649ee73ce3d"
 31 | 
 32 | [[package]]
 33 | name = "bincode"
 34 | version = "1.3.3"
 35 | source = "registry+https://github.com/rust-lang/crates.io-index"
 36 | checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
 37 | dependencies = [
 38 |  "serde",
 39 | ]
 40 | 
 41 | [[package]]
 42 | name = "bitflags"
 43 | version = "1.3.2"
 44 | source = "registry+https://github.com/rust-lang/crates.io-index"
 45 | checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 46 | 
 47 | [[package]]
 48 | name = "cc"
 49 | version = "1.0.79"
 50 | source = "registry+https://github.com/rust-lang/crates.io-index"
 51 | checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
 52 | 
 53 | [[package]]
 54 | name = "cfg-if"
 55 | version = "1.0.0"
 56 | source = "registry+https://github.com/rust-lang/crates.io-index"
 57 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 58 | 
 59 | [[package]]
 60 | name = "crc32fast"
 61 | version = "1.3.2"
 62 | source = "registry+https://github.com/rust-lang/crates.io-index"
 63 | checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
 64 | dependencies = [
 65 |  "cfg-if",
 66 | ]
 67 | 
 68 | [[package]]
 69 | name = "flate2"
 70 | version = "1.0.26"
 71 | source = "registry+https://github.com/rust-lang/crates.io-index"
 72 | checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
 73 | dependencies = [
 74 |  "crc32fast",
 75 |  "miniz_oxide",
 76 | ]
 77 | 
 78 | [[package]]
 79 | name = "fnv"
 80 | version = "1.0.7"
 81 | source = "registry+https://github.com/rust-lang/crates.io-index"
 82 | checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 83 | 
 84 | [[package]]
 85 | name = "hashbrown"
 86 | version = "0.12.3"
 87 | source = "registry+https://github.com/rust-lang/crates.io-index"
 88 | checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 89 | 
 90 | [[package]]
 91 | name = "heck"
 92 | version = "0.4.1"
 93 | source = "registry+https://github.com/rust-lang/crates.io-index"
 94 | checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 95 | 
 96 | [[package]]
 97 | name = "indexmap"
 98 | version = "1.9.3"
 99 | source = "registry+https://github.com/rust-lang/crates.io-index"
100 | checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
101 | dependencies = [
102 |  "autocfg",
103 |  "hashbrown",
104 | ]
105 | 
106 | [[package]]
107 | name = "itoa"
108 | version = "1.0.6"
109 | source = "registry+https://github.com/rust-lang/crates.io-index"
110 | checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
111 | 
112 | [[package]]
113 | name = "ketbin_utils_syntax"
114 | version = "0.1.0"
115 | dependencies = [
116 |  "rustler",
117 |  "syntect",
118 | ]
119 | 
120 | [[package]]
121 | name = "lazy_static"
122 | version = "1.4.0"
123 | source = "registry+https://github.com/rust-lang/crates.io-index"
124 | checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
125 | 
126 | [[package]]
127 | name = "lazycell"
128 | version = "1.3.0"
129 | source = "registry+https://github.com/rust-lang/crates.io-index"
130 | checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
131 | 
132 | [[package]]
133 | name = "libc"
134 | version = "0.2.147"
135 | source = "registry+https://github.com/rust-lang/crates.io-index"
136 | checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
137 | 
138 | [[package]]
139 | name = "line-wrap"
140 | version = "0.1.1"
141 | source = "registry+https://github.com/rust-lang/crates.io-index"
142 | checksum = "f30344350a2a51da54c1d53be93fade8a237e545dbcc4bdbe635413f2117cab9"
143 | dependencies = [
144 |  "safemem",
145 | ]
146 | 
147 | [[package]]
148 | name = "linked-hash-map"
149 | version = "0.5.6"
150 | source = "registry+https://github.com/rust-lang/crates.io-index"
151 | checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
152 | 
153 | [[package]]
154 | name = "memchr"
155 | version = "2.5.0"
156 | source = "registry+https://github.com/rust-lang/crates.io-index"
157 | checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
158 | 
159 | [[package]]
160 | name = "miniz_oxide"
161 | version = "0.7.1"
162 | source = "registry+https://github.com/rust-lang/crates.io-index"
163 | checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
164 | dependencies = [
165 |  "adler",
166 | ]
167 | 
168 | [[package]]
169 | name = "once_cell"
170 | version = "1.18.0"
171 | source = "registry+https://github.com/rust-lang/crates.io-index"
172 | checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
173 | 
174 | [[package]]
175 | name = "onig"
176 | version = "6.4.0"
177 | source = "registry+https://github.com/rust-lang/crates.io-index"
178 | checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f"
179 | dependencies = [
180 |  "bitflags",
181 |  "libc",
182 |  "once_cell",
183 |  "onig_sys",
184 | ]
185 | 
186 | [[package]]
187 | name = "onig_sys"
188 | version = "69.8.1"
189 | source = "registry+https://github.com/rust-lang/crates.io-index"
190 | checksum = "7b829e3d7e9cc74c7e315ee8edb185bf4190da5acde74afd7fc59c35b1f086e7"
191 | dependencies = [
192 |  "cc",
193 |  "pkg-config",
194 | ]
195 | 
196 | [[package]]
197 | name = "pkg-config"
198 | version = "0.3.27"
199 | source = "registry+https://github.com/rust-lang/crates.io-index"
200 | checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
201 | 
202 | [[package]]
203 | name = "plist"
204 | version = "1.4.3"
205 | source = "registry+https://github.com/rust-lang/crates.io-index"
206 | checksum = "9bd9647b268a3d3e14ff09c23201133a62589c658db02bb7388c7246aafe0590"
207 | dependencies = [
208 |  "base64",
209 |  "indexmap",
210 |  "line-wrap",
211 |  "quick-xml",
212 |  "serde",
213 |  "time",
214 | ]
215 | 
216 | [[package]]
217 | name = "proc-macro2"
218 | version = "1.0.63"
219 | source = "registry+https://github.com/rust-lang/crates.io-index"
220 | checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
221 | dependencies = [
222 |  "unicode-ident",
223 | ]
224 | 
225 | [[package]]
226 | name = "quick-xml"
227 | version = "0.28.2"
228 | source = "registry+https://github.com/rust-lang/crates.io-index"
229 | checksum = "0ce5e73202a820a31f8a0ee32ada5e21029c81fd9e3ebf668a40832e4219d9d1"
230 | dependencies = [
231 |  "memchr",
232 | ]
233 | 
234 | [[package]]
235 | name = "quote"
236 | version = "1.0.28"
237 | source = "registry+https://github.com/rust-lang/crates.io-index"
238 | checksum = "1b9ab9c7eadfd8df19006f1cf1a4aed13540ed5cbc047010ece5826e10825488"
239 | dependencies = [
240 |  "proc-macro2",
241 | ]
242 | 
243 | [[package]]
244 | name = "regex"
245 | version = "1.8.4"
246 | source = "registry+https://github.com/rust-lang/crates.io-index"
247 | checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f"
248 | dependencies = [
249 |  "aho-corasick",
250 |  "memchr",
251 |  "regex-syntax 0.7.2",
252 | ]
253 | 
254 | [[package]]
255 | name = "regex-syntax"
256 | version = "0.6.29"
257 | source = "registry+https://github.com/rust-lang/crates.io-index"
258 | checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
259 | 
260 | [[package]]
261 | name = "regex-syntax"
262 | version = "0.7.2"
263 | source = "registry+https://github.com/rust-lang/crates.io-index"
264 | checksum = "436b050e76ed2903236f032a59761c1eb99e1b0aead2c257922771dab1fc8c78"
265 | 
266 | [[package]]
267 | name = "rustler"
268 | version = "0.29.0"
269 | source = "registry+https://github.com/rust-lang/crates.io-index"
270 | checksum = "095fb0fb2864560480609c5b1427fe9f3872f6b3e400036f5531e8f06ff33026"
271 | dependencies = [
272 |  "lazy_static",
273 |  "rustler_codegen",
274 |  "rustler_sys",
275 | ]
276 | 
277 | [[package]]
278 | name = "rustler_codegen"
279 | version = "0.29.0"
280 | source = "registry+https://github.com/rust-lang/crates.io-index"
281 | checksum = "a8911f25973c1d68a3ffdea53d664026f6b0877c949bd3f9f5bc263385c33553"
282 | dependencies = [
283 |  "heck",
284 |  "proc-macro2",
285 |  "quote",
286 |  "syn",
287 | ]
288 | 
289 | [[package]]
290 | name = "rustler_sys"
291 | version = "2.3.0"
292 | source = "registry+https://github.com/rust-lang/crates.io-index"
293 | checksum = "0b311902a5c224452d0d8e1821a4b682d43f58248a2c559f613a7b52e0980075"
294 | dependencies = [
295 |  "regex",
296 |  "unreachable",
297 | ]
298 | 
299 | [[package]]
300 | name = "ryu"
301 | version = "1.0.13"
302 | source = "registry+https://github.com/rust-lang/crates.io-index"
303 | checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
304 | 
305 | [[package]]
306 | name = "safemem"
307 | version = "0.3.3"
308 | source = "registry+https://github.com/rust-lang/crates.io-index"
309 | checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
310 | 
311 | [[package]]
312 | name = "same-file"
313 | version = "1.0.6"
314 | source = "registry+https://github.com/rust-lang/crates.io-index"
315 | checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
316 | dependencies = [
317 |  "winapi-util",
318 | ]
319 | 
320 | [[package]]
321 | name = "serde"
322 | version = "1.0.164"
323 | source = "registry+https://github.com/rust-lang/crates.io-index"
324 | checksum = "9e8c8cf938e98f769bc164923b06dce91cea1751522f46f8466461af04c9027d"
325 | 
326 | [[package]]
327 | name = "serde_derive"
328 | version = "1.0.164"
329 | source = "registry+https://github.com/rust-lang/crates.io-index"
330 | checksum = "d9735b638ccc51c28bf6914d90a2e9725b377144fc612c49a611fddd1b631d68"
331 | dependencies = [
332 |  "proc-macro2",
333 |  "quote",
334 |  "syn",
335 | ]
336 | 
337 | [[package]]
338 | name = "serde_json"
339 | version = "1.0.99"
340 | source = "registry+https://github.com/rust-lang/crates.io-index"
341 | checksum = "46266871c240a00b8f503b877622fe33430b3c7d963bdc0f2adc511e54a1eae3"
342 | dependencies = [
343 |  "itoa",
344 |  "ryu",
345 |  "serde",
346 | ]
347 | 
348 | [[package]]
349 | name = "syn"
350 | version = "2.0.22"
351 | source = "registry+https://github.com/rust-lang/crates.io-index"
352 | checksum = "2efbeae7acf4eabd6bcdcbd11c92f45231ddda7539edc7806bd1a04a03b24616"
353 | dependencies = [
354 |  "proc-macro2",
355 |  "quote",
356 |  "unicode-ident",
357 | ]
358 | 
359 | [[package]]
360 | name = "syntect"
361 | version = "4.6.0"
362 | source = "registry+https://github.com/rust-lang/crates.io-index"
363 | checksum = "8b20815bbe80ee0be06e6957450a841185fcf690fe0178f14d77a05ce2caa031"
364 | dependencies = [
365 |  "bincode",
366 |  "bitflags",
367 |  "flate2",
368 |  "fnv",
369 |  "lazy_static",
370 |  "lazycell",
371 |  "onig",
372 |  "plist",
373 |  "regex-syntax 0.6.29",
374 |  "serde",
375 |  "serde_derive",
376 |  "serde_json",
377 |  "walkdir",
378 |  "yaml-rust",
379 | ]
380 | 
381 | [[package]]
382 | name = "time"
383 | version = "0.3.22"
384 | source = "registry+https://github.com/rust-lang/crates.io-index"
385 | checksum = "ea9e1b3cf1243ae005d9e74085d4d542f3125458f3a81af210d901dcd7411efd"
386 | dependencies = [
387 |  "itoa",
388 |  "serde",
389 |  "time-core",
390 |  "time-macros",
391 | ]
392 | 
393 | [[package]]
394 | name = "time-core"
395 | version = "0.1.1"
396 | source = "registry+https://github.com/rust-lang/crates.io-index"
397 | checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
398 | 
399 | [[package]]
400 | name = "time-macros"
401 | version = "0.2.9"
402 | source = "registry+https://github.com/rust-lang/crates.io-index"
403 | checksum = "372950940a5f07bf38dbe211d7283c9e6d7327df53794992d293e534c733d09b"
404 | dependencies = [
405 |  "time-core",
406 | ]
407 | 
408 | [[package]]
409 | name = "unicode-ident"
410 | version = "1.0.9"
411 | source = "registry+https://github.com/rust-lang/crates.io-index"
412 | checksum = "b15811caf2415fb889178633e7724bad2509101cde276048e013b9def5e51fa0"
413 | 
414 | [[package]]
415 | name = "unreachable"
416 | version = "1.0.0"
417 | source = "registry+https://github.com/rust-lang/crates.io-index"
418 | checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
419 | dependencies = [
420 |  "void",
421 | ]
422 | 
423 | [[package]]
424 | name = "void"
425 | version = "1.0.2"
426 | source = "registry+https://github.com/rust-lang/crates.io-index"
427 | checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
428 | 
429 | [[package]]
430 | name = "walkdir"
431 | version = "2.3.3"
432 | source = "registry+https://github.com/rust-lang/crates.io-index"
433 | checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698"
434 | dependencies = [
435 |  "same-file",
436 |  "winapi-util",
437 | ]
438 | 
439 | [[package]]
440 | name = "winapi"
441 | version = "0.3.9"
442 | source = "registry+https://github.com/rust-lang/crates.io-index"
443 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
444 | dependencies = [
445 |  "winapi-i686-pc-windows-gnu",
446 |  "winapi-x86_64-pc-windows-gnu",
447 | ]
448 | 
449 | [[package]]
450 | name = "winapi-i686-pc-windows-gnu"
451 | version = "0.4.0"
452 | source = "registry+https://github.com/rust-lang/crates.io-index"
453 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
454 | 
455 | [[package]]
456 | name = "winapi-util"
457 | version = "0.1.5"
458 | source = "registry+https://github.com/rust-lang/crates.io-index"
459 | checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
460 | dependencies = [
461 |  "winapi",
462 | ]
463 | 
464 | [[package]]
465 | name = "winapi-x86_64-pc-windows-gnu"
466 | version = "0.4.0"
467 | source = "registry+https://github.com/rust-lang/crates.io-index"
468 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
469 | 
470 | [[package]]
471 | name = "yaml-rust"
472 | version = "0.4.5"
473 | source = "registry+https://github.com/rust-lang/crates.io-index"
474 | checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
475 | dependencies = [
476 |  "linked-hash-map",
477 | ]
478 | 


--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
 1 | %{
 2 |   "bcrypt_elixir": {:hex, :bcrypt_elixir, "2.3.1", "5114d780459a04f2b4aeef52307de23de961b69e13a5cd98a911e39fda13f420", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "42182d5f46764def15bf9af83739e3bf4ad22661b1c34fc3e88558efced07279"},
 3 |   "castore": {:hex, :castore, "1.0.3", "7130ba6d24c8424014194676d608cb989f62ef8039efd50ff4b3f33286d06db8", [:mix], [], "hexpm", "680ab01ef5d15b161ed6a95449fac5c6b8f60055677a8e79acf01b27baa4390b"},
 4 |   "certifi": {:hex, :certifi, "2.9.0", "6f2a475689dd47f19fb74334859d460a2dc4e3252a3324bd2111b8f0429e7e21", [:rebar3], [], "hexpm", "266da46bdb06d6c6d35fde799bcb28d36d985d424ad7c08b5bb48f5b5cdd4641"},
 5 |   "comeonin": {:hex, :comeonin, "5.3.3", "2c564dac95a35650e9b6acfe6d2952083d8a08e4a89b93a481acb552b325892e", [:mix], [], "hexpm", "3e38c9c2cb080828116597ca8807bb482618a315bfafd98c90bc22a821cc84df"},
 6 |   "cors_plug": {:hex, :cors_plug, "3.0.3", "7c3ac52b39624bc616db2e937c282f3f623f25f8d550068b6710e58d04a0e330", [:mix], [{:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3f2d759e8c272ed3835fab2ef11b46bddab8c1ab9528167bd463b6452edf830d"},
 7 |   "cowboy": {:hex, :cowboy, "2.10.0", "ff9ffeff91dae4ae270dd975642997afe2a1179d94b1887863e43f681a203e26", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "3afdccb7183cc6f143cb14d3cf51fa00e53db9ec80cdcd525482f5e99bc41d6b"},
 8 |   "cowboy_telemetry": {:hex, :cowboy_telemetry, "0.3.1", "ebd1a1d7aff97f27c66654e78ece187abdc646992714164380d8a041eda16754", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3a6efd3366130eab84ca372cbd4a7d3c3a97bdfcfb4911233b035d117063f0af"},
 9 |   "cowlib": {:hex, :cowlib, "2.12.1", "a9fa9a625f1d2025fe6b462cb865881329b5caff8f1854d1cbc9f9533f00e1e1", [:make, :rebar3], [], "hexpm", "163b73f6367a7341b33c794c4e88e7dbfe6498ac42dcd69ef44c5bc5507c8db0"},
10 |   "db_connection": {:hex, :db_connection, "2.5.0", "bb6d4f30d35ded97b29fe80d8bd6f928a1912ca1ff110831edcd238a1973652c", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c92d5ba26cd69ead1ff7582dbb860adeedfff39774105a4f1c92cbb654b55aa2"},
11 |   "decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
12 |   "earmark": {:hex, :earmark, "1.4.38", "ba8fda946c259c6e8f6759d3647d448e9216e2c0afed8c6ae7f8ce1f7072a497", [:mix], [{:earmark_parser, "~> 1.4.32", [hex: :earmark_parser, repo: "hexpm", optional: false]}], "hexpm", "f938e30de4167e7d8f3bf588b01dc041138278dda1e5a13fb9ec89b43dd5ec7f"},
13 |   "earmark_parser": {:hex, :earmark_parser, "1.4.32", "fa739a0ecfa34493de19426681b23f6814573faee95dfd4b4aafe15a7b5b32c6", [:mix], [], "hexpm", "b8b0dd77d60373e77a3d7e8afa598f325e49e8663a51bcc2b88ef41838cca755"},
14 |   "ecto": {:hex, :ecto, "3.10.2", "6b887160281a61aa16843e47735b8a266caa437f80588c3ab80a8a960e6abe37", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6a895778f0d7648a4b34b486af59a1c8009041fbdf2b17f1ac215eb829c60235"},
15 |   "ecto_sql": {:hex, :ecto_sql, "3.10.1", "6ea6b3036a0b0ca94c2a02613fd9f742614b5cfe494c41af2e6571bb034dd94c", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.10.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "f6a25bdbbd695f12c8171eaff0851fa4c8e72eec1e98c7364402dda9ce11c56b"},
16 |   "elixir_make": {:hex, :elixir_make, "0.7.7", "7128c60c2476019ed978210c245badf08b03dbec4f24d05790ef791da11aa17c", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}], "hexpm", "5bc19fff950fad52bbe5f211b12db9ec82c6b34a9647da0c2224b8b8464c7e6c"},
17 |   "expo": {:hex, :expo, "0.4.1", "1c61d18a5df197dfda38861673d392e642649a9cef7694d2f97a587b2cfb319b", [:mix], [], "hexpm", "2ff7ba7a798c8c543c12550fa0e2cbc81b95d4974c65855d8d15ba7b37a1ce47"},
18 |   "file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
19 |   "gen_smtp": {:hex, :gen_smtp, "1.2.0", "9cfc75c72a8821588b9b9fe947ae5ab2aed95a052b81237e0928633a13276fd3", [:rebar3], [{:ranch, ">= 1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "5ee0375680bca8f20c4d85f58c2894441443a743355430ff33a783fe03296779"},
20 |   "gettext": {:hex, :gettext, "0.22.2", "6bfca374de34ecc913a28ba391ca184d88d77810a3e427afa8454a71a51341ac", [:mix], [{:expo, "~> 0.4.0", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "8a2d389673aea82d7eae387e6a2ccc12660610080ae7beb19452cfdc1ec30f60"},
21 |   "hackney": {:hex, :hackney, "1.18.1", "f48bf88f521f2a229fc7bae88cf4f85adc9cd9bcf23b5dc8eb6a1788c662c4f6", [:rebar3], [{:certifi, "~> 2.9.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~> 6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~> 1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~> 1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.3.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~> 0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "a4ecdaff44297e9b5894ae499e9a070ea1888c84afdd1fd9b7b2bc384950128e"},
22 |   "html_sanitize_ex": {:hex, :html_sanitize_ex, "1.4.3", "67b3d9fa8691b727317e0cc96b9b3093be00ee45419ffb221cdeee88e75d1360", [:mix], [{:mochiweb, "~> 2.15 or ~> 3.1", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm", "87748d3c4afe949c7c6eb7150c958c2bcba43fc5b2a02686af30e636b74bccb7"},
23 |   "idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~> 0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
24 |   "jason": {:hex, :jason, "1.4.0", "e855647bc964a44e2f67df589ccf49105ae039d4179db7f6271dfd3843dc27e6", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "79a3791085b2a0f743ca04cec0f7be26443738779d09302e01318f97bdb82121"},
25 |   "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
26 |   "mime": {:hex, :mime, "2.0.5", "dc34c8efd439abe6ae0343edbb8556f4d63f178594894720607772a041b04b02", [:mix], [], "hexpm", "da0d64a365c45bc9935cc5c8a7fc5e49a0e0f9932a761c55d6c52b142780a05c"},
27 |   "mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm", "f278585650aa581986264638ebf698f8bb19df297f66ad91b18910dfc6e19323"},
28 |   "mochiweb": {:hex, :mochiweb, "3.2.2", "bb435384b3b9fd1f92f2f3fe652ea644432877a3e8a81ed6459ce951e0482ad3", [:rebar3], [], "hexpm", "4114e51f1b44c270b3242d91294fe174ce1ed989100e8b65a1fab58e0cba41d5"},
29 |   "parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},
30 |   "phoenix": {:hex, :phoenix, "1.6.16", "e5bdd18c7a06da5852a25c7befb72246de4ddc289182285f8685a40b7b5f5451", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 1.0 or ~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:plug, "~> 1.10", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.2", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e15989ff34f670a96b95ef6d1d25bad0d9c50df5df40b671d8f4a669e050ac39"},
31 |   "phoenix_ecto": {:hex, :phoenix_ecto, "4.4.2", "b21bd01fdeffcfe2fab49e4942aa938b6d3e89e93a480d4aee58085560a0bc0d", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "70242edd4601d50b69273b057ecf7b684644c19ee750989fd555625ae4ce8f5d"},
32 |   "phoenix_html": {:hex, :phoenix_html, "3.3.1", "4788757e804a30baac6b3fc9695bf5562465dd3f1da8eb8460ad5b404d9a2178", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "bed1906edd4906a15fd7b412b85b05e521e1f67c9a85418c55999277e553d0d3"},
33 |   "phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.7.2", "97cc4ff2dba1ebe504db72cb45098cb8e91f11160528b980bd282cc45c73b29c", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.18.3", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "0e5fdf063c7a3b620c566a30fcf68b7ee02e5e46fe48ee46a6ec3ba382dc05b7"},
34 |   "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.4.1", "2aff698f5e47369decde4357ba91fc9c37c6487a512b41732818f2204a8ef1d3", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "9bffb834e7ddf08467fe54ae58b5785507aaba6255568ae22b4d46e2bb3615ab"},
35 |   "phoenix_live_view": {:hex, :phoenix_live_view, "0.18.18", "1f38fbd7c363723f19aad1a04b5490ff3a178e37daaf6999594d5f34796c47fc", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a5810d0472f3189ede6d2a95bda7f31c6113156b91784a3426cb0ab6a6d85214"},
36 |   "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
37 |   "phoenix_template": {:hex, :phoenix_template, "1.0.1", "85f79e3ad1b0180abb43f9725973e3b8c2c3354a87245f91431eec60553ed3ef", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "157dc078f6226334c91cb32c1865bf3911686f8bcd6bcff86736f6253e6993ee"},
38 |   "phoenix_view": {:hex, :phoenix_view, "2.0.2", "6bd4d2fd595ef80d33b439ede6a19326b78f0f1d8d62b9a318e3d9c1af351098", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "a929e7230ea5c7ee0e149ffcf44ce7cf7f4b6d2bfe1752dd7c084cdff152d36f"},
39 |   "plug": {:hex, :plug, "1.14.2", "cff7d4ec45b4ae176a227acd94a7ab536d9b37b942c8e8fa6dfc0fff98ff4d80", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "842fc50187e13cf4ac3b253d47d9474ed6c296a8732752835ce4a86acdf68d13"},
40 |   "plug_cowboy": {:hex, :plug_cowboy, "2.6.1", "9a3bbfceeb65eff5f39dab529e5cd79137ac36e913c02067dba3963a26efe9b2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "de36e1a21f451a18b790f37765db198075c25875c64834bcc82d90b309eb6613"},
41 |   "plug_crypto": {:hex, :plug_crypto, "1.2.5", "918772575e48e81e455818229bf719d4ab4181fcbf7f85b68a35620f78d89ced", [:mix], [], "hexpm", "26549a1d6345e2172eb1c233866756ae44a9609bd33ee6f99147ab3fd87fd842"},
42 |   "postgrex": {:hex, :postgrex, "0.17.1", "01c29fd1205940ee55f7addb8f1dc25618ca63a8817e56fac4f6846fc2cddcbe", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "14b057b488e73be2beee508fb1955d8db90d6485c6466428fe9ccf1d6692a555"},
43 |   "ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
44 |   "rustler": {:hex, :rustler, "0.29.0", "46b7792dfecfd8aab323d1bbf417086b67f1d394733a7e67808b20cd2d455a36", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "3fec912e623c111745dcc768e28784dfba6aabae13d0d41f1f07bbd8a52a957a"},
45 |   "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
46 |   "swoosh": {:hex, :swoosh, "1.11.2", "39dd1e44f75bc03a34366d5f830599d248de2b9caaf05704dc76c0507a58c6a1", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "4c43f4591503e7d5bf028314af8ac7c06d1c4d340aa23faeefabfa2543fa726e"},
47 |   "telemetry": {:hex, :telemetry, "0.4.3", "a06428a514bdbc63293cd9a6263aad00ddeb66f608163bdec7c8995784080818", [:rebar3], [], "hexpm", "eb72b8365ffda5bed68a620d1da88525e326cb82a75ee61354fc24b844768041"},
48 |   "telemetry_metrics": {:hex, :telemetry_metrics, "0.6.1", "315d9163a1d4660aedc3fee73f33f1d355dcc76c5c3ab3d59e76e3edf80eef1f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7be9e0871c41732c233be71e4be11b96e56177bf15dde64a8ac9ce72ac9834c6"},
49 |   "telemetry_poller": {:hex, :telemetry_poller, "0.5.1", "21071cc2e536810bac5628b935521ff3e28f0303e770951158c73eaaa01e962a", [:rebar3], [{:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "4cab72069210bc6e7a080cec9afffad1b33370149ed5d379b81c7c5f0c663fd4"},
50 |   "toml": {:hex, :toml, "0.7.0", "fbcd773caa937d0c7a02c301a1feea25612720ac3fa1ccb8bfd9d30d822911de", [:mix], [], "hexpm", "0690246a2478c1defd100b0c9b89b4ea280a22be9a7b313a8a058a2408a2fa70"},
51 |   "unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
52 | }
53 | 


--------------------------------------------------------------------------------