dont use S3 directly allow to use any document url (document service agnostic)

lib/provider_service/aggregates/provider.ex

@@ -98,21 +98,16 @@ defmodule ProviderService.Aggregates.Provider do
   def execute(%__MODULE__{active: false}, %AddProviderTemplate{}),
     do: {:error, :provider_inactive}
 
-  def execute(%__MODULE__{} = agg, %AddProviderTemplate{} = cmd) do
-    existing = get_in(agg.templates, [cmd.policy_type, cmd.client_type]) || []
-    version = length(existing) + 1
-
-    %ProviderTemplateAdded{
-      provider_id: agg.provider_id,
-      template_id: cmd.template_id,
-      policy_type: cmd.policy_type,
-      client_type: cmd.client_type,
-      s3_key: cmd.s3_key,
-      fields: cmd.fields,
-      version: version,
-      added_at: DateTime.utc_now()
-    }
-  end
+   def execute(%__MODULE__{} = agg, %AddProviderTemplate{} = cmd) do
+     %ProviderTemplateAdded{
+       provider_id: agg.provider_id,
+       template_id: cmd.template_id,
+       policy_type: cmd.policy_type,
+       client_type: cmd.client_type,
+       document_url: cmd.document_url,
+       added_at: DateTime.utc_now()
+     }
+   end
 
   def execute(%__MODULE__{} = agg, %ActivateProviderTemplate{} = cmd) do
     case find_template(agg, cmd.policy_type, cmd.client_type, cmd.template_id) do
@@ -235,10 +230,8 @@ defmodule ProviderService.Aggregates.Provider do
           [
             %{
               template_id: e.template_id,
-              s3_key: e.s3_key,
-              fields: e.fields,
-              version: e.version,
-              active: true
+              document_url: e.document_url,
+              active: false
             }
           ]
       )

lib/provider_service/commands/provider.ex

@@ -16,7 +16,7 @@ defmodule ProviderService.Commands do
   end
 
   defmodule AddProviderTemplate do
-    defstruct [:provider_id, :template_id, :policy_type, :s3_key, :fields, :client_type]
+    defstruct [:provider_id, :template_id, :policy_type, :document_url, :client_type]
   end
 
   defmodule ActivateProviderTemplate do

lib/provider_service/events/provider.ex

@@ -25,9 +25,7 @@ defmodule ProviderService.Events do
       :provider_id,
       :template_id,
       :policy_type,
-      :s3_key,
-      :fields,
-      :version,
+      :document_url,
       :added_at,
       :client_type
     ]

lib/provider_service/projections/provider_projection.ex

@@ -76,9 +76,7 @@ defmodule ProviderService.Projections.ProviderProjection do
       template = %{
         "template_id" => e.template_id,
         "client_type" => e.client_type,
-        "s3_key" => e.s3_key,
-        "fields" => e.fields || [],
-        "version" => e.version,
+        "document_url" => e.document_url,
         "active" => false
       }
 

lib/provider_service/queries/provider_queries.ex

@@ -1,9 +1,11 @@
 defmodule ProviderService.Queries.ProviderQueries do
+  import Ecto.Query
   alias ProviderService.Projections.Provider
   alias ProviderService.Repo
 
   def list_providers(params \\ %{}) do
-    Flop.validate_and_run(Provider, params, for: Provider)
+    base = from(p in Provider)
+    Flop.validate_and_run(base, params, for: Provider)
   end
 
   def get_provider(provider_id) do

lib/provider_service/s3.ex

@@ -1,38 +0,0 @@
-defmodule ProviderService.S3 do
-  @bucket Application.compile_env(:provider_service, :s3_bucket)
-
-  def presigned_upload_url(s3_key) do
-    {:ok, url} =
-      ExAws.Config.new(:s3)
-      |> ExAws.S3.presigned_url(:put, @bucket, s3_key,
-        expires_in: 900,
-        query_params: [{"Content-Type", "application/pdf"}]
-      )
-
-    url
-  end
-
-  def presigned_download_url(s3_key) do
-    {:ok, url} =
-      ExAws.Config.new(:s3)
-      |> ExAws.S3.presigned_url(:get, @bucket, s3_key, expires_in: 3600)
-
-    url
-  end
-
-  def delete(s3_key) do
-    ExAws.S3.delete_object(@bucket, s3_key)
-    |> ExAws.request()
-  end
-
-  def upload(local_path, s3_key) do
-    local_path
-    |> File.read!()
-    |> then(&ExAws.S3.put_object(@bucket, s3_key, &1, content_type: "application/pdf"))
-    |> ExAws.request()
-    |> case do
-      {:ok, _} -> :ok
-      {:error, e} -> {:error, inspect(e)}
-    end
-  end
-end

