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

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