From a52f049a29b3dc3f79b7b62defa24d03cd87edec Mon Sep 17 00:00:00 2001 From: Haim Kortovich Date: Thu, 5 Mar 2026 11:30:08 -0500 Subject: [PATCH] wip --- .envrc | 1 + .formatter.exs | 5 + .gitignore | 27 ++ AGENTS.md | 111 +++++++ README.md | 18 + config/config.exs | 48 +++ config/dev.exs | 75 +++++ config/prod.exs | 17 + config/runtime.exs | 102 ++++++ config/test.exs | 37 +++ docker-compose.yml | 22 ++ flake.lock | 60 ++++ flake.nix | 25 ++ lib/policy_service.ex | 9 + .../aggregates/car_policy_application.ex | 309 ++++++++++++++++++ lib/policy_service/application.ex | 33 ++ lib/policy_service/commanded_app.ex | 23 ++ lib/policy_service/commands/car.ex | 39 +++ lib/policy_service/common/car_info.ex | 16 + lib/policy_service/common/client_info.ex | 6 + lib/policy_service/event_store.ex | 3 + lib/policy_service/events/car.ex | 69 ++++ .../handlers/quote_request_handler.ex | 21 ++ lib/policy_service/message_bus.ex | 22 ++ lib/policy_service/repo.ex | 13 + lib/policy_service_web.ex | 63 ++++ lib/policy_service_web/api_spec.ex | 24 ++ .../controllers/car_policy_controller.ex | 85 +++++ .../controllers/error_json.ex | 21 ++ lib/policy_service_web/endpoint.ex | 49 +++ lib/policy_service_web/router.ex | 26 ++ lib/policy_service_web/schemas/car_policy.ex | 114 +++++++ lib/policy_service_web/telemetry.ex | 93 ++++++ mix.exs | 75 +++++ mix.lock | 46 +++ priv/repo/migrations/.formatter.exs | 4 + priv/repo/seeds.exs | 11 + priv/static/favicon.ico | Bin 0 -> 152 bytes priv/static/robots.txt | 5 + rabbitmq/definitions.json | 91 ++++++ rabbitmq/rabbitmq.conf | 2 + test/policy_service_test.exs | 8 + .../controllers/error_json_test.exs | 12 + test/support/conn_case.ex | 38 +++ test/support/data_case.ex | 58 ++++ test/test_helper.exs | 2 + 46 files changed, 1938 insertions(+) create mode 100644 .envrc create mode 100644 .formatter.exs create mode 100644 .gitignore create mode 100644 AGENTS.md create mode 100644 README.md create mode 100644 config/config.exs create mode 100644 config/dev.exs create mode 100644 config/prod.exs create mode 100644 config/runtime.exs create mode 100644 config/test.exs create mode 100644 docker-compose.yml create mode 100644 flake.lock create mode 100644 flake.nix create mode 100644 lib/policy_service.ex create mode 100644 lib/policy_service/aggregates/car_policy_application.ex create mode 100644 lib/policy_service/application.ex create mode 100644 lib/policy_service/commanded_app.ex create mode 100644 lib/policy_service/commands/car.ex create mode 100644 lib/policy_service/common/car_info.ex create mode 100644 lib/policy_service/common/client_info.ex create mode 100644 lib/policy_service/event_store.ex create mode 100644 lib/policy_service/events/car.ex create mode 100644 lib/policy_service/handlers/quote_request_handler.ex create mode 100644 lib/policy_service/message_bus.ex create mode 100644 lib/policy_service/repo.ex create mode 100644 lib/policy_service_web.ex create mode 100644 lib/policy_service_web/api_spec.ex create mode 100644 lib/policy_service_web/controllers/car_policy_controller.ex create mode 100644 lib/policy_service_web/controllers/error_json.ex create mode 100644 lib/policy_service_web/endpoint.ex create mode 100644 lib/policy_service_web/router.ex create mode 100644 lib/policy_service_web/schemas/car_policy.ex create mode 100644 lib/policy_service_web/telemetry.ex create mode 100644 mix.exs create mode 100644 mix.lock create mode 100644 priv/repo/migrations/.formatter.exs create mode 100644 priv/repo/seeds.exs create mode 100644 priv/static/favicon.ico create mode 100644 priv/static/robots.txt create mode 100644 rabbitmq/definitions.json create mode 100644 rabbitmq/rabbitmq.conf create mode 100644 test/policy_service_test.exs create mode 100644 test/policy_service_web/controllers/error_json_test.exs create mode 100644 test/support/conn_case.ex create mode 100644 test/support/data_case.ex create mode 100644 test/test_helper.exs diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3550a30 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake diff --git a/.formatter.exs b/.formatter.exs new file mode 100644 index 0000000..5971023 --- /dev/null +++ b/.formatter.exs @@ -0,0 +1,5 @@ +[ + import_deps: [:ecto, :ecto_sql, :phoenix], + subdirectories: ["priv/*/migrations"], + inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}", "priv/*/seeds.exs"] +] diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..83bb19e --- /dev/null +++ b/.gitignore @@ -0,0 +1,27 @@ +# The directory Mix will write compiled artifacts to. +/_build/ + +# If you run "mix test --cover", coverage assets end up here. +/cover/ + +# The directory Mix downloads your dependencies sources to. +/deps/ + +# Where 3rd-party dependencies like ExDoc output generated docs. +/doc/ + +# Ignore .fetch files in case you like to edit your project deps locally. +/.fetch + +# If the VM crashes, it generates a dump, let's ignore it too. +erl_crash.dump + +# Also ignore archive artifacts (built via "mix archive.build"). +*.ez + +# Temporary files, for example, from tests. +/tmp/ + +# Ignore package tarball (built via "mix hex.build"). +policy_service-*.tar + diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..a51acdd --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,111 @@ +This is a web application written using the Phoenix web framework. + +## Project guidelines + +- Use `mix precommit` alias when you are done with all changes and fix any pending issues +- Use the already included and available `:req` (`Req`) library for HTTP requests, **avoid** `:httpoison`, `:tesla`, and `:httpc`. Req is included by default and is the preferred HTTP client for Phoenix apps + +### Phoenix v1.8 guidelines + +- **Always** begin your LiveView templates with `` which wraps all inner content +- The `MyAppWeb.Layouts` module is aliased in the `my_app_web.ex` file, so you can use it without needing to alias it again +- Anytime you run into errors with no `current_scope` assign: + - You failed to follow the Authenticated Routes guidelines, or you failed to pass `current_scope` to `` + - **Always** fix the `current_scope` error by moving your routes to the proper `live_session` and ensure you pass `current_scope` as needed +- Phoenix v1.8 moved the `<.flash_group>` component to the `Layouts` module. You are **forbidden** from calling `<.flash_group>` outside of the `layouts.ex` module +- Out of the box, `core_components.ex` imports an `<.icon name="hero-x-mark" class="w-5 h-5"/>` component for for hero icons. **Always** use the `<.icon>` component for icons, **never** use `Heroicons` modules or similar +- **Always** use the imported `<.input>` component for form inputs from `core_components.ex` when available. `<.input>` is imported and using it will save steps and prevent errors +- If you override the default input classes (`<.input class="myclass px-2 py-1 rounded-lg">)`) class with your own values, no default classes are inherited, so your +custom classes must fully style the input + + + + + +## Elixir guidelines + +- Elixir lists **do not support index based access via the access syntax** + + **Never do this (invalid)**: + + i = 0 + mylist = ["blue", "green"] + mylist[i] + + Instead, **always** use `Enum.at`, pattern matching, or `List` for index based list access, ie: + + i = 0 + mylist = ["blue", "green"] + Enum.at(mylist, i) + +- Elixir variables are immutable, but can be rebound, so for block expressions like `if`, `case`, `cond`, etc + you *must* bind the result of the expression to a variable if you want to use it and you CANNOT rebind the result inside the expression, ie: + + # INVALID: we are rebinding inside the `if` and the result never gets assigned + if connected?(socket) do + socket = assign(socket, :val, val) + end + + # VALID: we rebind the result of the `if` to a new variable + socket = + if connected?(socket) do + assign(socket, :val, val) + end + +- **Never** nest multiple modules in the same file as it can cause cyclic dependencies and compilation errors +- **Never** use map access syntax (`changeset[:field]`) on structs as they do not implement the Access behaviour by default. For regular structs, you **must** access the fields directly, such as `my_struct.field` or use higher level APIs that are available on the struct if they exist, `Ecto.Changeset.get_field/2` for changesets +- Elixir's standard library has everything necessary for date and time manipulation. Familiarize yourself with the common `Time`, `Date`, `DateTime`, and `Calendar` interfaces by accessing their documentation as necessary. **Never** install additional dependencies unless asked or for date/time parsing (which you can use the `date_time_parser` package) +- Don't use `String.to_atom/1` on user input (memory leak risk) +- Predicate function names should not start with `is_` and should end in a question mark. Names like `is_thing` should be reserved for guards +- Elixir's builtin OTP primitives like `DynamicSupervisor` and `Registry`, require names in the child spec, such as `{DynamicSupervisor, name: MyApp.MyDynamicSup}`, then you can use `DynamicSupervisor.start_child(MyApp.MyDynamicSup, child_spec)` +- Use `Task.async_stream(collection, callback, options)` for concurrent enumeration with back-pressure. The majority of times you will want to pass `timeout: :infinity` as option + +## Mix guidelines + +- Read the docs and options before using tasks (by using `mix help task_name`) +- To debug test failures, run tests in a specific file with `mix test test/my_test.exs` or run all previously failed tests with `mix test --failed` +- `mix deps.clean --all` is **almost never needed**. **Avoid** using it unless you have good reason + +## Test guidelines + +- **Always use `start_supervised!/1`** to start processes in tests as it guarantees cleanup between tests +- **Avoid** `Process.sleep/1` and `Process.alive?/1` in tests + - Instead of sleeping to wait for a process to finish, **always** use `Process.monitor/1` and assert on the DOWN message: + + ref = Process.monitor(pid) + assert_receive {:DOWN, ^ref, :process, ^pid, :normal} + + - Instead of sleeping to synchronize before the next call, **always** use `_ = :sys.get_state/1` to ensure the process has handled prior messages + + + +## Phoenix guidelines + +- Remember Phoenix router `scope` blocks include an optional alias which is prefixed for all routes within the scope. **Always** be mindful of this when creating routes within a scope to avoid duplicate module prefixes. + +- You **never** need to create your own `alias` for route definitions! The `scope` provides the alias, ie: + + scope "/admin", AppWeb.Admin do + pipe_through :browser + + live "/users", UserLive, :index + end + + the UserLive route would point to the `AppWeb.Admin.UserLive` module + +- `Phoenix.View` no longer is needed or included with Phoenix, don't use it + + + +## Ecto Guidelines + +- **Always** preload Ecto associations in queries when they'll be accessed in templates, ie a message that needs to reference the `message.user.email` +- Remember `import Ecto.Query` and other supporting modules when you write `seeds.exs` +- `Ecto.Schema` fields always use the `:string` type, even for `:text`, columns, ie: `field :name, :string` +- `Ecto.Changeset.validate_number/2` **DOES NOT SUPPORT the `:allow_nil` option**. By default, Ecto validations only run if a change for the given field exists and the change value is not nil, so such as option is never needed +- You **must** use `Ecto.Changeset.get_field(changeset, :field)` to access changeset fields +- Fields which are set programatically, such as `user_id`, must not be listed in `cast` calls or similar for security purposes. Instead they must be explicitly set when creating the struct +- **Always** invoke `mix ecto.gen.migration migration_name_using_underscores` when generating migration files, so the correct timestamp and conventions are applied + + + \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..9295505 --- /dev/null +++ b/README.md @@ -0,0 +1,18 @@ +# PolicyService + +To start your Phoenix server: + +* Run `mix setup` to install and setup dependencies +* Start Phoenix endpoint with `mix phx.server` or inside IEx with `iex -S mix phx.server` + +Now you can visit [`localhost:4000`](http://localhost:4000) from your browser. + +Ready to run in production? Please [check our deployment guides](https://hexdocs.pm/phoenix/deployment.html). + +## Learn more + +* Official website: https://www.phoenixframework.org/ +* Guides: https://hexdocs.pm/phoenix/overview.html +* Docs: https://hexdocs.pm/phoenix +* Forum: https://elixirforum.com/c/phoenix-forum +* Source: https://github.com/phoenixframework/phoenix diff --git a/config/config.exs b/config/config.exs new file mode 100644 index 0000000..db10f68 --- /dev/null +++ b/config/config.exs @@ -0,0 +1,48 @@ +# This file is responsible for configuring your application +# and its dependencies with the aid of the Config module. +# +# This configuration file is loaded before any dependency and +# is restricted to this project. + +# General application configuration +import Config + +config :policy_service, + ecto_repos: [PolicyService.Repo], + event_stores: [PolicyService.EventStore] + +config :policy_service, PolicyServiceWeb.Endpoint, + url: [host: "localhost"], + adapter: Bandit.PhoenixAdapter, + render_errors: [ + formats: [json: PolicyServiceWeb.ErrorJSON], + layout: false + ], + pubsub_server: PolicyService.PubSub, + live_view: [signing_salt: "zPStCmh9"] + +# Configure Elixir's Logger +config :logger, :default_formatter, + format: "$time $metadata[$level] $message\n", + metadata: [:request_id] + +# Use Jason for JSON parsing in Phoenix +config :phoenix, :json_library, Jason + +config :policy_service, PolicyService.CommandedApp, + event_store: [ + adapter: Commanded.EventStore.Adapters.EventStore, + event_store: PolicyService.EventStore + ], + pub_sub: :local, + registry: :local + +config :commanded, + event_store_adapter: Commanded.EventStore.Adapters.EventStore + +config :commanded_ecto_projections, + repo: PolicyService.Repo + +# Import environment specific config. This must remain at the bottom +# of this file so it overrides the configuration defined above. +import_config "#{config_env()}.exs" diff --git a/config/dev.exs b/config/dev.exs new file mode 100644 index 0000000..fc6d18a --- /dev/null +++ b/config/dev.exs @@ -0,0 +1,75 @@ +import Config + +config :policy_service, amqp_url: "amqp://guest:guest@localhost:5672" + +config :policy_service, PolicyService.EventStore, + serializer: Commanded.Serialization.JsonSerializer, + username: "postgres", + password: "postgres", + database: "policy_service_eventstore_dev", + hostname: "localhost", + pool_size: 10 + +# Configure your database +config :policy_service, PolicyService.Repo, + username: "postgres", + password: "postgres", + hostname: "localhost", + database: "policy_service_dev", + stacktrace: true, + show_sensitive_data_on_connection_error: true, + pool_size: 10 + +# For development, we disable any cache and enable +# debugging and code reloading. +# +# The watchers configuration can be used to run external +# watchers to your application. For example, we can use it +# to bundle .js and .css sources. +config :policy_service, PolicyServiceWeb.Endpoint, + # Binding to loopback ipv4 address prevents access from other machines. + # Change to `ip: {0, 0, 0, 0}` to allow access from other machines. + http: [ip: {127, 0, 0, 1}], + check_origin: false, + code_reloader: true, + debug_errors: true, + secret_key_base: "rSPVNB6DCC2RMMlmk9QkCVGAzasUD6AWh5ussctvNuUxgZL9DRnFXTo6jcIz6JpB", + watchers: [] + +# ## SSL Support +# +# In order to use HTTPS in development, a self-signed +# certificate can be generated by running the following +# Mix task: +# +# mix phx.gen.cert +# +# Run `mix help phx.gen.cert` for more information. +# +# The `http:` config above can be replaced with: +# +# https: [ +# port: 4001, +# cipher_suite: :strong, +# keyfile: "priv/cert/selfsigned_key.pem", +# certfile: "priv/cert/selfsigned.pem" +# ], +# +# If desired, both `http:` and `https:` keys can be +# configured to run both http and https servers on +# different ports. + +# Enable dev routes for dashboard and mailbox +config :policy_service, dev_routes: true + +# Do not include metadata nor timestamps in development logs +config :logger, :default_formatter, format: "[$level] $message\n" + +# Set a higher stacktrace during development. Avoid configuring such +# in production as building large stacktraces may be expensive. +config :phoenix, :stacktrace_depth, 20 + +# Initialize plugs at runtime for faster development compilation +config :phoenix, :plug_init_mode, :runtime + +config :open_api_spex, :cache_adapter, OpenApiSpex.Plug.NoneCache diff --git a/config/prod.exs b/config/prod.exs new file mode 100644 index 0000000..65e9d66 --- /dev/null +++ b/config/prod.exs @@ -0,0 +1,17 @@ +import Config + +# Force using SSL in production. This also sets the "strict-security-transport" header, +# known as HSTS. If you have a health check endpoint, you may want to exclude it below. +# Note `:force_ssl` is required to be set at compile-time. +config :policy_service, PolicyServiceWeb.Endpoint, + force_ssl: [rewrite_on: [:x_forwarded_proto]], + exclude: [ + # paths: ["/health"], + hosts: ["localhost", "127.0.0.1"] + ] + +# Do not print debug messages in production +config :logger, level: :info + +# Runtime production configuration, including reading +# of environment variables, is done on config/runtime.exs. diff --git a/config/runtime.exs b/config/runtime.exs new file mode 100644 index 0000000..b40e1fb --- /dev/null +++ b/config/runtime.exs @@ -0,0 +1,102 @@ +import Config + +# config/runtime.exs is executed for all environments, including +# during releases. It is executed after compilation and before the +# system starts, so it is typically used to load production configuration +# and secrets from environment variables or elsewhere. Do not define +# any compile-time configuration in here, as it won't be applied. +# The block below contains prod specific runtime configuration. + +# ## Using releases +# +# If you use `mix release`, you need to explicitly enable the server +# by passing the PHX_SERVER=true when you start it: +# +# PHX_SERVER=true bin/policy_service start +# +# Alternatively, you can use `mix phx.gen.release` to generate a `bin/server` +# script that automatically sets the env var above. +if System.get_env("PHX_SERVER") do + config :policy_service, PolicyServiceWeb.Endpoint, server: true +end + +config :policy_service, PolicyServiceWeb.Endpoint, + http: [port: String.to_integer(System.get_env("PORT", "4000"))] + +if config_env() == :prod do + database_url = + System.get_env("DATABASE_URL") || + raise """ + environment variable DATABASE_URL is missing. + For example: ecto://USER:PASS@HOST/DATABASE + """ + + maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: [] + + config :policy_service, PolicyService.Repo, + # ssl: true, + url: database_url, + pool_size: String.to_integer(System.get_env("POOL_SIZE") || "10"), + # For machines with several cores, consider starting multiple pools of `pool_size` + # pool_count: 4, + socket_options: maybe_ipv6 + + # The secret key base is used to sign/encrypt cookies and other secrets. + # A default value is used in config/dev.exs and config/test.exs but you + # want to use a different value for prod and you most likely don't want + # to check this value into version control, so we use an environment + # variable instead. + secret_key_base = + System.get_env("SECRET_KEY_BASE") || + raise """ + environment variable SECRET_KEY_BASE is missing. + You can generate one by calling: mix phx.gen.secret + """ + + host = System.get_env("PHX_HOST") || "example.com" + + config :policy_service, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY") + + config :policy_service, PolicyServiceWeb.Endpoint, + url: [host: host, port: 443, scheme: "https"], + http: [ + # Enable IPv6 and bind on all interfaces. + # Set it to {0, 0, 0, 0, 0, 0, 0, 1} for local network only access. + # See the documentation on https://hexdocs.pm/bandit/Bandit.html#t:options/0 + # for details about using IPv6 vs IPv4 and loopback vs public addresses. + ip: {0, 0, 0, 0, 0, 0, 0, 0} + ], + secret_key_base: secret_key_base + + # ## SSL Support + # + # To get SSL working, you will need to add the `https` key + # to your endpoint configuration: + # + # config :policy_service, PolicyServiceWeb.Endpoint, + # https: [ + # ..., + # port: 443, + # cipher_suite: :strong, + # keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"), + # certfile: System.get_env("SOME_APP_SSL_CERT_PATH") + # ] + # + # The `cipher_suite` is set to `:strong` to support only the + # latest and more secure SSL ciphers. This means old browsers + # and clients may not be supported. You can set it to + # `:compatible` for wider support. + # + # `:keyfile` and `:certfile` expect an absolute path to the key + # and cert in disk or a relative path inside priv, for example + # "priv/ssl/server.key". For all supported SSL configuration + # options, see https://hexdocs.pm/plug/Plug.SSL.html#configure/1 + # + # We also recommend setting `force_ssl` in your config/prod.exs, + # ensuring no data is ever sent via http, always redirecting to https: + # + # config :policy_service, PolicyServiceWeb.Endpoint, + # force_ssl: [hsts: true] + # + # Check `Plug.SSL` for all available options in `force_ssl`. +end diff --git a/config/test.exs b/config/test.exs new file mode 100644 index 0000000..f2f644a --- /dev/null +++ b/config/test.exs @@ -0,0 +1,37 @@ +import Config + +# Configure your database +# +# The MIX_TEST_PARTITION environment variable can be used +# to provide built-in test partitioning in CI environment. +# Run `mix help test` for more information. +config :policy_service, PolicyService.Repo, + username: "postgres", + password: "postgres", + hostname: "localhost", + database: "policy_service_test#{System.get_env("MIX_TEST_PARTITION")}", + pool: Ecto.Adapters.SQL.Sandbox, + pool_size: System.schedulers_online() * 2 + +# We don't run a server during test. If one is required, +# you can enable the server option below. +config :policy_service, PolicyServiceWeb.Endpoint, + http: [ip: {127, 0, 0, 1}, port: 4002], + secret_key_base: "mf3rysPsftCpSAdQfBIFEKFpjA1e9tGi9+jbxhNTs5qC3pC9LSn6P/kWlZatl9a0", + server: false + +# Print only warnings and errors during test +config :logger, level: :warning + +# Initialize plugs at runtime for faster test compilation +config :phoenix, :plug_init_mode, :runtime + +# Sort query params output of verified routes for robust url comparisons +config :phoenix, + sort_verified_routes_query_params: true + +config :policy_service, PolicyService.Application, + event_store: [ + adapter: Commanded.EventStore.Adapters.InMemory, + serializer: Commanded.Serialization.JsonSerializer + ] diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..221a29e --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,22 @@ +services: + rabbitmq: + image: rabbitmq:3.13-management + container_name: policy_service_rabbitmq + ports: + - "5672:5672" # AMQP + - "15672:15672" # Management UI + environment: + RABBITMQ_DEFAULT_USER: guest + RABBITMQ_DEFAULT_PASS: guest + volumes: + - rabbitmq_data:/var/lib/rabbitmq + - ./rabbitmq/definitions.json:/etc/rabbitmq/definitions.json + - ./rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf + healthcheck: + test: ["CMD", "rabbitmq-diagnostics", "ping"] + interval: 10s + timeout: 5s + retries: 5 + +volumes: + rabbitmq_data: diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..05379bc --- /dev/null +++ b/flake.lock @@ -0,0 +1,60 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1770827874, + "narHash": "sha256-c46lN+QyhURJIGO2ZjpEHGjhAcQCEn+L0Er219ridNs=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "f4a37e804018a73d81c2bdc2643a64c944b57d92", + "type": "github" + }, + "original": { + "owner": "nixos", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..1f49a87 --- /dev/null +++ b/flake.nix @@ -0,0 +1,25 @@ +{ + description = "test"; + + inputs = { + nixpkgs.url = "github:nixos/nixpkgs"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { self, nixpkgs, flake-utils, ... }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = nixpkgs.legacyPackages.${system}; + + in { + devShell = + pkgs.mkShell { + buildInputs = with pkgs; + [ + elixir + elixir-ls + git + ]; + }; + }); +} diff --git a/lib/policy_service.ex b/lib/policy_service.ex new file mode 100644 index 0000000..593b56d --- /dev/null +++ b/lib/policy_service.ex @@ -0,0 +1,9 @@ +defmodule PolicyService do + @moduledoc """ + PolicyService keeps the contexts that define your domain + and business logic. + + Contexts are also responsible for managing your data, regardless + if it comes from the database, an external API or others. + """ +end diff --git a/lib/policy_service/aggregates/car_policy_application.ex b/lib/policy_service/aggregates/car_policy_application.ex new file mode 100644 index 0000000..e7024a6 --- /dev/null +++ b/lib/policy_service/aggregates/car_policy_application.ex @@ -0,0 +1,309 @@ +defmodule PolicyService.Aggregates.CarPolicyApplication do + @moduledoc """ + Aggregate for managing car insurance policy applications. + + Lifecycle: + nil → :awaiting_quotes → :solicitation_sent → :issued + """ + + defstruct [ + :application_id, + :org_id, + :submitted_by, + :applicant_info, + :car_details, + :selected_providers, + :quotes, + :accepted_quote_id, + :accepted_provider_id, + :policy_number, + :state + ] + + alias PolicyService.Commands.Car.{ + SubmitCarPolicyApplication, + RecordCarProviderQuote, + AcceptCarQuoteAndSolicit, + RecordCarPolicyIssued + } + + alias PolicyService.Events.Car.{ + CarPolicyApplicationSubmitted, + CarProviderQuoteReceived, + AllCarQuotesReceived, + CarQuoteAccepted, + CarSolicitationSent, + CarPolicyIssued, + CarQuoteRequestSent + } + + # --------------------------------------------------------------------------- + # Submit — establishes org ownership + # --------------------------------------------------------------------------- + + def execute(%__MODULE__{state: nil}, %SubmitCarPolicyApplication{} = cmd) do + with :ok <- validate_org(cmd.org_id), + :ok <- validate_user(cmd.submitted_by), + :ok <- validate_applicant(cmd.applicant_info), + :ok <- validate_car_details(cmd.car_details), + :ok <- validate_providers(cmd.selected_providers) do + quote_requests = + Enum.map(cmd.selected_providers, fn provider -> + %CarQuoteRequestSent{ + application_id: cmd.application_id, + org_id: cmd.org_id, + provider_id: provider.id, + provider_email: provider.email, + applicant_info: cmd.applicant_info, + car_details: cmd.car_details, + requested_at: DateTime.utc_now() + } + end) + + [ + %CarPolicyApplicationSubmitted{ + application_id: cmd.application_id, + org_id: cmd.org_id, + submitted_by: cmd.submitted_by, + applicant_info: cmd.applicant_info, + car_details: cmd.car_details, + selected_providers: cmd.selected_providers, + submitted_at: DateTime.utc_now() + } + | quote_requests + ] + end + end + + def execute(%__MODULE__{state: state}, %SubmitCarPolicyApplication{}) do + {:error, {:invalid_state, "cannot submit in state: #{state}"}} + end + + # --------------------------------------------------------------------------- + # Record provider quote — external webhook, verify org + # --------------------------------------------------------------------------- + + def execute(%__MODULE__{state: :awaiting_quotes} = agg, %RecordCarProviderQuote{} = cmd) do + with :ok <- verify_org(agg, cmd) do + if Map.has_key?(agg.quotes, cmd.provider_id) do + {:error, {:duplicate_quote, "quote from provider #{cmd.provider_id} already received"}} + else + quote_event = %CarProviderQuoteReceived{ + application_id: cmd.application_id, + org_id: agg.org_id, + recorded_by: cmd.recorded_by, + provider_id: cmd.provider_id, + quote_id: cmd.quote_id, + premium: cmd.premium, + coverage_details: cmd.coverage_details, + valid_until: cmd.valid_until, + received_at: DateTime.utc_now() + } + + new_quote_count = map_size(agg.quotes) + 1 + + if new_quote_count == length(agg.selected_providers) do + [ + quote_event, + %AllCarQuotesReceived{ + application_id: cmd.application_id, + org_id: agg.org_id, + quote_count: new_quote_count + } + ] + else + quote_event + end + end + end + end + + def execute(%__MODULE__{state: state}, %RecordCarProviderQuote{}) do + {:error, {:invalid_state, "cannot record quote in state: #{state}"}} + end + + # --------------------------------------------------------------------------- + # Accept quote and solicit — internal user action, verify org + # --------------------------------------------------------------------------- + + def execute(%__MODULE__{state: :awaiting_quotes} = agg, %AcceptCarQuoteAndSolicit{} = cmd) do + with :ok <- verify_org(agg, cmd) do + case find_quote(agg.quotes, cmd.quote_id) do + nil -> + {:error, {:quote_not_found, "quote #{cmd.quote_id} not found"}} + + {provider_id, _quote} -> + [ + %CarQuoteAccepted{ + application_id: cmd.application_id, + org_id: agg.org_id, + accepted_by: cmd.accepted_by, + quote_id: cmd.quote_id, + provider_id: provider_id, + accepted_at: DateTime.utc_now() + }, + %CarSolicitationSent{ + application_id: cmd.application_id, + org_id: agg.org_id, + provider_id: provider_id, + quote_id: cmd.quote_id, + sent_at: DateTime.utc_now() + } + ] + end + end + end + + def execute(%__MODULE__{state: state}, %AcceptCarQuoteAndSolicit{}) do + {:error, {:invalid_state, "cannot accept quote in state: #{state}"}} + end + + # --------------------------------------------------------------------------- + # Record policy issued — external or internal, verify org + # --------------------------------------------------------------------------- + + def execute(%__MODULE__{state: :solicitation_sent} = agg, %RecordCarPolicyIssued{} = cmd) do + with :ok <- verify_org(agg, cmd) do + if cmd.provider_id != agg.accepted_provider_id do + {:error, {:provider_mismatch, "policy issued by unexpected provider"}} + else + %CarPolicyIssued{ + application_id: cmd.application_id, + org_id: agg.org_id, + recorded_by: cmd.recorded_by, + policy_number: cmd.policy_number, + provider_id: cmd.provider_id, + effective_date: cmd.effective_date, + expiry_date: cmd.expiry_date, + issued_at: DateTime.utc_now() + } + end + end + end + + def execute(%__MODULE__{state: state}, %RecordCarPolicyIssued{}) do + {:error, {:invalid_state, "cannot record policy in state: #{state}"}} + end + + # --------------------------------------------------------------------------- + # Apply events + # --------------------------------------------------------------------------- + + def apply(%__MODULE__{} = agg, %CarPolicyApplicationSubmitted{} = e) do + %__MODULE__{ + agg + | application_id: e.application_id, + org_id: e.org_id, + submitted_by: e.submitted_by, + applicant_info: e.applicant_info, + car_details: e.car_details, + selected_providers: e.selected_providers, + quotes: %{}, + state: :awaiting_quotes + } + end + + def apply(%__MODULE__{} = agg, %CarQuoteRequestSent{}), do: agg + + def apply(%__MODULE__{} = agg, %CarProviderQuoteReceived{} = e) do + quote_data = %{ + quote_id: e.quote_id, + premium: e.premium, + coverage_details: e.coverage_details, + valid_until: e.valid_until + } + + %__MODULE__{agg | quotes: Map.put(agg.quotes, e.provider_id, quote_data)} + end + + def apply(%__MODULE__{} = agg, %AllCarQuotesReceived{}), do: agg + + def apply(%__MODULE__{} = agg, %CarQuoteAccepted{} = e) do + %__MODULE__{agg | accepted_quote_id: e.quote_id, accepted_provider_id: e.provider_id} + end + + def apply(%__MODULE__{} = agg, %CarSolicitationSent{}) do + %__MODULE__{agg | state: :solicitation_sent} + end + + def apply(%__MODULE__{} = agg, %CarPolicyIssued{} = e) do + %__MODULE__{agg | policy_number: e.policy_number, state: :issued} + end + + # --------------------------------------------------------------------------- + # Private helpers + # --------------------------------------------------------------------------- + + defp verify_org(%__MODULE__{org_id: org_id}, %{org_id: cmd_org_id}) do + if org_id == cmd_org_id, + do: :ok, + else: {:error, :org_mismatch} + end + + defp validate_org(org_id) when is_binary(org_id) and byte_size(org_id) > 0, do: :ok + defp validate_org(_), do: {:error, :missing_org_id} + + defp validate_user(user_id) when is_binary(user_id) and byte_size(user_id) > 0, do: :ok + defp validate_user(_), do: {:error, :missing_user_id} + + defp validate_applicant(%{name: name, date_of_birth: dob, document_id: doc}) + when is_binary(name) and is_binary(doc), + do: :ok + + defp validate_applicant(_), do: {:error, :invalid_applicant_info} + + @valid_use_types ~w(private commercial bus taxi school)a + @valid_car_types ~w(sedan suv hatchback coupe convertible pickup van minivan truck)a + + defp validate_car_details(%{ + plate: plate, + make: make, + model: model, + year: year, + car_value: car_value, + use_type: use_type, + car_type: car_type, + chassis_number: chassis_number, + engine_number: engine_number + }) + when is_binary(plate) and is_binary(make) and is_binary(model) and + is_integer(year) and is_number(car_value) and car_value > 0 and + is_binary(chassis_number) and is_binary(engine_number) do + current_year = Date.utc_today().year + + cond do + year < 1886 -> + {:error, :invalid_car_year} + + year > current_year + 1 -> + {:error, :invalid_car_year} + + use_type not in @valid_use_types -> + {:error, {:invalid_use_type, "must be one of: #{inspect(@valid_use_types)}"}} + + car_type not in @valid_car_types -> + {:error, {:invalid_car_type, "must be one of: #{inspect(@valid_car_types)}"}} + + byte_size(chassis_number) == 0 -> + {:error, :missing_chassis_number} + + byte_size(engine_number) == 0 -> + {:error, :missing_engine_number} + + true -> + :ok + end + end + + defp validate_car_details(_), do: {:error, :invalid_car_details} + + defp validate_providers(providers) + when is_list(providers) and length(providers) > 0, + do: :ok + + defp validate_providers(_), do: {:error, :no_providers_selected} + + defp find_quote(quotes, quote_id) do + Enum.find(quotes, fn {_provider_id, q} -> q.quote_id == quote_id end) + end +end diff --git a/lib/policy_service/application.ex b/lib/policy_service/application.ex new file mode 100644 index 0000000..ca09b57 --- /dev/null +++ b/lib/policy_service/application.ex @@ -0,0 +1,33 @@ +defmodule PolicyService.Application do + # See https://hexdocs.pm/elixir/Application.html + # for more information on OTP Applications + @moduledoc false + + use Application + + @impl true + def start(_type, _args) do + children = [ + PolicyService.CommandedApp, + PolicyService.Handlers.QuoteRequestHandler, + PolicyServiceWeb.Telemetry, + PolicyService.Repo, + {DNSCluster, query: Application.get_env(:policy_service, :dns_cluster_query) || :ignore}, + {Phoenix.PubSub, name: PolicyService.PubSub}, + PolicyServiceWeb.Endpoint + ] + + # See https://hexdocs.pm/elixir/Supervisor.html + # for other strategies and supported options + opts = [strategy: :one_for_one, name: PolicyService.Supervisor] + Supervisor.start_link(children, opts) + end + + # Tell Phoenix to update the endpoint configuration + # whenever the application is updated. + @impl true + def config_change(changed, _new, removed) do + PolicyServiceWeb.Endpoint.config_change(changed, removed) + :ok + end +end diff --git a/lib/policy_service/commanded_app.ex b/lib/policy_service/commanded_app.ex new file mode 100644 index 0000000..302005e --- /dev/null +++ b/lib/policy_service/commanded_app.ex @@ -0,0 +1,23 @@ +defmodule PolicyService.Router do + use Commanded.Commands.Router + alias PolicyService.Commands.Car + alias PolicyService.Aggregates + + dispatch( + [ + Car.SubmitCarPolicyApplication, + Car.RecordCarProviderQuote, + Car.AcceptCarQuoteAndSolicit, + Car.RecordCarPolicyIssued + ], + to: PolicyService.Aggregates.CarPolicyApplication, + identity: :application_id + ) +end + +defmodule PolicyService.CommandedApp do + use Commanded.Application, + otp_app: :policy_service + + router(PolicyService.Router) +end diff --git a/lib/policy_service/commands/car.ex b/lib/policy_service/commands/car.ex new file mode 100644 index 0000000..789a939 --- /dev/null +++ b/lib/policy_service/commands/car.ex @@ -0,0 +1,39 @@ +defmodule PolicyService.Commands.Car.SubmitCarPolicyApplication do + defstruct [ + :application_id, + :org_id, + :submitted_by, + :applicant_info, + :car_details, + :selected_providers + ] +end + +defmodule PolicyService.Commands.Car.RecordCarProviderQuote do + defstruct [ + :application_id, + :org_id, + :recorded_by, + :provider_id, + :quote_id, + :premium, + :coverage_details, + :valid_until + ] +end + +defmodule PolicyService.Commands.Car.AcceptCarQuoteAndSolicit do + defstruct [:application_id, :org_id, :accepted_by, :quote_id] +end + +defmodule PolicyService.Commands.Car.RecordCarPolicyIssued do + defstruct [ + :application_id, + :org_id, + :recorded_by, + :policy_number, + :provider_id, + :effective_date, + :expiry_date + ] +end diff --git a/lib/policy_service/common/car_info.ex b/lib/policy_service/common/car_info.ex new file mode 100644 index 0000000..187e041 --- /dev/null +++ b/lib/policy_service/common/car_info.ex @@ -0,0 +1,16 @@ +defmodule PolicyService.Common.CarInfo do + use ExConstructor + + @derive Jason.Encoder + defstruct [ + :plate, + :make, + :model, + :year, + :car_value, + :use_type, + :car_type, + :chassis_number, + :engine_number + ] +end diff --git a/lib/policy_service/common/client_info.ex b/lib/policy_service/common/client_info.ex new file mode 100644 index 0000000..915f79b --- /dev/null +++ b/lib/policy_service/common/client_info.ex @@ -0,0 +1,6 @@ +defmodule PolicyService.Common.ClientInfo do + use ExConstructor + + @derive Jason.Encoder + defstruct [:first_name, :last_name, :birth_date, :gender, :email, :phone, :user_id] +end diff --git a/lib/policy_service/event_store.ex b/lib/policy_service/event_store.ex new file mode 100644 index 0000000..7607da1 --- /dev/null +++ b/lib/policy_service/event_store.ex @@ -0,0 +1,3 @@ +defmodule PolicyService.EventStore do + use EventStore, otp_app: :policy_service +end diff --git a/lib/policy_service/events/car.ex b/lib/policy_service/events/car.ex new file mode 100644 index 0000000..6dbff34 --- /dev/null +++ b/lib/policy_service/events/car.ex @@ -0,0 +1,69 @@ +defmodule PolicyService.Events.Car.CarPolicyApplicationSubmitted do + @derive Jason.Encoder + defstruct [ + :application_id, + :org_id, + :submitted_by, + :applicant_info, + :car_details, + :selected_providers, + :submitted_at + ] +end + +defmodule PolicyService.Events.Car.CarQuoteRequestSent do + @derive Jason.Encoder + defstruct [ + :application_id, + :org_id, + :provider_id, + :provider_email, + :applicant_info, + :car_details, + :requested_at + ] +end + +defmodule PolicyService.Events.Car.CarProviderQuoteReceived do + @derive Jason.Encoder + defstruct [ + :application_id, + :org_id, + :recorded_by, + :provider_id, + :quote_id, + :premium, + :coverage_details, + :valid_until, + :received_at + ] +end + +defmodule PolicyService.Events.Car.AllCarQuotesReceived do + @derive Jason.Encoder + defstruct [:application_id, :org_id, :quote_count] +end + +defmodule PolicyService.Events.Car.CarQuoteAccepted do + @derive Jason.Encoder + defstruct [:application_id, :org_id, :accepted_by, :quote_id, :provider_id, :accepted_at] +end + +defmodule PolicyService.Events.Car.CarSolicitationSent do + @derive Jason.Encoder + defstruct [:application_id, :org_id, :provider_id, :quote_id, :sent_at] +end + +defmodule PolicyService.Events.Car.CarPolicyIssued do + @derive Jason.Encoder + defstruct [ + :application_id, + :org_id, + :recorded_by, + :policy_number, + :provider_id, + :effective_date, + :expiry_date, + :issued_at + ] +end diff --git a/lib/policy_service/handlers/quote_request_handler.ex b/lib/policy_service/handlers/quote_request_handler.ex new file mode 100644 index 0000000..7177834 --- /dev/null +++ b/lib/policy_service/handlers/quote_request_handler.ex @@ -0,0 +1,21 @@ +defmodule PolicyService.Handlers.QuoteRequestHandler do + use Commanded.Event.Handler, + application: PolicyService.CommandedApp, + name: __MODULE__ + + alias PolicyService.Events.Car.CarQuoteRequestSent + # alias PolicyService.Events.Life.LifeQuoteRequestSent + # alias PolicyService.Events.Fire.FireQuoteRequestSent + + def handle(%CarQuoteRequestSent{} = e, _metadata) do + PolicyService.MessageBus.publish("carquote.requested", e) + end + + # def handle(%LifeQuoteRequestSent{} = e, _metadata) do + # PolicyService.MessageBus.publish("quote.requested", e) + # end + + # def handle(%FireQuoteRequestSent{} = e, _metadata) do + # PolicyService.MessageBus.publish("quote.requested", e) + # end +end diff --git a/lib/policy_service/message_bus.ex b/lib/policy_service/message_bus.ex new file mode 100644 index 0000000..612bb32 --- /dev/null +++ b/lib/policy_service/message_bus.ex @@ -0,0 +1,22 @@ +defmodule PolicyService.MessageBus do + use AMQP + + def publish(routing_key, event) do + payload = Jason.encode!(event) + + :ok = + AMQP.Basic.publish(channel(), "policy_service.events", routing_key, payload, + content_type: "application/json", + # survives RabbitMQ restart + persistent: true + ) + end + + defp channel do + {:ok, conn} = AMQP.Connection.open(amqp_url()) + {:ok, chan} = AMQP.Channel.open(conn) + chan + end + + defp amqp_url, do: Application.fetch_env!(:policy_service, :amqp_url) +end diff --git a/lib/policy_service/repo.ex b/lib/policy_service/repo.ex new file mode 100644 index 0000000..c7746e4 --- /dev/null +++ b/lib/policy_service/repo.ex @@ -0,0 +1,13 @@ +defmodule PolicyService.Repo do + use Ecto.Repo, + otp_app: :policy_service, + adapter: Ecto.Adapters.Postgres + + @doc """ + Dynamically loads the repository url from the + DATABASE_URL environment variable. + """ + def init(_, opts) do + {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))} + end +end diff --git a/lib/policy_service_web.ex b/lib/policy_service_web.ex new file mode 100644 index 0000000..5e06559 --- /dev/null +++ b/lib/policy_service_web.ex @@ -0,0 +1,63 @@ +defmodule PolicyServiceWeb do + @moduledoc """ + The entrypoint for defining your web interface, such + as controllers, components, channels, and so on. + + This can be used in your application as: + + use PolicyServiceWeb, :controller + use PolicyServiceWeb, :html + + The definitions below will be executed for every controller, + component, etc, so keep them short and clean, focused + on imports, uses and aliases. + + Do NOT define functions inside the quoted expressions + below. Instead, define additional modules and import + those modules here. + """ + + def static_paths, do: ~w(assets fonts images favicon.ico robots.txt) + + def router do + quote do + use Phoenix.Router, helpers: false + + # Import common connection and controller functions to use in pipelines + import Plug.Conn + import Phoenix.Controller + end + end + + def channel do + quote do + use Phoenix.Channel + end + end + + def controller do + quote do + use Phoenix.Controller, formats: [:html, :json] + + import Plug.Conn + + unquote(verified_routes()) + end + end + + def verified_routes do + quote do + use Phoenix.VerifiedRoutes, + endpoint: PolicyServiceWeb.Endpoint, + router: PolicyServiceWeb.Router, + statics: PolicyServiceWeb.static_paths() + end + end + + @doc """ + When used, dispatch to the appropriate controller/live_view/etc. + """ + defmacro __using__(which) when is_atom(which) do + apply(__MODULE__, which, []) + end +end diff --git a/lib/policy_service_web/api_spec.ex b/lib/policy_service_web/api_spec.ex new file mode 100644 index 0000000..039051e --- /dev/null +++ b/lib/policy_service_web/api_spec.ex @@ -0,0 +1,24 @@ +defmodule PolicyServiceWeb.ApiSpec do + alias OpenApiSpex.{OpenApi, Info, Server} + alias OpenApiSpex.{Info, OpenApi, Paths, Server} + alias PolicyServiceWeb.{Endpoint, Router} + @behaviour OpenApi + + @impl OpenApi + def spec do + %OpenApi{ + servers: [ + # Populate the Server info from a phoenix endpoint + Server.from_endpoint(Endpoint) + ], + info: %Info{ + title: "Policy Service", + version: "1.0" + }, + # Populate the paths from a phoenix router + paths: Paths.from_router(Router) + } + # Discover request/response schemas from path specs + |> OpenApiSpex.resolve_schema_modules() + end +end diff --git a/lib/policy_service_web/controllers/car_policy_controller.ex b/lib/policy_service_web/controllers/car_policy_controller.ex new file mode 100644 index 0000000..6d23e12 --- /dev/null +++ b/lib/policy_service_web/controllers/car_policy_controller.ex @@ -0,0 +1,85 @@ +# lib/policy_service_web/controllers/car_policy_controller.ex + +defmodule PolicyServiceWeb.CarPolicyController do + use PolicyServiceWeb, :controller + use OpenApiSpex.ControllerSpecs + + alias OpenApiSpex.Schema + alias PolicyServiceWeb.Schemas.CarPolicy.{QuoteRequest, QuoteResponse} + alias PolicyService.Commands.Car.SubmitCarPolicyApplication + + tags(["Car Policy"]) + security([%{"bearerAuth" => []}]) + + operation(:request_quote, + summary: "Solicitar cotización de seguro de auto", + description: "Envía una solicitud de cotización a los proveedores seleccionados", + request_body: {"Quote request body", "application/json", QuoteRequest, required: true}, + responses: [ + created: {"Solicitud creada exitosamente", "application/json", QuoteResponse}, + unprocessable_entity: + {"Error de validación", "application/json", + %Schema{ + type: :object, + properties: %{ + errors: %Schema{type: :object} + } + }} + ] + ) + + def request_quote(conn, params) do + user = %{"id" => "test", "org_id" => "test"} + + cmd = %SubmitCarPolicyApplication{ + application_id: Ecto.UUID.generate(), + org_id: user["org_id"], + submitted_by: user["id"], + applicant_info: %{ + name: params["applicant_info"]["name"], + date_of_birth: Date.from_iso8601!(params["applicant_info"]["date_of_birth"]), + document_id: params["applicant_info"]["document_id"] + }, + car_details: %{ + plate: params["car_details"]["plate"], + make: params["car_details"]["make"], + model: params["car_details"]["model"], + year: params["car_details"]["year"], + car_value: parse_number(params["car_details"]["car_value"]), + use_type: String.to_atom(params["car_details"]["use_type"]), + car_type: String.to_atom(params["car_details"]["car_type"]), + chassis_number: params["car_details"]["chassis_number"], + engine_number: params["car_details"]["engine_number"] + }, + selected_providers: + Enum.map(params["selected_providers"], fn p -> + %{id: p["id"], email: p["email"]} + end) + } + + case PolicyService.CommandedApp.dispatch(cmd) do + :ok -> + conn + |> put_status(:created) + |> json(%{ + application_id: cmd.applicant_info, + status: "awaiting_quotes" + }) + + {:error, reason} -> + conn + |> put_status(:unprocessable_entity) + |> json(%{errors: reason}) + end + end + + defp parse_number(val) when is_float(val), do: val + defp parse_number(val) when is_integer(val), do: val * 1.0 + + defp parse_number(val) when is_binary(val) do + case Float.parse(val) do + {f, _} -> f + :error -> raise "invalid number: #{val}" + end + end +end diff --git a/lib/policy_service_web/controllers/error_json.ex b/lib/policy_service_web/controllers/error_json.ex new file mode 100644 index 0000000..21a984b --- /dev/null +++ b/lib/policy_service_web/controllers/error_json.ex @@ -0,0 +1,21 @@ +defmodule PolicyServiceWeb.ErrorJSON do + @moduledoc """ + This module is invoked by your endpoint in case of errors on JSON requests. + + See config/config.exs. + """ + + # If you want to customize a particular status code, + # you may add your own clauses, such as: + # + # def render("500.json", _assigns) do + # %{errors: %{detail: "Internal Server Error"}} + # end + + # By default, Phoenix returns the status message from + # the template name. For example, "404.json" becomes + # "Not Found". + def render(template, _assigns) do + %{errors: %{detail: Phoenix.Controller.status_message_from_template(template)}} + end +end diff --git a/lib/policy_service_web/endpoint.ex b/lib/policy_service_web/endpoint.ex new file mode 100644 index 0000000..e21f913 --- /dev/null +++ b/lib/policy_service_web/endpoint.ex @@ -0,0 +1,49 @@ +defmodule PolicyServiceWeb.Endpoint do + use Phoenix.Endpoint, otp_app: :policy_service + + # The session will be stored in the cookie and signed, + # this means its contents can be read but not tampered with. + # Set :encryption_salt if you would also like to encrypt it. + @session_options [ + store: :cookie, + key: "_policy_service_key", + signing_salt: "9eYllgTe", + same_site: "Lax" + ] + + # socket "/live", Phoenix.LiveView.Socket, + # websocket: [connect_info: [session: @session_options]], + # longpoll: [connect_info: [session: @session_options]] + + # Serve at "/" the static files from "priv/static" directory. + # + # When code reloading is disabled (e.g., in production), + # the `gzip` option is enabled to serve compressed + # static files generated by running `phx.digest`. + plug Plug.Static, + at: "/", + from: :policy_service, + gzip: not code_reloading?, + only: PolicyServiceWeb.static_paths(), + raise_on_missing_only: code_reloading? + + # Code reloading can be explicitly enabled under the + # :code_reloader configuration of your endpoint. + if code_reloading? do + plug Phoenix.CodeReloader + plug Phoenix.Ecto.CheckRepoStatus, otp_app: :policy_service + end + + plug Plug.RequestId + plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint] + + plug Plug.Parsers, + parsers: [:urlencoded, :multipart, :json], + pass: ["*/*"], + json_decoder: Phoenix.json_library() + + plug Plug.MethodOverride + plug Plug.Head + plug Plug.Session, @session_options + plug PolicyServiceWeb.Router +end diff --git a/lib/policy_service_web/router.ex b/lib/policy_service_web/router.ex new file mode 100644 index 0000000..d6735e6 --- /dev/null +++ b/lib/policy_service_web/router.ex @@ -0,0 +1,26 @@ +defmodule PolicyServiceWeb.Router do + use PolicyServiceWeb, :router + + pipeline :api do + plug OpenApiSpex.Plug.PutApiSpec, module: PolicyServiceWeb.ApiSpec + end + + scope "/api" do + pipe_through [:api] + + get "/openapi", OpenApiSpex.Plug.RenderSpec, [] + + scope "/v1" do + scope "/car-policies" do + post "/quotes", PolicyServiceWeb.CarPolicyController, :request_quote + end + end + end + + # Swagger UI — only in dev + if Mix.env() == :dev do + scope "/swaggerui" do + get "/", OpenApiSpex.Plug.SwaggerUI, path: "/api/openapi" + end + end +end diff --git a/lib/policy_service_web/schemas/car_policy.ex b/lib/policy_service_web/schemas/car_policy.ex new file mode 100644 index 0000000..d817649 --- /dev/null +++ b/lib/policy_service_web/schemas/car_policy.ex @@ -0,0 +1,114 @@ +defmodule PolicyServiceWeb.Schemas.CarPolicy do + alias OpenApiSpex.Schema + + defmodule ApplicantInfo do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "ApplicantInfo", + type: :object, + required: [:name, :date_of_birth, :document_id], + properties: %{ + name: %Schema{type: :string, example: "Juan Pérez"}, + date_of_birth: %Schema{type: :string, format: :date, example: "1985-06-15"}, + document_id: %Schema{type: :string, example: "V-12345678"} + } + }) + end + + defmodule CarDetails do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "CarDetails", + type: :object, + required: [ + :plate, + :make, + :model, + :year, + :car_value, + :use_type, + :car_type, + :chassis_number, + :engine_number + ], + properties: %{ + plate: %Schema{type: :string, example: "ABC-1234"}, + make: %Schema{type: :string, example: "Toyota"}, + model: %Schema{type: :string, example: "Corolla"}, + year: %Schema{type: :integer, example: 2022}, + car_value: %Schema{type: :number, example: 18000}, + use_type: %Schema{ + type: :string, + enum: ["private", "commercial", "bus", "taxi", "school"], + example: "private" + }, + car_type: %Schema{ + type: :string, + enum: [ + "sedan", + "suv", + "hatchback", + "coupe", + "convertible", + "pickup", + "van", + "minivan", + "truck" + ], + example: "sedan" + }, + chassis_number: %Schema{type: :string, example: "9BWZZZ377VT004251"}, + engine_number: %Schema{type: :string, example: "1NZ-FE-1234567"} + } + }) + end + + defmodule Provider do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "Provider", + type: :object, + required: [:id, :email], + properties: %{ + id: %Schema{type: :string, example: "provider-uuid"}, + email: %Schema{type: :string, format: :email, example: "cotizaciones@aseguradora.com"} + } + }) + end + + defmodule QuoteRequest do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "QuoteRequest", + type: :object, + required: [:applicant_info, :car_details, :selected_providers], + properties: %{ + applicant_info: ApplicantInfo, + car_details: CarDetails, + selected_providers: %Schema{ + type: :array, + items: Provider, + minItems: 1, + example: [%{id: "provider-uuid", email: "cotizaciones@aseguradora.com"}] + } + } + }) + end + + defmodule QuoteResponse do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "QuoteResponse", + type: :object, + properties: %{ + application_id: %Schema{type: :string, example: "550e8400-e29b-41d4-a716-446655440000"}, + status: %Schema{type: :string, example: "awaiting_quotes"} + } + }) + end +end diff --git a/lib/policy_service_web/telemetry.ex b/lib/policy_service_web/telemetry.ex new file mode 100644 index 0000000..2f8ede9 --- /dev/null +++ b/lib/policy_service_web/telemetry.ex @@ -0,0 +1,93 @@ +defmodule PolicyServiceWeb.Telemetry do + use Supervisor + import Telemetry.Metrics + + def start_link(arg) do + Supervisor.start_link(__MODULE__, arg, name: __MODULE__) + end + + @impl true + def init(_arg) do + children = [ + # Telemetry poller will execute the given period measurements + # every 10_000ms. Learn more here: https://hexdocs.pm/telemetry_metrics + {:telemetry_poller, measurements: periodic_measurements(), period: 10_000} + # Add reporters as children of your supervision tree. + # {Telemetry.Metrics.ConsoleReporter, metrics: metrics()} + ] + + Supervisor.init(children, strategy: :one_for_one) + end + + def metrics do + [ + # Phoenix Metrics + summary("phoenix.endpoint.start.system_time", + unit: {:native, :millisecond} + ), + summary("phoenix.endpoint.stop.duration", + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.start.system_time", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.exception.duration", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.stop.duration", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.socket_connected.duration", + unit: {:native, :millisecond} + ), + sum("phoenix.socket_drain.count"), + summary("phoenix.channel_joined.duration", + unit: {:native, :millisecond} + ), + summary("phoenix.channel_handled_in.duration", + tags: [:event], + unit: {:native, :millisecond} + ), + + # Database Metrics + summary("policy_service.repo.query.total_time", + unit: {:native, :millisecond}, + description: "The sum of the other measurements" + ), + summary("policy_service.repo.query.decode_time", + unit: {:native, :millisecond}, + description: "The time spent decoding the data received from the database" + ), + summary("policy_service.repo.query.query_time", + unit: {:native, :millisecond}, + description: "The time spent executing the query" + ), + summary("policy_service.repo.query.queue_time", + unit: {:native, :millisecond}, + description: "The time spent waiting for a database connection" + ), + summary("policy_service.repo.query.idle_time", + unit: {:native, :millisecond}, + description: + "The time the connection spent waiting before being checked out for the query" + ), + + # VM Metrics + summary("vm.memory.total", unit: {:byte, :kilobyte}), + summary("vm.total_run_queue_lengths.total"), + summary("vm.total_run_queue_lengths.cpu"), + summary("vm.total_run_queue_lengths.io") + ] + end + + defp periodic_measurements do + [ + # A module, function and arguments to be invoked periodically. + # This function must call :telemetry.execute/3 and a metric must be added above. + # {PolicyServiceWeb, :count_users, []} + ] + end +end diff --git a/mix.exs b/mix.exs new file mode 100644 index 0000000..623b31c --- /dev/null +++ b/mix.exs @@ -0,0 +1,75 @@ +defmodule PolicyService.MixProject do + use Mix.Project + + def project do + [ + app: :policy_service, + version: "0.1.0", + elixir: "~> 1.15", + elixirc_paths: elixirc_paths(Mix.env()), + start_permanent: Mix.env() == :prod, + aliases: aliases(), + deps: deps(), + listeners: [Phoenix.CodeReloader] + ] + end + + # Configuration for the OTP application. + # + # Type `mix help compile.app` for more information. + def application do + [ + mod: {PolicyService.Application, []}, + extra_applications: [:logger, :runtime_tools] + ] + end + + def cli do + [ + preferred_envs: [precommit: :test] + ] + end + + # Specifies which paths to compile per environment. + defp elixirc_paths(:test), do: ["lib", "test/support"] + defp elixirc_paths(_), do: ["lib"] + + # Specifies your project dependencies. + # + # Type `mix help deps` for examples and options. + defp deps do + [ + {:phoenix, "~> 1.8.3"}, + {:phoenix_ecto, "~> 4.5"}, + {:ecto_sql, "~> 3.13"}, + {:postgrex, ">= 0.0.0"}, + {:telemetry_metrics, "~> 1.0"}, + {:telemetry_poller, "~> 1.0"}, + {:jason, "~> 1.2"}, + {:dns_cluster, "~> 0.2.0"}, + {:bandit, "~> 1.5"}, + {:commanded_ecto_projections, "~> 1.4"}, + {:commanded_eventstore_adapter, "~> 1.4"}, + {:commanded, "~> 1.4"}, + {:amqp, "~> 4.1"}, + {:exconstructor, "~> 1.3.1"}, + {:open_api_spex, "~> 3.20"} + ] + end + + # Aliases are shortcuts or tasks specific to the current project. + # For example, to install project dependencies and perform other setup tasks, run: + # + # $ mix setup + # + # See the documentation for `Mix` for more info on aliases. + defp aliases do + [ + setup: ["deps.get", "ecto.setup"], + "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"], + "ecto.reset": ["ecto.drop", "ecto.setup"], + test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"], + precommit: ["compile --warnings-as-errors", "deps.unlock --unused", "format", "test"] + ] + end +end diff --git a/mix.lock b/mix.lock new file mode 100644 index 0000000..233538d --- /dev/null +++ b/mix.lock @@ -0,0 +1,46 @@ +%{ + "amqp": {:hex, :amqp, "4.1.0", "ab993d7a7adb41bc52fc084224441bad34ba04a6ff97fcd4a17f8281ed010ed1", [:mix], [{:amqp_client, "~> 4.0", [hex: :amqp_client, repo: "hexpm", optional: false]}], "hexpm", "360559cb5a4c4a920806a8c281d0418db3a625ce730008c8460749dd9b1cf838"}, + "amqp_client": {:hex, :amqp_client, "4.2.1", "cff0cc13186e57457dc5745f1b3a4127c6857717cb8f5920dc457c84d0ad00a2", [:make, :rebar3], [{:credentials_obfuscation, "3.5.0", [hex: :credentials_obfuscation, repo: "hexpm", optional: false]}, {:rabbit_common, "4.2.1", [hex: :rabbit_common, repo: "hexpm", optional: false]}], "hexpm", "8ae00b055a58500e0557f73d9c0ffe257487131e603f7f84fe72cbfaaf03838a"}, + "backoff": {:hex, :backoff, "1.1.6", "83b72ed2108ba1ee8f7d1c22e0b4a00cfe3593a67dbc792799e8cce9f42f796b", [:rebar3], [], "hexpm", "cf0cfff8995fb20562f822e5cc47d8ccf664c5ecdc26a684cbe85c225f9d7c39"}, + "bandit": {:hex, :bandit, "1.10.2", "d15ea32eb853b5b42b965b24221eb045462b2ba9aff9a0bda71157c06338cbff", [:mix], [{:hpax, "~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "27b2a61b647914b1726c2ced3601473be5f7aa6bb468564a688646a689b3ee45"}, + "brod": {:hex, :brod, "3.19.1", "6e42e0b495108f8c691717654c6efef7a02f69d1eaaf885bb8d0f7aa8c04b9c7", [:rebar3], [{:kafka_protocol, "4.1.5", [hex: :kafka_protocol, repo: "hexpm", optional: false]}, {:snappyer, "1.2.9", [hex: :snappyer, repo: "hexpm", optional: false]}], "hexpm", "241899cff62e175cd60de4acd4b72f40edb3529b18853f8b22a8a35e4c76d71d"}, + "commanded": {:hex, :commanded, "1.4.9", "289bc371943cf082f1161b1560563f5451ca176c967670cccd63fc3988fcd225", [:mix], [{:backoff, "~> 1.1", [hex: :backoff, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_registry, "~> 0.2", [hex: :telemetry_registry, repo: "hexpm", optional: false]}], "hexpm", "a4f49c23041a23687aa10e99f3db7ee3b8ae470bb615b73b9f887b86437263e7"}, + "commanded_ecto_projections": {:hex, :commanded_ecto_projections, "1.4.0", "a1b220577577d5e0aee4c92b2d9bc6de221f9c1ac2ab36932cba15881761332f", [:mix], [{:commanded, "~> 1.4", [hex: :commanded, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.11", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "8919a6173cd8f30fe2f948c2967f9289c7f5fe4eeca7abc67966bfca31f4aa9f"}, + "commanded_eventstore_adapter": {:hex, :commanded_eventstore_adapter, "1.4.2", "4f2d9d9bd8ef7807a5a4c278b4344adddbbbb4d9c86c693872bc85b944be1fe8", [:mix], [{:commanded, "~> 1.4", [hex: :commanded, repo: "hexpm", optional: false]}, {:eventstore, "~> 1.4", [hex: :eventstore, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "26eaa68515e3e73834d769b73bddfea76c3fdcaff085d735c22b82a66ba19b10"}, + "crc32cer": {:hex, :crc32cer, "0.1.8", "c6c2275c5fb60a95f4935d414f30b50ee9cfed494081c9b36ebb02edfc2f48db", [:rebar3], [], "hexpm", "251499085482920deb6c9b7aadabf9fb4c432f96add97ab42aee4501e5b6f591"}, + "credentials_obfuscation": {:hex, :credentials_obfuscation, "3.5.0", "61e282adfb4439486b3994faaec69543c7ee6cc7e70c6340e8853fd9deaf8219", [:rebar3], [], "hexpm", "843adbe3246861ce0f1a0fa3222f384834eb31defd8d6b9cba7afd2977c957bc"}, + "db_connection": {:hex, :db_connection, "2.9.0", "a6a97c5c958a2d7091a58a9be40caf41ab496b0701d21e1d1abff3fa27a7f371", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "17d502eacaf61829db98facf6f20808ed33da6ccf495354a41e64fe42f9c509c"}, + "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"}, + "dns_cluster": {:hex, :dns_cluster, "0.2.0", "aa8eb46e3bd0326bd67b84790c561733b25c5ba2fe3c7e36f28e88f384ebcb33", [:mix], [], "hexpm", "ba6f1893411c69c01b9e8e8f772062535a4cf70f3f35bcc964a324078d8c8240"}, + "ecto": {:hex, :ecto, "3.13.5", "9d4a69700183f33bf97208294768e561f5c7f1ecf417e0fa1006e4a91713a834", [:mix], [{:decimal, "~> 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", "df9efebf70cf94142739ba357499661ef5dbb559ef902b68ea1f3c1fabce36de"}, + "ecto_sql": {:hex, :ecto_sql, "3.13.4", "b6e9d07557ddba62508a9ce4a484989a5bb5e9a048ae0e695f6d93f095c25d60", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.13.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.7", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.19 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", "2b38cf0749ca4d1c5a8bcbff79bbe15446861ca12a61f9fba604486cb6b62a14"}, + "eventstore": {:hex, :eventstore, "1.4.8", "26778c991cfb078f3906a4267060efc7bb5e5943f69ddb8ae6fb60f07042a66e", [:mix], [{:fsm, "~> 0.3", [hex: :fsm, repo: "hexpm", optional: false]}, {:gen_stage, "~> 1.2", [hex: :gen_stage, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.17", [hex: :postgrex, repo: "hexpm", optional: false]}], "hexpm", "30c914602fdea8db5992a90ecb1f84068531e764cf0c066be71ff0eec4e3bcb9"}, + "exconstructor": {:hex, :exconstructor, "1.3.1", "2c8b19b4702b195782e0cba46c7764df815c0beb8633383a9afb01199c47c3bd", [:mix], [], "hexpm", "5b7b2b043023e4643a44a66750d47587f01f3459d2fb4e7de05406b3a093fa6e"}, + "fsm": {:hex, :fsm, "0.3.1", "087aa9b02779a84320dc7a2d8464452b5308e29877921b2bde81cdba32a12390", [:mix], [], "hexpm", "fbf0d53f89e9082b326b0b5828b94b4c549ff9d1452bbfd00b4d1ac082208e96"}, + "gen_stage": {:hex, :gen_stage, "1.3.2", "7c77e5d1e97de2c6c2f78f306f463bca64bf2f4c3cdd606affc0100b89743b7b", [:mix], [], "hexpm", "0ffae547fa777b3ed889a6b9e1e64566217413d018cabd825f786e843ffe63e7"}, + "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"}, + "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"}, + "kafka_protocol": {:hex, :kafka_protocol, "4.1.5", "d15e64994a8ca99716ab47db4132614359ac1bfa56d6c5b4341fdc1aa4041518", [:rebar3], [{:crc32cer, "0.1.8", [hex: :crc32cer, repo: "hexpm", optional: false]}], "hexpm", "c956c9357fef493b7072a35d0c3e2be02aa5186c804a412d29e62423bb15e5d9"}, + "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"}, + "open_api_spex": {:hex, :open_api_spex, "3.22.2", "0b3c4f572ee69cb6c936abf426b9d84d8eebd34960871fd77aead746f0d69cb0", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0 or ~> 6.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "0a4fc08472d75e9cfe96e0748c6b1565b3b4398f97bf43fcce41b41b6fd3fb33"}, + "phoenix": {:hex, :phoenix, "1.8.3", "49ac5e485083cb1495a905e47eb554277bdd9c65ccb4fc5100306b350151aa95", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, 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]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "36169f95cc2e155b78be93d9590acc3f462f1e5438db06e6248613f27c80caec"}, + "phoenix_ecto": {:hex, :phoenix_ecto, "4.7.0", "75c4b9dfb3efdc42aec2bd5f8bccd978aca0651dbcbc7a3f362ea5d9d43153c6", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.1", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "1d75011e4254cb4ddf823e81823a9629559a1be93b4321a6a5f11a5306fbf4cc"}, + "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"}, + "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"}, + "plug": {:hex, :plug, "1.19.1", "09bac17ae7a001a68ae393658aa23c7e38782be5c5c00c80be82901262c394c0", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "560a0017a8f6d5d30146916862aaf9300b7280063651dd7e532b8be168511e62"}, + "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"}, + "postgrex": {:hex, :postgrex, "0.22.0", "fb027b58b6eab1f6de5396a2abcdaaeb168f9ed4eccbb594e6ac393b02078cbd", [:mix], [{:db_connection, "~> 2.9", [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", "a68c4261e299597909e03e6f8ff5a13876f5caadaddd0d23af0d0a61afcc5d84"}, + "rabbit_common": {:hex, :rabbit_common, "4.2.1", "1d64e391e12116b76b1425eb96b7552de51f0301093eba669b5334f4759cc1e8", [:make, :rebar3], [{:credentials_obfuscation, "3.5.0", [hex: :credentials_obfuscation, repo: "hexpm", optional: false]}, {:ranch, "2.2.0", [hex: :ranch, repo: "hexpm", optional: false]}, {:recon, "2.5.6", [hex: :recon, repo: "hexpm", optional: false]}, {:thoas, "1.2.1", [hex: :thoas, repo: "hexpm", optional: false]}], "hexpm", "ff509b07e639b1784898c28031e5204fea14260172e4fc339f94405586037e40"}, + "ranch": {:hex, :ranch, "2.2.0", "25528f82bc8d7c6152c57666ca99ec716510fe0925cb188172f41ce93117b1b0", [:make, :rebar3], [], "hexpm", "fa0b99a1780c80218a4197a59ea8d3bdae32fbff7e88527d7d8a4787eff4f8e7"}, + "recon": {:hex, :recon, "2.5.6", "9052588e83bfedfd9b72e1034532aee2a5369d9d9343b61aeb7fbce761010741", [:mix, :rebar3], [], "hexpm", "96c6799792d735cc0f0fd0f86267e9d351e63339cbe03df9d162010cefc26bb0"}, + "snappyer": {:hex, :snappyer, "1.2.9", "9cc58470798648ce34c662ca0aa6daae31367667714c9a543384430a3586e5d3", [:rebar3], [], "hexpm", "18d00ca218ae613416e6eecafe1078db86342a66f86277bd45c95f05bf1c8b29"}, + "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, + "telemetry_metrics": {:hex, :telemetry_metrics, "1.1.0", "5bd5f3b5637e0abea0426b947e3ce5dd304f8b3bc6617039e2b5a008adc02f8f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7b79e8ddfde70adb6db8a6623d1778ec66401f366e9a8f5dd0955c56bc8ce67"}, + "telemetry_poller": {:hex, :telemetry_poller, "1.3.0", "d5c46420126b5ac2d72bc6580fb4f537d35e851cc0f8dbd571acf6d6e10f5ec7", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "51f18bed7128544a50f75897db9974436ea9bfba560420b646af27a9a9b35211"}, + "telemetry_registry": {:hex, :telemetry_registry, "0.3.2", "701576890320be6428189bff963e865e8f23e0ff3615eade8f78662be0fc003c", [:mix, :rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7ed191eb1d115a3034af8e1e35e4e63d5348851d556646d46ca3d1b4e16bab9"}, + "thoas": {:hex, :thoas, "1.2.1", "19a25f31177a17e74004d4840f66d791d4298c5738790fa2cc73731eb911f195", [:rebar3], [], "hexpm", "e38697edffd6e91bd12cea41b155115282630075c2a727e7a6b2947f5408b86a"}, + "thousand_island": {:hex, :thousand_island, "1.4.3", "2158209580f633be38d43ec4e3ce0a01079592b9657afff9080d5d8ca149a3af", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6e4ce09b0fd761a58594d02814d40f77daff460c48a7354a15ab353bb998ea0b"}, + "uuid": {:hex, :uuid, "1.1.8", "e22fc04499de0de3ed1116b770c7737779f226ceefa0badb3592e64d5cfb4eb9", [:mix], [], "hexpm", "c790593b4c3b601f5dc2378baae7efaf5b3d73c4c6456ba85759905be792f2ac"}, + "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"}, + "websock_adapter": {:hex, :websock_adapter, "0.5.9", "43dc3ba6d89ef5dec5b1d0a39698436a1e856d000d84bf31a3149862b01a287f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "5534d5c9adad3c18a0f58a9371220d75a803bf0b9a3d87e6fe072faaeed76a08"}, +} diff --git a/priv/repo/migrations/.formatter.exs b/priv/repo/migrations/.formatter.exs new file mode 100644 index 0000000..49f9151 --- /dev/null +++ b/priv/repo/migrations/.formatter.exs @@ -0,0 +1,4 @@ +[ + import_deps: [:ecto_sql], + inputs: ["*.exs"] +] diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs new file mode 100644 index 0000000..84b54a6 --- /dev/null +++ b/priv/repo/seeds.exs @@ -0,0 +1,11 @@ +# Script for populating the database. You can run it as: +# +# mix run priv/repo/seeds.exs +# +# Inside the script, you can read and write to any of your +# repositories directly: +# +# PolicyService.Repo.insert!(%PolicyService.SomeSchema{}) +# +# We recommend using the bang functions (`insert!`, `update!` +# and so on) as they will fail if something goes wrong. diff --git a/priv/static/favicon.ico b/priv/static/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..7f372bfc21cdd8cb47585339d5fa4d9dd424402f GIT binary patch literal 152 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=@t!V@Ar*{oFEH`~d50E!_s``s q?{G*w(7?#d#v@^nKnY_HKaYb01EZMZjMqTJ89ZJ6T-G@yGywoKK_h|y literal 0 HcmV?d00001 diff --git a/priv/static/robots.txt b/priv/static/robots.txt new file mode 100644 index 0000000..26e06b5 --- /dev/null +++ b/priv/static/robots.txt @@ -0,0 +1,5 @@ +# See https://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file +# +# To ban all spiders from the entire site uncomment the next two lines: +# User-agent: * +# Disallow: / diff --git a/rabbitmq/definitions.json b/rabbitmq/definitions.json new file mode 100644 index 0000000..b966943 --- /dev/null +++ b/rabbitmq/definitions.json @@ -0,0 +1,91 @@ +{ + "vhosts": [ + { + "name": "/" + } + ], + "permissions": [ + { + "user": "guest", + "vhost": "/", + "configure": ".*", + "write": ".*", + "read": ".*" + } + ], + "exchanges": [ + { + "name": "policy_service.events", + "vhost": "/", + "type": "topic", + "durable": true, + "auto_delete": false, + "arguments": {} + }, + { + "name": "carrier_inbox.events", + "vhost": "/", + "type": "topic", + "durable": true, + "auto_delete": false, + "arguments": {} + } + ], + "queues": [ + { + "name": "carquote.requested", + "vhost": "/", + "durable": true, + "auto_delete": false, + "arguments": {} + }, + { + "name": "carsolicitation.sent", + "vhost": "/", + "durable": true, + "auto_delete": false, + "arguments": {} + }, + { + "name": "policy_service.quote_received", + "vhost": "/", + "durable": true, + "auto_delete": false, + "arguments": {} + } + ], + "bindings": [ + { + "source": "policy_service.events", + "vhost": "/", + "destination": "carquote.requested", + "destination_type": "queue", + "routing_key": "carquote.requested", + "arguments": {} + }, + { + "source": "policy_service.events", + "vhost": "/", + "destination": "carsolicitation.sent", + "destination_type": "queue", + "routing_key": "carsolicitation.sent", + "arguments": {} + }, + { + "source": "carrier_inbox.events", + "vhost": "/", + "destination": "policy_service.quote_received", + "destination_type": "queue", + "routing_key": "quote.received", + "arguments": {} + } + ], + "users": [ + { + "name": "guest", + "password_hash": "rE1pU3Tq9IG79e0m1W4Yp2gSHFvr4DDF5m4H0U6+0Zgu5BFb", + "hashing_algorithm": "rabbit_password_hashing_sha256", + "tags": "administrator" + } + ] +} diff --git a/rabbitmq/rabbitmq.conf b/rabbitmq/rabbitmq.conf new file mode 100644 index 0000000..53d7cf8 --- /dev/null +++ b/rabbitmq/rabbitmq.conf @@ -0,0 +1,2 @@ +loopback_users.guest = false +load_definitions = /etc/rabbitmq/definitions.json diff --git a/test/policy_service_test.exs b/test/policy_service_test.exs new file mode 100644 index 0000000..f9573b5 --- /dev/null +++ b/test/policy_service_test.exs @@ -0,0 +1,8 @@ +defmodule PolicyServiceTest do + use ExUnit.Case + doctest PolicyService + + test "greets the world" do + assert PolicyService.hello() == :world + end +end diff --git a/test/policy_service_web/controllers/error_json_test.exs b/test/policy_service_web/controllers/error_json_test.exs new file mode 100644 index 0000000..0536874 --- /dev/null +++ b/test/policy_service_web/controllers/error_json_test.exs @@ -0,0 +1,12 @@ +defmodule PolicyServiceWeb.ErrorJSONTest do + use PolicyServiceWeb.ConnCase, async: true + + test "renders 404" do + assert PolicyServiceWeb.ErrorJSON.render("404.json", %{}) == %{errors: %{detail: "Not Found"}} + end + + test "renders 500" do + assert PolicyServiceWeb.ErrorJSON.render("500.json", %{}) == + %{errors: %{detail: "Internal Server Error"}} + end +end diff --git a/test/support/conn_case.ex b/test/support/conn_case.ex new file mode 100644 index 0000000..9d63b18 --- /dev/null +++ b/test/support/conn_case.ex @@ -0,0 +1,38 @@ +defmodule PolicyServiceWeb.ConnCase do + @moduledoc """ + This module defines the test case to be used by + tests that require setting up a connection. + + Such tests rely on `Phoenix.ConnTest` and also + import other functionality to make it easier + to build common data structures and query the data layer. + + Finally, if the test case interacts with the database, + we enable the SQL sandbox, so changes done to the database + are reverted at the end of every test. If you are using + PostgreSQL, you can even run database tests asynchronously + by setting `use PolicyServiceWeb.ConnCase, async: true`, although + this option is not recommended for other databases. + """ + + use ExUnit.CaseTemplate + + using do + quote do + # The default endpoint for testing + @endpoint PolicyServiceWeb.Endpoint + + use PolicyServiceWeb, :verified_routes + + # Import conveniences for testing with connections + import Plug.Conn + import Phoenix.ConnTest + import PolicyServiceWeb.ConnCase + end + end + + setup tags do + PolicyService.DataCase.setup_sandbox(tags) + {:ok, conn: Phoenix.ConnTest.build_conn()} + end +end diff --git a/test/support/data_case.ex b/test/support/data_case.ex new file mode 100644 index 0000000..e8de488 --- /dev/null +++ b/test/support/data_case.ex @@ -0,0 +1,58 @@ +defmodule PolicyService.DataCase do + @moduledoc """ + This module defines the setup for tests requiring + access to the application's data layer. + + You may define functions here to be used as helpers in + your tests. + + Finally, if the test case interacts with the database, + we enable the SQL sandbox, so changes done to the database + are reverted at the end of every test. If you are using + PostgreSQL, you can even run database tests asynchronously + by setting `use PolicyService.DataCase, async: true`, although + this option is not recommended for other databases. + """ + + use ExUnit.CaseTemplate + + using do + quote do + alias PolicyService.Repo + + import Ecto + import Ecto.Changeset + import Ecto.Query + import PolicyService.DataCase + end + end + + setup tags do + PolicyService.DataCase.setup_sandbox(tags) + :ok + end + + @doc """ + Sets up the sandbox based on the test tags. + """ + def setup_sandbox(tags) do + pid = Ecto.Adapters.SQL.Sandbox.start_owner!(PolicyService.Repo, shared: not tags[:async]) + on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end) + end + + @doc """ + A helper that transforms changeset errors into a map of messages. + + assert {:error, changeset} = Accounts.create_user(%{password: "short"}) + assert "password is too short" in errors_on(changeset).password + assert %{password: ["password is too short"]} = errors_on(changeset) + + """ + def errors_on(changeset) do + Ecto.Changeset.traverse_errors(changeset, fn {message, opts} -> + Regex.replace(~r"%{(\w+)}", message, fn _, key -> + opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string() + end) + end) + end +end diff --git a/test/test_helper.exs b/test/test_helper.exs new file mode 100644 index 0000000..f23996a --- /dev/null +++ b/test/test_helper.exs @@ -0,0 +1,2 @@ +ExUnit.start() +Ecto.Adapters.SQL.Sandbox.mode(PolicyService.Repo, :manual)