lib/provider_service_web/controllers/provider_controller.ex

@@ -13,16 +13,11 @@ defmodule ProviderServiceWeb.ProviderController do
   }
 
   alias ProviderServiceWeb.Schemas.Provider, as: PS
+  alias ProviderServiceWeb.QueryHelpers
 
   operation(:index,
     summary: "List providers",
-    parameters: [
-      "page[number]": [in: :query, type: :integer, required: false],
-      "page[size]": [in: :query, type: :integer, required: false],
-      "filters[0][field]": [in: :query, type: :string, required: false],
-      "filters[0][op]": [in: :query, type: :string, required: false],
-      "filters[0][value]": [in: :query, type: :string, required: false]
-    ],
+    parameters: QueryHelpers.flop([:active, :search], [:name, :inserted_at]),
     responses: [
       ok: {"Provider list", "application/json", PS.ProviderListResponse}
     ]

lib/provider_service_web/controllers/template_controller.ex

@@ -13,7 +13,6 @@ defmodule ProviderServiceWeb.TemplateController do
     RemoveProviderTemplate
   }
 
-  alias ProviderService.S3
   alias ProviderServiceWeb.Schemas.Provider, as: PS
 
   operation(:index,
@@ -37,65 +36,41 @@ defmodule ProviderServiceWeb.TemplateController do
   end
 
   operation(:upload_template,
-    summary: "Upload solicitation template",
-    description: "Upload a fillable PDF. Fields are auto-discovered via solicitation_service.",
+    summary: "Register template by document URL",
+    description: "Register a template document URL for a provider.",
     parameters: [
       provider_id: [in: :path, type: :string, required: true]
     ],
     request_body:
-      {"Multipart PDF upload", "multipart/form-data", PS.UploadTemplateRequest, required: true},
+      {"Document URL payload", "application/json", PS.UploadTemplateRequest, required: true},
     responses: [
       created: {"Template registered", "application/json", PS.UploadTemplateResponse}
     ]
   )
 
   def upload_template(conn, %{"provider_id" => provider_id} = params) do
-    # %Plug.Upload{}
-    upload = params["file"]
+    document_url = params["document_url"]
     policy_type = params["policy_type"]
     client_type = params["client_type"]
 
     template_id = Ecto.UUID.generate()
-    s3_key = "templates/#{provider_id}/#{policy_type}/#{client_type}/#{template_id}.pdf"
 
-    # Upload to S3/MinIO
-    case S3.upload(upload.path, s3_key) do
+    cmd = %AddProviderTemplate{
+      provider_id: provider_id,
+      template_id: template_id,
+      client_type: client_type,
+      policy_type: policy_type,
+      document_url: document_url
+    }
+
+    case ProviderService.CommandedApp.dispatch(cmd) do
       :ok ->
-        # Discover AcroForm fields via solicitation_service
-        fields = discover_fields(s3_key)
-
-        cmd = %AddProviderTemplate{
-          provider_id: provider_id,
-          template_id: template_id,
-          client_type: client_type,
-          policy_type: policy_type,
-          s3_key: s3_key,
-          fields: fields
-        }
-
-        case ProviderService.CommandedApp.dispatch(cmd) do
-          :ok ->
-            conn
-            |> put_status(:created)
-            |> json(%{template_id: template_id, s3_key: s3_key, fields: fields})
-
-          {:error, reason} ->
-            conn |> put_status(:unprocessable_entity) |> json(%{error: reason})
-        end
+        conn
+        |> put_status(:created)
+        |> json(%{template_id: template_id, document_url: document_url})
 
       {:error, reason} ->
-        conn
-        |> put_status(:internal_server_error)
-        |> json(%{error: "S3 upload failed: #{reason}"})
-    end
-  end
-
-  defp discover_fields(s3_key) do
-    url = Application.get_env(:provider_service, :solicitation_service_url)
-
-    case Req.get("#{url}/api/solicitations/templates/fields", params: [s3_key: s3_key]) do
-      {:ok, %{status: 200, body: %{"fields" => fields}}} -> fields
-      _ -> []
+        conn |> put_status(:unprocessable_entity) |> json(%{error: reason})
     end
   end
 

lib/provider_service_web/query_helpers.ex

@@ -0,0 +1,34 @@
+defmodule ProviderServiceWeb.QueryHelpers do
+  @moduledoc false
+
+  alias OpenApiSpex.Schema
+
+  @filter_count 3
+
+  def flop(filter_fields, order_fields, other \\ []) do
+    [
+      page: [in: :query, schema: %Schema{type: :number, default: 1}],
+      page_size: [in: :query, schema: %Schema{type: :number, default: 20}],
+      order_by: [
+        in: :query,
+        schema: %Schema{type: :array, items: %Schema{type: :string, enum: order_fields}}
+      ],
+      order_directions: [
+        in: :query,
+        schema: %Schema{type: :array, items: %Schema{type: :string, enum: ["asc", "desc"]}}
+      ]
+    ] ++ build_filter_params(filter_fields) ++ other
+  end
+
+  defp build_filter_params(fields) do
+    for i <- 0..(@filter_count - 1) do
+      [
+        {:"filters[#{i}][field]", [in: :query, schema: %Schema{type: :string, enum: fields}]},
+        {:"filters[#{i}][op]",
+         [in: :query, schema: %Schema{type: :string, enum: Flop.Filter.allowed_operators(:all)}]},
+        {:"filters[#{i}][value]", [in: :query, schema: %Schema{type: :string}]}
+      ]
+    end
+    |> List.flatten()
+  end
+end

lib/provider_service_web/schemas/provider.ex

@@ -18,22 +18,6 @@ defmodule ProviderServiceWeb.Schemas.Provider do
     })
   end
 
-  defmodule TemplateField do
-    require OpenApiSpex
-
-    OpenApiSpex.schema(%{
-      title: "TemplateField",
-      type: :object,
-      properties: %{
-        field: %Schema{type: :string, example: "beneficiary_name"},
-        label: %Schema{type: :string, example: "Beneficiary Name"},
-        type: %Schema{type: :string, enum: ["string", "date", "number", "select", "boolean"]},
-        required: %Schema{type: :boolean},
-        options: %Schema{type: :array, items: %Schema{type: :string}, nullable: true}
-      }
-    })
-  end
-
   defmodule Template do
     require OpenApiSpex
 
@@ -44,9 +28,7 @@ defmodule ProviderServiceWeb.Schemas.Provider do
         template_id: %Schema{type: :string, format: :uuid},
         policy_type: %Schema{type: :string, enum: ["car", "life", "fire"]},
         client_type: %Schema{type: :string, enum: ["natural", "juridico"]},
-        s3_key: %Schema{type: :string},
-        version: %Schema{type: :integer},
-        fields: %Schema{type: :array, items: TemplateField},
+        document_url: %Schema{type: :string},
         active: %Schema{type: :boolean}
       }
     })
@@ -98,12 +80,11 @@ defmodule ProviderServiceWeb.Schemas.Provider do
     OpenApiSpex.schema(%{
       title: "UploadTemplateRequest",
       type: :object,
-      required: [:file, :policy_type, :client_type],
+      required: [:document_url, :policy_type, :client_type],
       properties: %{
-        file: %Schema{
+        document_url: %Schema{
           type: :string,
-          format: :binary,
-          description: "Fillable PDF (AcroForm)"
+          description: "URL to the uploaded document"
         },
         policy_type: %Schema{
           type: :string,
@@ -127,8 +108,7 @@ defmodule ProviderServiceWeb.Schemas.Provider do
       type: :object,
       properties: %{
         template_id: %Schema{type: :string, format: :uuid},
-        s3_key: %Schema{type: :string},
-        fields: %Schema{type: :array, items: TemplateField}
+        document_url: %Schema{type: :string}
       }
     })
   end