- <%= if @search != "" or @type_filter != "all" do %>
- Try adjusting your filters or search terms
- <% else %>
- Billing profiles are created by users
- <% end %>
-
- <%!-- IMPORTANT: Roles are REVERSED for credit notes --%>
- <%!-- Company is the PAYER (issuing refund) --%>
-
-
Issued By (Payer)
-
- {@company.name}
-
- <%= for line <- String.split(@company.address || "", "\n") do %>
- {line}
- <% end %>
- <%= if @company.vat != "" do %>
- VAT: {@company.vat}
- <% end %>
-
-
-
- <%!-- Customer is the PAYEE (receiving refund) --%>
-
-
Issued To (Payee)
-
- <%= if @invoice.billing_details && map_size(@invoice.billing_details) > 0 do %>
- <%= if @invoice.billing_details["type"] == "company" do %>
- {@invoice.billing_details["company_name"]}
-
- <%= if @invoice.billing_details["company_vat_number"] do %>
- VAT: {@invoice.billing_details["company_vat_number"]}
- <% end %>
- <% else %>
-
- {@invoice.billing_details["first_name"]} {@invoice.billing_details[
- "last_name"
- ]}
-
-
- <% end %>
- <%= if @invoice.billing_details["address_line1"] do %>
- {@invoice.billing_details["address_line1"]}
- <% end %>
- <%= if @invoice.billing_details["address_line2"] do %>
- {@invoice.billing_details["address_line2"]}
- <% end %>
- <%= if @invoice.billing_details["city"] do %>
- {@invoice.billing_details["city"]}
- <%= if @invoice.billing_details["postal_code"] do %>
- , {@invoice.billing_details["postal_code"]}
- <% end %>
-
- <% end %>
- <%= if @invoice.billing_details["country"] do %>
- {@invoice.billing_details["country"]}
- <% end %>
- <% else %>
- <%= if @invoice.user do %>
- {@invoice.user.email}
- <% else %>
- No billing information
- <% end %>
- <% end %>
-
- The default currency is used for all new orders. Exchange rates are relative to the default currency (base rate = 1.0).
- Enable only the currencies you plan to accept for billing.
-
-
-
-
-
- <%!-- Currency Form Modal --%>
- <%= if @show_form do %>
-
- <%= for currency <- @currencies do %>
- <.currency_badge code={currency.code} name={currency.name} size={:md} />
- <% end %>
- <%= if Enum.empty?(@currencies) do %>
- No currencies configured
- <% end %>
-
- Created <.time_ago datetime={@invoice.inserted_at} />
-
- <:actions>
- <%!-- Send/Resend Invoice - available for all except void --%>
- <%= if @invoice.status != "void" do %>
-
- <% end %>
-
- <%!-- Mark as Paid - available for sent/overdue --%>
- <%= if @invoice.status in ["sent", "overdue"] do %>
-
- <% end %>
-
- <%!-- Online Payment Providers - available for sent/overdue with remaining balance --%>
- <%= if @invoice.status in ["sent", "overdue"] && Decimal.positive?(PhoenixKit.Modules.Billing.Invoice.remaining_amount(@invoice)) do %>
- <%= for provider <- @available_providers do %>
-
- <% end %>
- <% end %>
-
- <%!-- Issue Refund - available if has payments --%>
- <%= if PhoenixKit.Modules.Billing.Invoice.has_payments?(@invoice) do %>
-
- <% end %>
-
- <%!-- Generate Receipt - available when paid_amount > 0 and no receipt yet --%>
- <%= if is_nil(@invoice.receipt_number) && @invoice.paid_amount && Decimal.gt?(@invoice.paid_amount, Decimal.new(0)) do %>
-
- <% end %>
-
- <%!-- Void - available for draft/sent/overdue --%>
- <%= if @invoice.status in ["draft", "sent", "overdue"] do %>
-
- <% end %>
-
- <.link
- navigate={
- PhoenixKit.Utils.Routes.path("/admin/billing/invoices/#{@invoice.uuid}/print")
- }
- class="btn btn-outline btn-sm"
- target="_blank"
- >
- <.icon name="hero-printer" class="w-4 h-4" /> Print / PDF
-
-
- <%!-- View Receipt - available when receipt is generated --%>
- <%= if @invoice.receipt_number do %>
- <.link
- navigate={
- PhoenixKit.Utils.Routes.path("/admin/billing/invoices/#{@invoice.uuid}/receipt")
- }
- class="btn btn-success btn-sm"
- target="_blank"
- >
- <.icon name="hero-document-check" class="w-4 h-4" /> View Receipt
-
-
- <% end %>
-
-
-
-
- <%!-- Main Content --%>
-
- <%!-- Invoice Details --%>
-
-
-
Invoice Details
-
- <%!-- Line Items --%>
-
-
-
-
-
Item
-
Qty
-
Unit Price
-
Total
-
-
-
- <%= for item <- @invoice.line_items || [] do %>
-
- <%= if @search != "" or @status_filter != "all" do %>
- Try adjusting your filters or search terms
- <% else %>
- Invoices are generated from orders
- <% end %>
-
- This customer has no billing profile. A billing profile is required to create an order.
- <.link
- navigate={
- PhoenixKit.Utils.Routes.path(
- "/admin/billing/profiles/new?user_uuid=#{@selected_user_uuid}"
- )
- }
- class="link font-medium"
- >
- Create one now
-
-
- <%= if @search != "" or @status_filter != "all" do %>
- Try adjusting your filters or search terms
- <% else %>
- Get started by creating your first order
- <% end %>
-
- <%= if @invoice.billing_details && map_size(@invoice.billing_details) > 0 do %>
- <%= if @invoice.billing_details["type"] == "company" do %>
- {@invoice.billing_details["company_name"]}
-
- <%= if @invoice.billing_details["company_vat_number"] do %>
- VAT: {@invoice.billing_details["company_vat_number"]}
- <% end %>
- <% else %>
-
- {@invoice.billing_details["first_name"]} {@invoice.billing_details[
- "last_name"
- ]}
-
-
- <% end %>
- <%= if @invoice.billing_details["address_line1"] do %>
- {@invoice.billing_details["address_line1"]}
- <% end %>
- <%= if @invoice.billing_details["address_line2"] do %>
- {@invoice.billing_details["address_line2"]}
- <% end %>
- <%= if @invoice.billing_details["city"] do %>
- {@invoice.billing_details["city"]}
- <%= if @invoice.billing_details["postal_code"] do %>
- , {@invoice.billing_details["postal_code"]}
- <% end %>
-
- <% end %>
- <%= if @invoice.billing_details["country"] do %>
- {@invoice.billing_details["country"]}
- <% end %>
- <% else %>
- <%= if @invoice.user do %>
- {@invoice.user.email}
- <% else %>
- No billing information
- <% end %>
- <% end %>
-
-
-
-
-
Received By
-
- {@company.name}
-
- <%= for line <- String.split(@company.address || "", "\n") do %>
- {line}
- <% end %>
- <%= if @company.vat != "" do %>
- VAT: {@company.vat}
- <% end %>
-
- Last Payment Date
-
- <%= if @last_payment_date do %>
- {Calendar.strftime(@last_payment_date, "%B %d, %Y at %H:%M")}
- <% else %>
- -
- <% end %>
-
-
- <%= if @subscription.current_period_start do %>
- <.time_ago datetime={@subscription.current_period_start} />
- <% else %>
- Not set
- <% end %>
-
-
-
-
Period End
-
- <%= if @subscription.current_period_end do %>
- <.time_ago datetime={@subscription.current_period_end} />
- <% days = days_until_renewal(@subscription) %>
- <%= if days && days > 0 do %>
-
- ({days} days remaining)
-
- <% end %>
- <% else %>
- Not set
- <% end %>
-
-
-
-
- <%!-- Trial Period --%>
- <%= if @subscription.trial_start || @subscription.trial_end do %>
-
Trial Period
-
-
-
Trial Start
-
- <%= if @subscription.trial_start do %>
- <.time_ago datetime={@subscription.trial_start} />
- <% else %>
- -
- <% end %>
-
-
-
-
Trial End
-
- <%= if @subscription.trial_end do %>
- <.time_ago datetime={@subscription.trial_end} />
- <% else %>
- -
- <% end %>
-
-
-
- <% end %>
-
- <%!-- Grace Period (if past_due) --%>
- <%= if @subscription.status == "past_due" && @subscription.grace_period_end do %>
-
- <%= if @selected_subscription_type_uuid do %>
- <% type =
- Enum.find(
- @subscription_types,
- &(to_string(&1.uuid) == to_string(@selected_subscription_type_uuid))
- ) %>
- <%= if type do %>
-
- <%= if @search != "" or @type_filter != "all" or @payment_method_filter != "all" do %>
- Try adjusting your filters or search terms
- <% else %>
- Transactions will appear here when payments or refunds are recorded
- <% end %>
-
-
- <% else %>
-
-
-
-
-
Transaction #
-
Invoice
-
Type
-
Amount
-
Method
-
Description
-
Date
-
-
-
-
- <%= for transaction <- @transactions do %>
-
- Create a billing profile to use for your orders
-
- <.link navigate={Routes.path("/dashboard/billing-profiles/new")} class="btn btn-primary">
- Create Your First Profile
-
-
-
- <% else %>
-
- <%= for profile <- @profiles do %>
-
-
-
- <%!-- Profile Info --%>
-
-
-
- {String.capitalize(profile.type)}
-
- <%= if profile.is_default do %>
- Default
- <% end %>
-
-
- <%= if profile.type == "company" do %>
-
{profile.company_name}
- <%= if profile.company_vat_number do %>
-
- VAT: {profile.company_vat_number}
-
- <% end %>
- <% else %>
-
- {profile.first_name} {profile.last_name}
-
- <%= if profile.email do %>
-
{profile.email}
- <% end %>
- <% end %>
-
- <%= if profile.address_line1 do %>
-
- {profile.address_line1}
- <%= if profile.city do %>
- , {profile.city}
- <% end %>
- <%= if profile.country do %>
- , {profile.country}
- <% end %>
-
- <% end %>
-
-
- <%!-- Actions --%>
-
- <.link
- navigate={Routes.path("/dashboard/billing-profiles/#{profile.uuid}/edit")}
- class="btn btn-outline btn-sm"
- >
- <.icon name="hero-pencil" class="w-4 h-4" /> Edit
-
-
- <%= if not profile.is_default do %>
-
- <% end %>
-
-
-
-
-
-
- <% end %>
-
- <% end %>
-
-
- """
- end
-
- # Private helpers
-
- defp get_current_user(socket) do
- case socket.assigns[:phoenix_kit_current_scope] do
- %{user: %{uuid: _} = user} -> user
- _ -> nil
- end
- end
-end
diff --git a/lib/modules/billing/web/webhook_controller.ex b/lib/modules/billing/web/webhook_controller.ex
deleted file mode 100644
index 0c264a1b0..000000000
--- a/lib/modules/billing/web/webhook_controller.ex
+++ /dev/null
@@ -1,160 +0,0 @@
-defmodule PhoenixKit.Modules.Billing.Web.WebhookController do
- @moduledoc """
- Handles webhooks from payment providers (Stripe, PayPal, Razorpay).
-
- This controller receives webhook events from payment providers,
- verifies their signatures, and processes them through the WebhookProcessor.
-
- ## Webhook URLs
-
- Configure these URLs in your payment provider dashboards:
-
- - Stripe: `https://yourdomain.com/phoenix_kit/webhooks/billing/stripe`
- - PayPal: `https://yourdomain.com/phoenix_kit/webhooks/billing/paypal`
- - Razorpay: `https://yourdomain.com/phoenix_kit/webhooks/billing/razorpay`
-
- ## Security
-
- All webhooks verify signatures to ensure they come from legitimate sources.
- Invalid signatures result in 401 Unauthorized responses.
-
- ## Idempotency
-
- Events are logged in the `phoenix_kit_webhook_events` table with their
- event IDs. Duplicate events are detected and ignored to prevent
- double-processing.
- """
-
- use Phoenix.Controller,
- formats: [:json]
-
- alias PhoenixKit.Modules.Billing.Providers
- alias PhoenixKit.Modules.Billing.WebhookProcessor
- alias PhoenixKit.Settings
-
- require Logger
-
- @doc """
- Handles Stripe webhooks.
-
- Expects the raw body in `conn.assigns.raw_body` (set by a custom Plug).
- Signature is read from the `stripe-signature` header.
- """
- def stripe(conn, _params) do
- handle_webhook(conn, :stripe, "stripe-signature")
- end
-
- @doc """
- Handles PayPal webhooks.
-
- PayPal verification requires multiple headers for signature verification.
- """
- def paypal(conn, _params) do
- handle_webhook(conn, :paypal, "paypal-transmission-sig")
- end
-
- @doc """
- Handles Razorpay webhooks.
-
- Signature is read from the `x-razorpay-signature` header.
- """
- def razorpay(conn, _params) do
- handle_webhook(conn, :razorpay, "x-razorpay-signature")
- end
-
- # ===========================================
- # Private Implementation
- # ===========================================
-
- defp handle_webhook(conn, provider, signature_header) do
- with {:ok, raw_body} <- get_raw_body(conn),
- {:ok, signature} <- get_signature(conn, signature_header),
- {:ok, secret} <- get_webhook_secret(provider),
- :ok <- verify_signature(provider, raw_body, signature, secret),
- {:ok, payload} <- decode_payload(raw_body),
- {:ok, event} <- Providers.handle_webhook_event(provider, payload),
- {:ok, _result} <- WebhookProcessor.process(event) do
- Logger.info("Webhook processed successfully: #{provider} - #{event.type}")
-
- conn
- |> put_status(200)
- |> json(%{status: "ok"})
- else
- {:error, :invalid_signature} ->
- Logger.warning("Invalid webhook signature from #{provider}")
-
- conn
- |> put_status(401)
- |> json(%{error: "Invalid signature"})
-
- {:error, :duplicate_event} ->
- # Duplicate events are OK - return 200 to prevent retries
- Logger.debug("Duplicate webhook event from #{provider}")
-
- conn
- |> put_status(200)
- |> json(%{status: "duplicate"})
-
- {:error, :unknown_event} ->
- # Unknown events are OK - return 200 to prevent retries
- Logger.debug("Unknown webhook event type from #{provider}")
-
- conn
- |> put_status(200)
- |> json(%{status: "ignored"})
-
- {:error, :not_configured} ->
- Logger.warning("Webhook received for unconfigured provider: #{provider}")
-
- conn
- |> put_status(400)
- |> json(%{error: "Provider not configured"})
-
- {:error, reason} ->
- Logger.error("Webhook processing failed for #{provider}: #{inspect(reason)}")
-
- conn
- |> put_status(400)
- |> json(%{error: "Processing failed"})
- end
- end
-
- defp get_raw_body(conn) do
- case conn.assigns[:raw_body] do
- nil ->
- # Try to read from body_params if raw_body not set
- # This is a fallback - ideally raw_body should be set by a Plug
- {:error, :no_raw_body}
-
- raw_body when is_binary(raw_body) ->
- {:ok, raw_body}
- end
- end
-
- defp get_signature(conn, header_name) do
- case get_req_header(conn, header_name) do
- [signature | _] -> {:ok, signature}
- [] -> {:error, :no_signature}
- end
- end
-
- defp get_webhook_secret(provider) do
- key = "billing_#{provider}_webhook_secret"
-
- case Settings.get_setting(key, "") do
- "" -> {:error, :not_configured}
- secret -> {:ok, secret}
- end
- end
-
- defp verify_signature(provider, raw_body, signature, secret) do
- Providers.verify_webhook_signature(provider, raw_body, signature, secret)
- end
-
- defp decode_payload(raw_body) do
- case Jason.decode(raw_body) do
- {:ok, payload} -> {:ok, payload}
- {:error, _} -> {:error, :invalid_json}
- end
- end
-end
diff --git a/lib/modules/billing/workers/subscription_dunning_worker.ex b/lib/modules/billing/workers/subscription_dunning_worker.ex
deleted file mode 100644
index 990b26ea7..000000000
--- a/lib/modules/billing/workers/subscription_dunning_worker.ex
+++ /dev/null
@@ -1,212 +0,0 @@
-defmodule PhoenixKit.Modules.Billing.Workers.SubscriptionDunningWorker do
- @moduledoc """
- Oban worker for dunning (failed payment recovery).
-
- When a subscription payment fails, the subscription enters `past_due` status
- and this worker handles retry attempts during the grace period.
-
- ## Dunning Process
-
- 1. Initial payment fails → subscription status = `past_due`
- 2. Grace period starts (configurable, default 3 days)
- 3. This worker retries payment at intervals
- 4. If payment succeeds → status = `active`
- 5. If max attempts reached or grace period ends → status = `cancelled`
-
- ## Retry Schedule
-
- Default retry schedule (can be configured):
- - Attempt 1: Immediate (handled by RenewalWorker)
- - Attempt 2: 24 hours later
- - Attempt 3: 48 hours later (2 days)
- - Attempt 4: 72 hours later (3 days, grace period ends)
-
- ## Configuration
-
- ```elixir
- # Settings (stored in database)
- billing_subscription_grace_days: 3
- billing_dunning_max_attempts: 3
- ```
-
- ## Manual Trigger
-
- ```elixir
- %{subscription_uuid: "019145a1-0000-7000-8000-000000000001"}
- |> SubscriptionDunningWorker.new()
- |> Oban.insert()
- ```
- """
-
- use Oban.Worker,
- queue: :billing,
- max_attempts: 5,
- unique: [period: 3600, keys: [:subscription_uuid]]
-
- alias PhoenixKit.Modules.Billing.{PaymentMethod, Providers, Subscription, SubscriptionType}
- alias PhoenixKit.RepoHelper
- alias PhoenixKit.Settings
- alias PhoenixKit.Utils.Date, as: UtilsDate
-
- require Logger
-
- @impl Oban.Worker
- def perform(%Oban.Job{args: args}) do
- subscription_uuid = Map.get(args, "subscription_uuid") || Map.get(args, "subscription_id")
-
- case get_subscription_with_preloads(subscription_uuid) do
- nil ->
- Logger.warning("Subscription #{subscription_uuid} not found for dunning")
- :ok
-
- subscription ->
- process_dunning(subscription)
- end
- end
-
- # ============================================
- # Dunning Processing
- # ============================================
-
- defp process_dunning(%Subscription{status: "cancelled"}) do
- # Already cancelled, nothing to do
- :ok
- end
-
- defp process_dunning(%Subscription{status: status}) when status not in ["past_due"] do
- # Not in past_due status, skip
- :ok
- end
-
- defp process_dunning(%Subscription{} = subscription) do
- max_attempts = get_max_attempts()
-
- cond do
- subscription.renewal_attempts >= max_attempts ->
- Logger.info("Subscription #{subscription.uuid} exceeded max dunning attempts, cancelling")
- cancel_subscription(subscription, "Max payment retry attempts exceeded")
-
- Subscription.grace_period_expired?(subscription) ->
- Logger.info("Subscription #{subscription.uuid} grace period expired, cancelling")
- cancel_subscription(subscription, "Grace period expired")
-
- true ->
- attempt_payment_retry(subscription)
- end
- end
-
- defp attempt_payment_retry(%Subscription{payment_method: nil} = subscription) do
- Logger.warning("Subscription #{subscription.uuid} has no payment method for retry")
- # Still schedule next retry in case user adds payment method
- schedule_next_retry(subscription)
- {:ok, :no_payment_method}
- end
-
- defp attempt_payment_retry(%Subscription{} = subscription) do
- pm = subscription.payment_method
-
- if PaymentMethod.usable?(pm) do
- Logger.info(
- "Attempting payment retry ##{subscription.renewal_attempts + 1} for subscription #{subscription.uuid}"
- )
-
- case charge_subscription(subscription) do
- {:ok, _result} ->
- Logger.info("Dunning payment successful for subscription #{subscription.uuid}")
- reactivate_subscription(subscription)
-
- {:error, reason} ->
- Logger.warning(
- "Dunning payment failed for subscription #{subscription.uuid}: #{inspect(reason)}"
- )
-
- update_retry_count(subscription)
- schedule_next_retry(subscription)
- {:error, reason}
- end
- else
- Logger.warning(
- "Payment method not usable for subscription #{subscription.uuid}: #{inspect(pm.status)}"
- )
-
- schedule_next_retry(subscription)
- {:error, :payment_method_not_usable}
- end
- end
-
- defp charge_subscription(%Subscription{} = subscription) do
- plan = subscription.subscription_type
- pm = subscription.payment_method
-
- # Providers.charge_payment_method expects the payment_method map with :provider key
- Providers.charge_payment_method(pm, plan.price,
- currency: plan.currency,
- description: "Subscription renewal (dunning retry)",
- metadata: %{
- subscription_uuid: subscription.uuid,
- retry_attempt: subscription.renewal_attempts + 1
- }
- )
- end
-
- defp reactivate_subscription(%Subscription{} = subscription) do
- plan = subscription.subscription_type
- new_period_start = subscription.current_period_end
- new_period_end = SubscriptionType.next_billing_date(plan, DateTime.to_date(new_period_start))
-
- subscription
- |> Subscription.activate_changeset(datetime_from_date(new_period_end))
- |> RepoHelper.repo().update()
- end
-
- defp update_retry_count(%Subscription{} = subscription) do
- subscription
- |> Ecto.Changeset.change(%{
- renewal_attempts: subscription.renewal_attempts + 1,
- last_renewal_attempt_at: UtilsDate.utc_now()
- })
- |> RepoHelper.repo().update()
- end
-
- defp cancel_subscription(%Subscription{} = subscription, reason) do
- Logger.info("Cancelling subscription #{subscription.uuid}: #{reason}")
-
- subscription
- |> Subscription.cancel_changeset(true)
- |> RepoHelper.repo().update()
- end
-
- defp schedule_next_retry(%Subscription{} = subscription) do
- max_attempts = get_max_attempts()
-
- if subscription.renewal_attempts < max_attempts do
- # Schedule next retry in 24 hours
- %{subscription_uuid: subscription.uuid}
- |> __MODULE__.new(schedule_in: 86_400)
- |> Oban.insert()
- end
- end
-
- # ============================================
- # Queries & Helpers
- # ============================================
-
- defp get_subscription_with_preloads(uuid) when is_binary(uuid) do
- import Ecto.Query
-
- from(s in Subscription,
- where: s.uuid == ^uuid,
- preload: [:subscription_type, :payment_method]
- )
- |> RepoHelper.repo().one()
- end
-
- defp get_max_attempts do
- Settings.get_setting("billing_dunning_max_attempts", "3")
- |> String.to_integer()
- end
-
- defp datetime_from_date(date) do
- DateTime.new!(date, ~T[00:00:00], "Etc/UTC")
- end
-end
diff --git a/lib/modules/billing/workers/subscription_renewal_worker.ex b/lib/modules/billing/workers/subscription_renewal_worker.ex
deleted file mode 100644
index 6f654ad74..000000000
--- a/lib/modules/billing/workers/subscription_renewal_worker.ex
+++ /dev/null
@@ -1,269 +0,0 @@
-defmodule PhoenixKit.Modules.Billing.Workers.SubscriptionRenewalWorker do
- @moduledoc """
- Oban worker for processing subscription renewals.
-
- This worker runs daily and handles:
- - Finding subscriptions due for renewal (within 24 hours of period end)
- - Creating invoices for the renewal
- - Charging saved payment methods via providers
- - Updating subscription periods on success
- - Moving to past_due status on failure
-
- ## Scheduling
-
- The worker should be scheduled to run daily via Oban crontab:
-
- ```elixir
- config :my_app, Oban,
- queues: [default: 10, billing: 5],
- plugins: [
- {Oban.Plugins.Cron,
- crontab: [
- {"0 6 * * *", PhoenixKit.Modules.Billing.Workers.SubscriptionRenewalWorker}
- ]}
- ]
- ```
-
- ## Process Flow
-
- 1. Query subscriptions where `current_period_end` is within 24 hours
- 2. For each subscription:
- a. Skip if cancel_at_period_end is true
- b. Create renewal invoice
- c. Charge saved payment method
- d. On success: extend period_end, update invoice as paid
- e. On failure: set past_due, schedule dunning
-
- ## Manual Trigger
-
- Can be triggered manually for a specific subscription:
-
- ```elixir
- %{subscription_uuid: "019145a1-0000-7000-8000-000000000001"}
- |> SubscriptionRenewalWorker.new()
- |> Oban.insert()
- ```
- """
-
- use Oban.Worker,
- queue: :billing,
- max_attempts: 3,
- unique: [period: 3600]
-
- alias PhoenixKit.Modules.Billing
- alias PhoenixKit.Modules.Billing.{PaymentMethod, Providers, Subscription, SubscriptionType}
- alias PhoenixKit.Modules.Billing.Workers.SubscriptionDunningWorker
- alias PhoenixKit.RepoHelper
- alias PhoenixKit.Settings
- alias PhoenixKit.Utils.Date, as: UtilsDate
-
- require Logger
-
- @impl Oban.Worker
- def perform(%Oban.Job{args: %{"subscription_uuid" => subscription_uuid}}) do
- # Process single subscription
- case get_subscription(subscription_uuid) do
- nil ->
- Logger.warning("Subscription #{subscription_uuid} not found for renewal")
- :ok
-
- subscription ->
- process_subscription_renewal(subscription)
- end
- end
-
- def perform(%Oban.Job{args: %{"subscription_id" => subscription_uuid}}) do
- # Backward compat for in-flight jobs
- case get_subscription(subscription_uuid) do
- nil ->
- Logger.warning("Subscription #{subscription_uuid} not found for renewal")
- :ok
-
- subscription ->
- process_subscription_renewal(subscription)
- end
- end
-
- def perform(%Oban.Job{args: _args}) do
- # Process all due subscriptions (daily batch)
- subscriptions = find_subscriptions_due_for_renewal()
- Logger.info("Found #{length(subscriptions)} subscriptions due for renewal")
-
- Enum.each(subscriptions, fn subscription ->
- case process_subscription_renewal(subscription) do
- {:ok, _} ->
- Logger.info("Renewed subscription #{subscription.uuid}")
-
- {:error, reason} ->
- Logger.warning("Failed to renew subscription #{subscription.uuid}: #{inspect(reason)}")
- end
- end)
-
- :ok
- end
-
- # ============================================
- # Renewal Processing
- # ============================================
-
- defp process_subscription_renewal(%Subscription{cancel_at_period_end: true} = subscription) do
- # Subscription marked for cancellation - don't renew, cancel now
- Logger.info("Subscription #{subscription.uuid} marked for cancellation, cancelling now")
-
- subscription
- |> Subscription.cancel_changeset(true)
- |> RepoHelper.repo().update()
- end
-
- defp process_subscription_renewal(%Subscription{} = subscription) do
- repo = RepoHelper.repo()
-
- with {:ok, subscription} <- repo.preload(subscription, [:subscription_type, :payment_method]),
- {:ok, invoice} <- create_renewal_invoice(subscription),
- {:ok, _} <- charge_payment_method(subscription, invoice) do
- # Payment successful - extend period
- plan = subscription.subscription_type
- new_period_start = subscription.current_period_end
-
- new_period_end =
- SubscriptionType.next_billing_date(plan, DateTime.to_date(new_period_start))
-
- subscription
- |> Subscription.activate_changeset(datetime_from_date(new_period_end))
- |> repo.update()
- else
- {:error, :no_payment_method} ->
- Logger.warning("Subscription #{subscription.uuid} has no payment method")
- handle_payment_failure(subscription, "No payment method configured")
-
- {:error, reason} ->
- handle_payment_failure(subscription, inspect(reason))
- end
- end
-
- defp create_renewal_invoice(%Subscription{subscription_type: nil}) do
- {:error, :no_plan}
- end
-
- defp create_renewal_invoice(%Subscription{} = subscription) do
- plan = subscription.subscription_type
-
- line_items = [
- %{
- "name" => "#{plan.name} subscription",
- "description" => "#{SubscriptionType.interval_description(plan)}",
- "quantity" => 1,
- "unit_price" => plan.price,
- "total" => plan.price
- }
- ]
-
- invoice_attrs = %{
- billing_profile_uuid: subscription.billing_profile_uuid,
- currency: plan.currency,
- status: "sent",
- due_date: Date.utc_today(),
- notes: "Subscription renewal: #{plan.name}",
- line_items: line_items,
- subtotal: plan.price,
- total: plan.price
- }
-
- case Billing.create_invoice(subscription.user_uuid, invoice_attrs) do
- {:ok, invoice} -> {:ok, invoice}
- error -> error
- end
- end
-
- defp charge_payment_method(%Subscription{payment_method: nil}, _invoice) do
- {:error, :no_payment_method}
- end
-
- defp charge_payment_method(%Subscription{payment_method: pm} = subscription, invoice) do
- if PaymentMethod.usable?(pm) do
- # Providers.charge_payment_method expects the payment_method map with :provider key
- case Providers.charge_payment_method(pm, invoice.total,
- currency: invoice.currency,
- description: "Subscription renewal",
- metadata: %{
- invoice_uuid: invoice.uuid,
- subscription_uuid: subscription.uuid
- }
- ) do
- {:ok, charge_result} ->
- # Record payment on invoice
- payment_attrs = %{
- amount: invoice.total,
- payment_method: pm.provider,
- description: "Subscription renewal payment",
- provider_transaction_id: charge_result.provider_transaction_id,
- provider_data: charge_result
- }
-
- Billing.record_payment(invoice, payment_attrs, nil)
-
- {:error, reason} ->
- {:error, reason}
- end
- else
- {:error, :payment_method_not_usable}
- end
- end
-
- defp handle_payment_failure(%Subscription{} = subscription, error_message) do
- grace_days =
- Settings.get_setting("billing_subscription_grace_days", "3") |> String.to_integer()
-
- grace_period_end = DateTime.add(UtilsDate.utc_now(), grace_days, :day)
-
- Logger.warning(
- "Subscription #{subscription.uuid} renewal failed: #{error_message}. Grace period until #{grace_period_end}"
- )
-
- result =
- subscription
- |> Subscription.past_due_changeset(grace_period_end)
- |> RepoHelper.repo().update()
-
- # Schedule dunning job
- schedule_dunning(subscription.uuid)
-
- result
- end
-
- defp schedule_dunning(subscription_uuid) do
- # Schedule dunning worker to retry in 24 hours
- %{subscription_uuid: subscription_uuid}
- |> SubscriptionDunningWorker.new(schedule_in: 86_400)
- |> Oban.insert()
- end
-
- # ============================================
- # Queries
- # ============================================
-
- defp find_subscriptions_due_for_renewal do
- import Ecto.Query
-
- # Find subscriptions where:
- # - Status is active or trialing
- # - Period end is within next 24 hours
- # - Not already marked for cancellation
- cutoff = DateTime.add(UtilsDate.utc_now(), 24, :hour)
-
- from(s in Subscription,
- where: s.status in ["active", "trialing"],
- where: s.current_period_end <= ^cutoff,
- where: s.cancel_at_period_end == false
- )
- |> RepoHelper.repo().all()
- end
-
- defp get_subscription(uuid) when is_binary(uuid) do
- RepoHelper.repo().get_by(Subscription, uuid: uuid)
- end
-
- defp datetime_from_date(date) do
- DateTime.new!(date, ~T[00:00:00], "Etc/UTC")
- end
-end
diff --git a/lib/modules/languages/languages.ex b/lib/modules/languages/languages.ex
index 269f7268b..9831b490a 100644
--- a/lib/modules/languages/languages.ex
+++ b/lib/modules/languages/languages.ex
@@ -132,8 +132,9 @@ defmodule PhoenixKit.Modules.Languages do
%Language{code: "ko", name: "Korean", is_default: false, is_enabled: true},
%Language{code: "ru", name: "Russian", is_default: false, is_enabled: true},
%Language{code: "nl", name: "Dutch", is_default: false, is_enabled: true},
- %Language{code: "zh-CN", name: "Chinese (Mandarin)", is_default: false, is_enabled: true},
- %Language{code: "ar", name: "Arabic", is_default: false, is_enabled: true}
+ %Language{code: "zh", name: "Chinese", is_default: false, is_enabled: true},
+ %Language{code: "ar", name: "Arabic", is_default: false, is_enabled: true},
+ %Language{code: "et", name: "Estonian", is_default: false, is_enabled: true}
]
## --- System Management Functions ---
@@ -514,7 +515,7 @@ defmodule PhoenixKit.Modules.Languages do
## Examples
iex> PhoenixKit.Modules.Languages.get_default_language_codes()
- ["en-US", "es-ES", "fr-FR", "de-DE", "pt-BR", "it", "nl", "ru", "ja", "ko", "zh-CN", "ar"]
+ ["en-US", "es-ES", "fr-FR", "de-DE", "pt-BR", "it", "nl", "ru", "ja", "ko", "zh", "ar", "et"]
"""
def get_default_language_codes do
@top_10_languages
diff --git a/lib/modules/legal/legal.ex b/lib/modules/legal/legal.ex
index 7f7d209f4..0ac5be898 100644
--- a/lib/modules/legal/legal.ex
+++ b/lib/modules/legal/legal.ex
@@ -569,6 +569,7 @@ defmodule PhoenixKit.Modules.Legal do
- cookie_policy_url: string (backward compat, derived from published pages)
- privacy_policy_url: string (backward compat, derived from published pages)
- legal_links: list of %{title: string, url: string} for all published legal pages
+ - legal_index_url: string
"""
@spec get_consent_widget_config() :: map()
def get_consent_widget_config do
diff --git a/lib/modules/shop/events.ex b/lib/modules/shop/events.ex
deleted file mode 100644
index 15bad15c1..000000000
--- a/lib/modules/shop/events.ex
+++ /dev/null
@@ -1,381 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Events do
- @moduledoc """
- PubSub event broadcasting for Shop module.
-
- This module provides functions to broadcast cart changes across
- multiple browser tabs and devices for the same user/session, as well
- as product, category, and inventory updates for real-time admin dashboards.
-
- ## Topics
-
- - `shop:cart:user:{user_uuid}` - Cart events for authenticated users
- - `shop:cart:session:{session_id}` - Cart events for guest sessions
- - `shop:products` - Product events (created, updated, deleted)
- - `shop:categories` - Category events (created, updated, deleted)
- - `shop:inventory` - Inventory events (stock changes)
- - `shop:products:{product_uuid}` - Individual product events
-
- ## Events
-
- ### Cart Events
- - `{:cart_updated, cart}` - Cart totals changed (generic update)
- - `{:item_added, cart, item}` - Item added to cart
- - `{:item_removed, cart, item_uuid}` - Item removed from cart
- - `{:quantity_updated, cart, item}` - Item quantity changed
- - `{:shipping_selected, cart}` - Shipping method selected/changed
- - `{:payment_selected, cart}` - Payment option selected/changed
- - `{:cart_cleared, cart}` - All items removed from cart
-
- ### Product Events
- - `{:product_created, product}` - New product created
- - `{:product_updated, product}` - Product updated
- - `{:product_deleted, product_uuid}` - Product deleted
- - `{:products_bulk_status_changed, product_uuids, status}` - Bulk status update
-
- ### Category Events
- - `{:category_created, category}` - New category created
- - `{:category_updated, category}` - Category updated
- - `{:category_deleted, category_uuid}` - Category deleted
-
- ### Inventory Events
- - `{:inventory_updated, product_uuid, stock_change}` - Stock level changed
-
- ## Examples
-
- # Subscribe to cart updates for authenticated user
- Events.subscribe_to_user_cart(user_uuid)
-
- # Subscribe to cart updates for guest session
- Events.subscribe_to_session_cart(session_id)
-
- # Subscribe to product updates (admin dashboard)
- Events.subscribe_products()
-
- # Broadcast item added
- Events.broadcast_item_added(cart, item)
-
- # Broadcast product created
- Events.broadcast_product_created(product)
-
- # Handle in LiveView
- def handle_info({:item_added, cart, _item}, socket) do
- {:noreply, assign(socket, :cart, cart)}
- end
- """
-
- alias PhoenixKit.Modules.Shop.Cart
- alias PhoenixKit.PubSub.Manager
-
- # ============================================
- # TOPIC CONSTANTS
- # ============================================
-
- @products_topic "shop:products"
- @categories_topic "shop:categories"
- @inventory_topic "shop:inventory"
-
- # ============================================
- # TOPIC GETTERS
- # ============================================
-
- @doc """
- Returns the PubSub topic for all products.
- """
- def products_topic, do: @products_topic
-
- @doc """
- Returns the PubSub topic for all categories.
- """
- def categories_topic, do: @categories_topic
-
- @doc """
- Returns the PubSub topic for inventory events.
- """
- def inventory_topic, do: @inventory_topic
-
- # ============================================
- # TOPIC BUILDERS
- # ============================================
-
- @doc """
- Returns the PubSub topic for a user's cart.
- """
- def user_cart_topic(user_uuid) when not is_nil(user_uuid) do
- "shop:cart:user:#{user_uuid}"
- end
-
- @doc """
- Returns the PubSub topic for a session's cart.
- """
- def session_cart_topic(session_id) when not is_nil(session_id) do
- "shop:cart:session:#{session_id}"
- end
-
- @doc """
- Returns the appropriate topic(s) for a cart.
- """
- def cart_topics(%Cart{user_uuid: user_uuid, session_id: session_id}) do
- topics = []
- topics = if user_uuid, do: [user_cart_topic(user_uuid) | topics], else: topics
- topics = if session_id, do: [session_cart_topic(session_id) | topics], else: topics
- topics
- end
-
- @doc """
- Returns the PubSub topic for a specific product.
- """
- def product_topic(product_uuid) when not is_nil(product_uuid) do
- "#{@products_topic}:#{product_uuid}"
- end
-
- # ============================================
- # SUBSCRIPTION FUNCTIONS
- # ============================================
-
- # --------------------------------------------
- # Product Subscriptions
- # --------------------------------------------
-
- @doc """
- Subscribes to product events.
- """
- def subscribe_products do
- Manager.subscribe(@products_topic)
- end
-
- @doc """
- Subscribes to events for a specific product.
- """
- def subscribe_product(product_uuid) when not is_nil(product_uuid) do
- Manager.subscribe(product_topic(product_uuid))
- end
-
- # --------------------------------------------
- # Category Subscriptions
- # --------------------------------------------
-
- @doc """
- Subscribes to category events.
- """
- def subscribe_categories do
- Manager.subscribe(@categories_topic)
- end
-
- # --------------------------------------------
- # Inventory Subscriptions
- # --------------------------------------------
-
- @doc """
- Subscribes to inventory events.
- """
- def subscribe_inventory do
- Manager.subscribe(@inventory_topic)
- end
-
- @doc """
- Subscribes to cart events for a specific cart.
- Subscribes to all relevant topics (user and/or session).
- """
- def subscribe_to_cart(%Cart{} = cart) do
- cart
- |> cart_topics()
- |> Enum.each(&Manager.subscribe/1)
- end
-
- @doc """
- Subscribes to cart events for an authenticated user.
- """
- def subscribe_to_user_cart(user_uuid) when not is_nil(user_uuid) do
- Manager.subscribe(user_cart_topic(user_uuid))
- end
-
- @doc """
- Subscribes to cart events for a guest session.
- """
- def subscribe_to_session_cart(session_id) when not is_nil(session_id) do
- Manager.subscribe(session_cart_topic(session_id))
- end
-
- @doc """
- Unsubscribes from cart events for a specific cart.
- """
- def unsubscribe_from_cart(%Cart{} = cart) do
- cart
- |> cart_topics()
- |> Enum.each(&Manager.unsubscribe/1)
- end
-
- @doc """
- Unsubscribes from cart events for an authenticated user.
- """
- def unsubscribe_from_user_cart(user_uuid) when not is_nil(user_uuid) do
- Manager.unsubscribe(user_cart_topic(user_uuid))
- end
-
- @doc """
- Unsubscribes from cart events for a guest session.
- """
- def unsubscribe_from_session_cart(session_id) when not is_nil(session_id) do
- Manager.unsubscribe(session_cart_topic(session_id))
- end
-
- # ============================================
- # PRODUCT BROADCAST FUNCTIONS
- # ============================================
-
- @doc """
- Broadcasts product created event.
- """
- def broadcast_product_created(product) do
- broadcast(@products_topic, {:product_created, product})
- end
-
- @doc """
- Broadcasts product updated event.
- """
- def broadcast_product_updated(product) do
- broadcast(@products_topic, {:product_updated, product})
- broadcast(product_topic(product.uuid), {:product_updated, product})
- end
-
- @doc """
- Broadcasts product deleted event.
- """
- def broadcast_product_deleted(product_uuid) do
- broadcast(@products_topic, {:product_deleted, product_uuid})
- end
-
- @doc """
- Broadcasts bulk product status changed event.
- """
- def broadcast_products_bulk_status_changed(product_uuids, status) do
- broadcast(@products_topic, {:products_bulk_status_changed, product_uuids, status})
- end
-
- # ============================================
- # CATEGORY BROADCAST FUNCTIONS
- # ============================================
-
- @doc """
- Broadcasts category created event.
- """
- def broadcast_category_created(category) do
- broadcast(@categories_topic, {:category_created, category})
- end
-
- @doc """
- Broadcasts category updated event.
- """
- def broadcast_category_updated(category) do
- broadcast(@categories_topic, {:category_updated, category})
- end
-
- @doc """
- Broadcasts category deleted event.
- """
- def broadcast_category_deleted(category_uuid) do
- broadcast(@categories_topic, {:category_deleted, category_uuid})
- end
-
- @doc """
- Broadcasts bulk category status changed event.
- """
- def broadcast_categories_bulk_status_changed(category_ids, status) do
- broadcast(@categories_topic, {:categories_bulk_status_changed, category_ids, status})
- end
-
- @doc """
- Broadcasts bulk category parent changed event.
- """
- def broadcast_categories_bulk_parent_changed(category_ids, parent_uuid) do
- broadcast(@categories_topic, {:categories_bulk_parent_changed, category_ids, parent_uuid})
- end
-
- @doc """
- Broadcasts bulk category deleted event.
- """
- def broadcast_categories_bulk_deleted(category_ids) do
- broadcast(@categories_topic, {:categories_bulk_deleted, category_ids})
- end
-
- # ============================================
- # INVENTORY BROADCAST FUNCTIONS
- # ============================================
-
- @doc """
- Broadcasts inventory updated event.
- """
- def broadcast_inventory_updated(product_uuid, stock_change) do
- broadcast(@inventory_topic, {:inventory_updated, product_uuid, stock_change})
- broadcast(product_topic(product_uuid), {:inventory_updated, product_uuid, stock_change})
- end
-
- # ============================================
- # CART BROADCAST FUNCTIONS
- # ============================================
-
- @doc """
- Broadcasts a generic cart update event.
- """
- def broadcast_cart_updated(%Cart{} = cart) do
- broadcast_to_cart(cart, {:cart_updated, cart})
- end
-
- @doc """
- Broadcasts item added event.
- """
- def broadcast_item_added(%Cart{} = cart, item) do
- broadcast_to_cart(cart, {:item_added, cart, item})
- end
-
- @doc """
- Broadcasts item removed event.
- """
- def broadcast_item_removed(%Cart{} = cart, item_uuid) do
- broadcast_to_cart(cart, {:item_removed, cart, item_uuid})
- end
-
- @doc """
- Broadcasts quantity updated event.
- """
- def broadcast_quantity_updated(%Cart{} = cart, item) do
- broadcast_to_cart(cart, {:quantity_updated, cart, item})
- end
-
- @doc """
- Broadcasts shipping method selected event.
- """
- def broadcast_shipping_selected(%Cart{} = cart) do
- broadcast_to_cart(cart, {:shipping_selected, cart})
- end
-
- @doc """
- Broadcasts payment option selected event.
- """
- def broadcast_payment_selected(%Cart{} = cart) do
- broadcast_to_cart(cart, {:payment_selected, cart})
- end
-
- @doc """
- Broadcasts cart cleared event.
- """
- def broadcast_cart_cleared(%Cart{} = cart) do
- broadcast_to_cart(cart, {:cart_cleared, cart})
- end
-
- # ============================================
- # PRIVATE FUNCTIONS
- # ============================================
-
- defp broadcast_to_cart(%Cart{} = cart, message) do
- cart
- |> cart_topics()
- |> Enum.each(fn topic ->
- Manager.broadcast(topic, message)
- end)
- end
-
- defp broadcast(topic, message) do
- Manager.broadcast(topic, message)
- end
-end
diff --git a/lib/modules/shop/import/csv_analyzer.ex b/lib/modules/shop/import/csv_analyzer.ex
deleted file mode 100644
index 985f0d072..000000000
--- a/lib/modules/shop/import/csv_analyzer.ex
+++ /dev/null
@@ -1,216 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.CSVAnalyzer do
- @moduledoc """
- Analyze Shopify CSV files to extract option metadata.
-
- Extracts all Option1..Option10 names and unique values from CSV
- for use in the import mapping UI.
-
- ## Usage
-
- CSVAnalyzer.analyze_options("/path/to/products.csv")
- # => %{
- # options: [
- # %{name: "Size", position: 1, values: ["Small", "Medium", "Large"]},
- # %{name: "Color", position: 2, values: ["Red", "Blue", "Green"]}
- # ],
- # total_products: 150,
- # total_variants: 450
- # }
- """
-
- alias PhoenixKit.Modules.Shop.Import.CSVParser
- alias PhoenixKit.Modules.Shop.Import.Filter
-
- @max_options 10
-
- @doc """
- Analyzes a CSV file and extracts option metadata.
-
- Returns a map with:
- - `options` - List of option definitions with name, position, and unique values
- - `total_products` - Number of unique product handles
- - `total_variants` - Total number of variant rows
-
- ## Examples
-
- CSVAnalyzer.analyze_options("/tmp/products.csv")
- # => %{
- # options: [
- # %{name: "Size", position: 1, values: ["S", "M", "L", "XL"]},
- # %{name: "Cup Color", position: 2, values: ["Red", "Blue"]},
- # %{name: "Liquid Color", position: 3, values: ["Clear", "Amber"]}
- # ],
- # total_products: 50,
- # total_variants: 200
- # }
- """
- def analyze_options(file_path, config \\ nil) do
- grouped = CSVParser.parse_and_group(file_path)
-
- # Apply import config filter if provided and not skipped
- {filtered, skipped_count} =
- if config && !config.skip_filter do
- filtered =
- grouped
- |> Enum.filter(fn {_handle, rows} -> Filter.should_include?(rows, config) end)
- |> Map.new()
-
- {filtered, map_size(grouped) - map_size(filtered)}
- else
- {grouped, 0}
- end
-
- # Group options by NAME instead of position
- # This handles cases where different products use Option1 for different purposes
- {option_data, total_variants} =
- Enum.reduce(filtered, {%{}, 0}, fn {_handle, rows}, {acc, variant_count} ->
- # Get option names and values from all rows
- first_row = List.first(rows)
- variant_rows = Enum.filter(rows, &has_price?/1)
-
- # Collect options by name
- acc = collect_options_by_name(acc, first_row, variant_rows)
-
- {acc, variant_count + length(variant_rows)}
- end)
-
- # Convert to output format, sorted by name
- options =
- option_data
- |> Enum.sort_by(fn {name, _} -> String.downcase(name) end)
- |> Enum.with_index(1)
- |> Enum.map(fn {{name, values}, index} ->
- %{
- name: name,
- position: index,
- values: MapSet.to_list(values) |> Enum.sort()
- }
- end)
-
- %{
- options: options,
- total_products: map_size(filtered),
- total_variants: total_variants,
- total_skipped: skipped_count
- }
- end
-
- @doc """
- Quick analysis - only extracts option names without values.
-
- Faster than full analysis, useful for initial UI display.
- """
- def analyze_option_names(file_path) do
- # Read just the first few rows to get option names
- grouped = CSVParser.parse_and_group(file_path)
-
- # Get first product's first row
- first_product_rows = grouped |> Map.values() |> List.first() || []
- first_row = List.first(first_product_rows) || %{}
-
- # Extract option names
- for i <- 1..@max_options,
- name = get_option_name(first_row, i),
- name != nil do
- %{name: name, position: i}
- end
- end
-
- @doc """
- Compares CSV option values with global option values.
-
- Returns a map showing which values are new (not in global option).
-
- ## Examples
-
- CSVAnalyzer.compare_with_global_option(csv_values, global_option)
- # => %{
- # existing: ["Red", "Blue"],
- # new: ["Yellow", "Purple"]
- # }
- """
- def compare_with_global_option(csv_values, global_option) when is_list(csv_values) do
- global_values = extract_global_option_values(global_option)
- global_set = MapSet.new(global_values)
-
- csv_set = MapSet.new(csv_values)
-
- existing = MapSet.intersection(csv_set, global_set) |> MapSet.to_list()
- new_values = MapSet.difference(csv_set, global_set) |> MapSet.to_list()
-
- %{
- existing: Enum.sort(existing),
- new: Enum.sort(new_values)
- }
- end
-
- def compare_with_global_option(_, _), do: %{existing: [], new: []}
-
- # Extract values from global option (handles both simple and enhanced format)
- defp extract_global_option_values(nil), do: []
-
- defp extract_global_option_values(%{"options" => options}) when is_list(options) do
- Enum.map(options, fn
- opt when is_binary(opt) -> opt
- %{"value" => value} -> value
- _ -> nil
- end)
- |> Enum.reject(&is_nil/1)
- end
-
- defp extract_global_option_values(_), do: []
-
- # Private helpers
-
- # Collect options grouped by name (not position)
- defp collect_options_by_name(acc, first_row, variant_rows) do
- # Get option names from first row
- option_names =
- for i <- 1..@max_options,
- name = get_option_name(first_row, i),
- name != nil,
- do: {i, name}
-
- # Collect values for each option name
- Enum.reduce(option_names, acc, fn {position, name}, acc ->
- # Get all values for this option from variant rows
- values =
- Enum.reduce(variant_rows, MapSet.new(), fn row, values_acc ->
- case get_option_value(row, position) do
- nil -> values_acc
- "" -> values_acc
- value -> MapSet.put(values_acc, value)
- end
- end)
-
- # Merge with existing values for this option name
- existing = Map.get(acc, name, MapSet.new())
- Map.put(acc, name, MapSet.union(existing, values))
- end)
- end
-
- defp get_option_name(row, position) do
- key = "Option#{position} Name"
-
- case row[key] do
- nil -> nil
- "" -> nil
- name -> String.trim(name)
- end
- end
-
- defp get_option_value(row, position) do
- key = "Option#{position} Value"
-
- case row[key] do
- nil -> nil
- "" -> nil
- value -> String.trim(value)
- end
- end
-
- defp has_price?(row) do
- price = row["Variant Price"]
- price != nil and price != ""
- end
-end
diff --git a/lib/modules/shop/import/csv_parser.ex b/lib/modules/shop/import/csv_parser.ex
deleted file mode 100644
index de5a5b891..000000000
--- a/lib/modules/shop/import/csv_parser.ex
+++ /dev/null
@@ -1,72 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.CSVParser do
- @moduledoc """
- Parse Shopify CSV and group rows by Handle.
-
- Shopify CSV structure:
- - First row with product data contains title, description, etc.
- - Subsequent rows for same Handle contain variant data only (empty title/description)
- - Each variant row has Option1/Option2 values and prices
- """
-
- NimbleCSV.define(ShopifyCSV, separator: ",", escape: "\"")
-
- @doc """
- Parse CSV file and group rows by Handle (product identifier).
-
- Returns a map where keys are handles and values are lists of row maps.
-
- ## Examples
-
- CSVParser.parse_and_group("/path/to/products.csv")
- # => %{
- # "product-handle" => [
- # %{"Handle" => "product-handle", "Title" => "Product", ...},
- # %{"Handle" => "product-handle", "Option1 Value" => "Small", ...},
- # ...
- # ],
- # ...
- # }
- """
- def parse_and_group(file_path) do
- {_headers, rows} =
- file_path
- |> File.stream!([:utf8])
- |> ShopifyCSV.parse_stream(skip_headers: false)
- |> Enum.reduce({nil, []}, fn
- row, {nil, []} ->
- # First row is headers
- {row, []}
-
- row, {headers, rows} ->
- # Convert row to map using headers
- row_map =
- Enum.zip(headers, row)
- |> Map.new()
-
- {headers, [row_map | rows]}
- end)
-
- # Group by Handle and reverse to maintain order
- rows
- |> Enum.reverse()
- |> Enum.group_by(& &1["Handle"])
- end
-
- @doc """
- Get the first (main) row for a product group.
- Contains title, description, and other product-level data.
- """
- def main_row(rows) when is_list(rows) do
- List.first(rows)
- end
-
- @doc """
- Get all variant rows (rows with price data).
- """
- def variant_rows(rows) when is_list(rows) do
- Enum.filter(rows, fn row ->
- price = row["Variant Price"]
- price != nil and price != ""
- end)
- end
-end
diff --git a/lib/modules/shop/import/csv_validator.ex b/lib/modules/shop/import/csv_validator.ex
deleted file mode 100644
index 8440aacb0..000000000
--- a/lib/modules/shop/import/csv_validator.ex
+++ /dev/null
@@ -1,295 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.CSVValidator do
- @moduledoc """
- Validates CSV files before import processing.
-
- Performs early validation to fail fast with meaningful errors
- rather than discovering issues mid-import.
-
- ## Validation Checks
-
- 1. **File exists and readable** - Basic filesystem check
- 2. **CSV parseable** - File is valid CSV format
- 3. **Required columns present** - Checks for Handle, Title, Variant Price by default
- 4. **Warning detection** - Non-blocking issues like empty rows
-
- ## Examples
-
- # Basic validation with default required columns
- case CSVValidator.validate_file("/path/to/products.csv") do
- :ok -> IO.puts("File is valid")
- {:error, reason} -> IO.puts("Validation failed: \#{reason}")
- end
-
- # Validation with custom required columns
- CSVValidator.validate_headers("/path/to/products.csv", ["Handle", "Title", "Price"])
-
- # Full validation report
- report = CSVValidator.get_validation_report("/path/to/products.csv")
- # => %{
- # valid: true,
- # file_path: "/path/to/products.csv",
- # headers: ["Handle", "Title", ...],
- # row_count: 1234,
- # warnings: ["Some rows have empty Handle values"]
- # }
- """
-
- alias PhoenixKit.Modules.Shop.ImportConfig
-
- NimbleCSV.define(ValidatorCSV, separator: ",", escape: "\"")
-
- @default_required_columns ImportConfig.default_required_columns()
-
- @doc """
- Validates that a file exists, is readable, and has valid CSV format.
-
- Returns `:ok` or `{:error, reason}`.
- """
- def validate_file(file_path) do
- with :ok <- check_file_exists(file_path),
- :ok <- check_file_readable(file_path) do
- check_csv_parseable(file_path)
- end
- end
-
- @doc """
- Extracts and validates CSV headers against required columns.
-
- Uses default required columns: #{inspect(@default_required_columns)}
-
- Returns `{:ok, headers}` or `{:error, reason}`.
- """
- def validate_headers(file_path) do
- validate_headers(file_path, @default_required_columns)
- end
-
- @doc """
- Extracts and validates CSV headers against custom required columns.
-
- Returns `{:ok, headers}` or `{:error, {:missing_columns, missing}}`.
- """
- def validate_headers(file_path, required_columns) when is_list(required_columns) do
- with :ok <- validate_file(file_path),
- {:ok, headers} <- extract_headers(file_path) do
- missing = find_missing_columns(headers, required_columns)
-
- if missing == [] do
- {:ok, headers}
- else
- {:error, {:missing_columns, missing}}
- end
- end
- end
-
- @doc """
- Returns a comprehensive validation report.
-
- ## Report Structure
-
- %{
- valid: boolean,
- file_path: string,
- file_size: integer,
- headers: list | nil,
- row_count: integer | nil,
- missing_columns: list,
- warnings: list,
- error: string | nil
- }
- """
- def get_validation_report(file_path, opts \\ []) do
- required_columns = Keyword.get(opts, :required_columns, @default_required_columns)
-
- report = %{
- valid: false,
- file_path: file_path,
- file_size: nil,
- headers: nil,
- row_count: nil,
- missing_columns: [],
- warnings: [],
- error: nil
- }
-
- with :ok <- check_file_exists(file_path),
- {:ok, file_size} <- get_file_size(file_path),
- :ok <- check_file_readable(file_path),
- {:ok, headers} <- extract_headers(file_path),
- {:ok, row_count} <- count_data_rows(file_path) do
- missing = find_missing_columns(headers, required_columns)
- warnings = detect_warnings(file_path, headers)
-
- %{
- report
- | valid: missing == [],
- file_size: file_size,
- headers: headers,
- row_count: row_count,
- missing_columns: missing,
- warnings: warnings
- }
- else
- {:error, reason} ->
- %{report | error: format_error(reason)}
- end
- end
-
- @doc """
- Extracts headers from a CSV file.
-
- Returns `{:ok, headers}` or `{:error, reason}`.
- """
- def extract_headers(file_path) do
- file_path
- |> File.stream!([:utf8])
- |> ValidatorCSV.parse_stream(skip_headers: false)
- |> Enum.take(1)
- |> case do
- [headers] when is_list(headers) ->
- {:ok, headers}
-
- [] ->
- {:error, :empty_file}
-
- _ ->
- {:error, :invalid_csv_format}
- end
- rescue
- e in NimbleCSV.ParseError ->
- {:error, {:parse_error, Exception.message(e)}}
-
- e ->
- {:error, {:unexpected_error, Exception.message(e)}}
- end
-
- # ============================================
- # PRIVATE FUNCTIONS
- # ============================================
-
- defp check_file_exists(file_path) do
- if File.exists?(file_path) do
- :ok
- else
- {:error, :file_not_found}
- end
- end
-
- defp check_file_readable(file_path) do
- # Try to open and read first few bytes to check readability
- case File.open(file_path, [:read, :utf8]) do
- {:ok, file} ->
- result = IO.read(file, 1024)
- File.close(file)
-
- case result do
- {:error, reason} -> {:error, {:file_not_readable, reason}}
- _ -> :ok
- end
-
- {:error, reason} ->
- {:error, {:file_not_readable, reason}}
- end
- end
-
- defp check_csv_parseable(file_path) do
- file_path
- |> File.stream!([:utf8])
- |> ValidatorCSV.parse_stream(skip_headers: false)
- |> Enum.take(2)
- |> case do
- [_ | _] -> :ok
- [] -> {:error, :empty_file}
- end
- rescue
- e in NimbleCSV.ParseError ->
- {:error, {:parse_error, Exception.message(e)}}
-
- _ ->
- {:error, :invalid_csv_format}
- end
-
- defp get_file_size(file_path) do
- case File.stat(file_path) do
- {:ok, %{size: size}} -> {:ok, size}
- {:error, reason} -> {:error, {:stat_error, reason}}
- end
- end
-
- defp count_data_rows(file_path) do
- count =
- file_path
- |> File.stream!([:utf8])
- |> ValidatorCSV.parse_stream(skip_headers: true)
- |> Enum.count()
-
- {:ok, count}
- rescue
- _ -> {:ok, nil}
- end
-
- defp find_missing_columns(headers, required_columns) do
- headers_set = MapSet.new(headers)
-
- required_columns
- |> Enum.reject(fn col -> MapSet.member?(headers_set, col) end)
- end
-
- defp detect_warnings(file_path, headers) do
- warnings = []
-
- # Check for Handle column index
- handle_index = Enum.find_index(headers, &(&1 == "Handle"))
-
- warnings =
- if handle_index do
- empty_handles = count_empty_handles(file_path, handle_index)
-
- if empty_handles > 0 do
- ["#{empty_handles} rows have empty Handle values" | warnings]
- else
- warnings
- end
- else
- warnings
- end
-
- # Check for duplicate headers
- duplicate_headers = find_duplicate_headers(headers)
-
- warnings =
- if duplicate_headers != [] do
- ["Duplicate headers found: #{Enum.join(duplicate_headers, ", ")}" | warnings]
- else
- warnings
- end
-
- Enum.reverse(warnings)
- end
-
- defp count_empty_handles(file_path, handle_index) do
- file_path
- |> File.stream!([:utf8])
- |> ValidatorCSV.parse_stream(skip_headers: true)
- |> Enum.count(fn row ->
- handle = Enum.at(row, handle_index, "")
- handle == nil or String.trim(handle) == ""
- end)
- rescue
- _ -> 0
- end
-
- defp find_duplicate_headers(headers) do
- headers
- |> Enum.frequencies()
- |> Enum.filter(fn {_header, count} -> count > 1 end)
- |> Enum.map(fn {header, _count} -> header end)
- end
-
- defp format_error(:file_not_found), do: "File not found"
- defp format_error(:empty_file), do: "File is empty"
- defp format_error(:invalid_csv_format), do: "Invalid CSV format"
- defp format_error({:file_not_readable, reason}), do: "File not readable: #{reason}"
- defp format_error({:stat_error, reason}), do: "Cannot read file stats: #{reason}"
- defp format_error({:parse_error, msg}), do: "CSV parse error: #{msg}"
- defp format_error({:unexpected_error, msg}), do: "Unexpected error: #{msg}"
-end
diff --git a/lib/modules/shop/import/filter.ex b/lib/modules/shop/import/filter.ex
deleted file mode 100644
index f4473fe67..000000000
--- a/lib/modules/shop/import/filter.ex
+++ /dev/null
@@ -1,201 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.Filter do
- @moduledoc """
- Filter products for import based on configurable rules.
-
- Supports both legacy hardcoded keywords (for backward compatibility)
- and configurable ImportConfig-based filtering.
-
- ## Configuration-based filtering
-
- config = Shop.get_default_import_config()
- Filter.should_include?(rows, config)
- Filter.categorize(title, config)
-
- ## Legacy filtering (backward compatible)
-
- Filter.should_include?(rows) # Uses hardcoded defaults
- Filter.categorize(title) # Uses hardcoded defaults
- """
-
- alias PhoenixKit.Modules.Shop.ImportConfig
-
- # Legacy hardcoded defaults for backward compatibility
- @default_include_keywords ~w(3d printed shelf mask vase planter holder stand lamp light figurine sculpture statue)
- @default_exclude_keywords ~w(decal sticker mural wallpaper poster tapestry canvas)
- @default_exclude_phrases ["wall art"]
-
- @default_category_rules [
- {["shelf"], "shelves"},
- {["mask"], "masks"},
- {["vase", "planter"], "vases-planters"},
- {["holder", "stand"], "holders-stands"},
- {["lamp", "light"], "lamps"},
- {["figurine", "sculpture", "statue"], "figurines"}
- ]
-
- @default_category_slug "other-3d"
-
- # ============================================
- # SHOULD_INCLUDE? FUNCTIONS
- # ============================================
-
- @doc """
- Check if product should be included in import.
-
- ## With config
-
- Filter.should_include?(rows, config)
-
- Returns true if:
- - Config has `skip_filter: true`, OR
- - Title matches at least one include keyword AND
- - Title does NOT match any exclude keyword/phrase
-
- ## Without config (legacy)
-
- Filter.should_include?(rows)
-
- Uses hardcoded default keywords for backward compatibility.
- """
- def should_include?(rows, config \\ nil)
-
- def should_include?(rows, %ImportConfig{skip_filter: true}) when is_list(rows), do: true
-
- def should_include?(rows, %ImportConfig{} = config) when is_list(rows) do
- first_row = List.first(rows)
- title = first_row["Title"] || ""
- handle = first_row["Handle"] || ""
-
- if skip_handle?(handle) do
- false
- else
- has_include_match?(title, config) and not has_exclude_match?(title, config)
- end
- end
-
- def should_include?(rows, nil) when is_list(rows) do
- # Legacy behavior: use hardcoded defaults
- first_row = List.first(rows)
- title = first_row["Title"] || ""
- handle = first_row["Handle"] || ""
-
- if skip_handle?(handle) do
- false
- else
- has_include_match_legacy?(title) and not has_exclude_match_legacy?(title)
- end
- end
-
- # ============================================
- # CATEGORIZE FUNCTIONS
- # ============================================
-
- @doc """
- Categorize product based on title keywords.
-
- ## With config
-
- Filter.categorize(title, config)
-
- Uses category_rules from config. Returns default_category_slug if no match.
-
- ## Without config (legacy)
-
- Filter.categorize(title)
-
- Uses hardcoded category rules. Returns "other-3d" if no match.
- """
- def categorize(title, config \\ nil)
-
- def categorize(title, %ImportConfig{} = config) when is_binary(title) do
- title_lower = String.downcase(title)
-
- find_category_from_config(title_lower, config) || config.default_category_slug ||
- @default_category_slug
- end
-
- def categorize(title, nil) when is_binary(title) do
- # Legacy behavior
- title_lower = String.downcase(title)
- find_category_legacy(title_lower) || @default_category_slug
- end
-
- # ============================================
- # CONFIG-BASED HELPERS
- # ============================================
-
- defp has_include_match?(title, %ImportConfig{include_keywords: keywords}) do
- if keywords == [] do
- # No include keywords = include everything
- true
- else
- title_lower = String.downcase(title)
- Enum.any?(keywords, &String.contains?(title_lower, String.downcase(&1)))
- end
- end
-
- defp has_exclude_match?(title, %ImportConfig{
- exclude_keywords: keywords,
- exclude_phrases: phrases
- }) do
- title_lower = String.downcase(title)
-
- has_keyword = Enum.any?(keywords || [], &String.contains?(title_lower, String.downcase(&1)))
- has_phrase = Enum.any?(phrases || [], &String.contains?(title_lower, String.downcase(&1)))
-
- has_keyword or has_phrase
- end
-
- defp find_category_from_config(title_lower, %ImportConfig{category_rules: rules})
- when is_list(rules) do
- Enum.find_value(rules, fn rule ->
- keywords = rule["keywords"] || rule[:keywords] || []
- slug = rule["slug"] || rule[:slug]
-
- if Enum.any?(keywords, fn kw -> String.contains?(title_lower, String.downcase(kw)) end) do
- slug
- end
- end)
- end
-
- defp find_category_from_config(_title_lower, _config), do: nil
-
- # ============================================
- # LEGACY HELPERS (backward compatibility)
- # ============================================
-
- defp has_include_match_legacy?(title) do
- title_lower = String.downcase(title)
- Enum.any?(@default_include_keywords, &String.contains?(title_lower, &1))
- end
-
- defp has_exclude_match_legacy?(title) do
- title_lower = String.downcase(title)
-
- has_keyword = Enum.any?(@default_exclude_keywords, &String.contains?(title_lower, &1))
- has_phrase = Enum.any?(@default_exclude_phrases, &String.contains?(title_lower, &1))
-
- has_keyword or has_phrase
- end
-
- defp find_category_legacy(title_lower) do
- Enum.find_value(@default_category_rules, fn {keywords, category} ->
- if Enum.any?(keywords, &String.contains?(title_lower, &1)) do
- category
- end
- end)
- end
-
- # ============================================
- # SHARED HELPERS
- # ============================================
-
- defp skip_handle?(handle) do
- handle_lower = String.downcase(handle)
-
- String.contains?(handle_lower, "shipping") or
- String.contains?(handle_lower, "payment") or
- String.contains?(handle_lower, "gift-card") or
- String.contains?(handle_lower, "custom-order")
- end
-end
diff --git a/lib/modules/shop/import/format_detector.ex b/lib/modules/shop/import/format_detector.ex
deleted file mode 100644
index d64bd783f..000000000
--- a/lib/modules/shop/import/format_detector.ex
+++ /dev/null
@@ -1,39 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.FormatDetector do
- @moduledoc """
- Auto-detect CSV format from file headers.
-
- Iterates known format modules and calls `detect?/1` on each.
- First match wins, so order matters.
- """
-
- alias PhoenixKit.Modules.Shop.Import.CSVValidator
- alias PhoenixKit.Modules.Shop.Import.{PromUaFormat, ShopifyFormat}
-
- # Ordered list — first match wins.
- # PromUaFormat first because its markers are more specific (Ukrainian columns).
- @formats [PromUaFormat, ShopifyFormat]
-
- @doc """
- Detect format module from CSV file path.
- Returns `{:ok, format_module}` or `{:error, :unknown_format}`.
- """
- def detect(path) do
- case CSVValidator.extract_headers(path) do
- {:ok, headers} -> detect_from_headers(headers)
- {:error, _} = error -> error
- end
- end
-
- @doc "Detect format module from pre-extracted headers."
- def detect_from_headers(headers) do
- case Enum.find(@formats, & &1.detect?(headers)) do
- nil -> {:error, :unknown_format}
- mod -> {:ok, mod}
- end
- end
-
- @doc "Returns human-readable format name."
- def format_name(ShopifyFormat), do: "Shopify"
- def format_name(PromUaFormat), do: "Prom.ua"
- def format_name(_), do: "Unknown"
-end
diff --git a/lib/modules/shop/import/import_format.ex b/lib/modules/shop/import/import_format.ex
deleted file mode 100644
index 57deb2b40..000000000
--- a/lib/modules/shop/import/import_format.ex
+++ /dev/null
@@ -1,32 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.ImportFormat do
- @moduledoc """
- Behaviour for CSV import format adapters.
-
- All CSV format modules (Shopify, Prom.ua, etc.) implement this behaviour
- to provide a uniform interface for the import pipeline.
- """
-
- alias PhoenixKit.Modules.Shop.ImportConfig
-
- @doc "Returns true if the given CSV headers match this format."
- @callback detect?(headers :: [String.t()]) :: boolean()
-
- @doc "Counts the number of products that will be imported from the file."
- @callback count(path :: String.t(), config :: ImportConfig.t() | nil) :: non_neg_integer()
-
- @doc "Whether the :configure wizard step (option mapping UI) should be shown."
- @callback requires_option_mapping?() :: boolean()
-
- @doc """
- Parses CSV and returns a list/stream of product attrs maps ready for `Shop.upsert_product/1`.
- """
- @callback parse_and_transform(
- path :: String.t(),
- categories_map :: map(),
- config :: ImportConfig.t() | nil,
- opts :: keyword()
- ) :: Enumerable.t()
-
- @doc "Returns default attrs for seeding an ImportConfig for this format."
- @callback default_config_attrs() :: map()
-end
diff --git a/lib/modules/shop/import/option_builder.ex b/lib/modules/shop/import/option_builder.ex
deleted file mode 100644
index fc77064df..000000000
--- a/lib/modules/shop/import/option_builder.ex
+++ /dev/null
@@ -1,280 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.OptionBuilder do
- @moduledoc """
- Build option values and price modifiers from Shopify variant rows.
-
- Extracts Option1..Option10 names and values from CSV rows,
- calculates base price (minimum) and price modifiers (deltas from base).
-
- ## Extended Support
-
- - Supports Option1 through Option10 (Shopify standard)
- - Accepts option_mappings for slot-based options
- - Builds _option_slots structure for products using global options
- """
-
- @max_options 10
-
- @doc """
- Build options data from variant rows (legacy format).
-
- Returns a map with:
- - base_price: minimum variant price (Decimal)
- - option1_name: name of first option (e.g., "Size")
- - option1_values: list of unique values for option1
- - option1_modifiers: map of value => price delta from base
- - option2_name: name of second option (e.g., "Color")
- - option2_values: list of unique values for option2
-
- ## Examples
-
- OptionBuilder.build_from_variants(rows)
- # => %{
- # base_price: Decimal.new("22.80"),
- # option1_name: "Size",
- # option1_values: ["4 inches (10 cm)", "5 inches (13 cm)", ...],
- # option1_modifiers: %{"4 inches (10 cm)" => "0", "5 inches (13 cm)" => "5.00", ...},
- # option2_name: "Color",
- # option2_values: ["Black", "White", ...]
- # }
- """
- def build_from_variants(rows) when is_list(rows) do
- # Get option names from first row
- first_row = List.first(rows)
- option1_name = get_non_empty(first_row, "Option1 Name")
- option2_name = get_non_empty(first_row, "Option2 Name")
-
- # Extract variants with prices
- variants =
- rows
- |> Enum.map(fn row ->
- %{
- option1_value: get_non_empty(row, "Option1 Value"),
- option2_value: get_non_empty(row, "Option2 Value"),
- price: parse_price(row["Variant Price"])
- }
- end)
- |> Enum.filter(& &1.price)
-
- # Calculate base price (minimum)
- base_price =
- variants
- |> Enum.map(& &1.price)
- |> Enum.min(fn -> Decimal.new("0") end)
-
- # Build option1 data (typically Size - affects price)
- {option1_values, option1_modifiers} = build_option_data(variants, :option1_value, base_price)
-
- # Build option2 values (typically Color - no price impact, just values)
- option2_values = get_unique_values(variants, :option2_value)
-
- %{
- base_price: base_price,
- option1_name: option1_name,
- option1_values: option1_values,
- option1_modifiers: option1_modifiers,
- option2_name: option2_name,
- option2_values: option2_values
- }
- end
-
- @doc """
- Build extended options data from variant rows.
-
- Supports Option1 through Option10 and optional slot mappings.
-
- ## Arguments
-
- - `rows` - List of CSV row maps for a single product
- - `opts` - Keyword options:
- - `:option_mappings` - List of mapping configs from ImportConfig
-
- ## Returns
-
- Map with:
- - `base_price` - Minimum variant price
- - `options` - List of option data for each option found
- - `option_slots` - Slot definitions if mappings provided
-
- ## Examples
-
- # Without mappings (standard import)
- OptionBuilder.build_extended(rows)
- # => %{
- # base_price: Decimal.new("22.80"),
- # options: [
- # %{position: 1, name: "Size", values: [...], modifiers: %{...}},
- # %{position: 2, name: "Cup Color", values: [...]},
- # %{position: 3, name: "Liquid Color", values: [...]}
- # ],
- # option_slots: []
- # }
-
- # With mappings (slot-based import)
- mappings = [
- %{"csv_name" => "Cup Color", "slot_key" => "cup_color", "source_key" => "color"},
- %{"csv_name" => "Liquid Color", "slot_key" => "liquid_color", "source_key" => "color"}
- ]
- OptionBuilder.build_extended(rows, option_mappings: mappings)
- # => %{
- # base_price: Decimal.new("22.80"),
- # options: [...],
- # option_slots: [
- # %{slot: "cup_color", source_key: "color", label: "Cup Color", values: [...]},
- # %{slot: "liquid_color", source_key: "color", label: "Liquid Color", values: [...]}
- # ]
- # }
- """
- def build_extended(rows, opts \\ []) when is_list(rows) do
- option_mappings = Keyword.get(opts, :option_mappings, [])
- first_row = List.first(rows)
-
- # Extract variants with prices and all option values
- variants = extract_all_variants(rows)
-
- # Calculate base price (minimum)
- base_price =
- variants
- |> Enum.map(& &1.price)
- |> Enum.filter(& &1)
- |> Enum.min(fn -> Decimal.new("0") end)
-
- # Build option data for each option position
- options =
- for i <- 1..@max_options,
- name = get_option_name(first_row, i),
- name != nil do
- field = String.to_atom("option#{i}_value")
- {values, modifiers} = build_option_data(variants, field, base_price)
-
- # Only include modifiers if they have non-zero values
- has_price_impact = Enum.any?(modifiers, fn {_k, v} -> v != "0" end)
-
- %{
- position: i,
- name: name,
- values: values,
- modifiers: if(has_price_impact, do: modifiers, else: %{})
- }
- end
-
- # Build option slots from mappings
- option_slots = build_option_slots_from_mappings(options, option_mappings)
-
- %{
- base_price: base_price,
- options: options,
- option_slots: option_slots
- }
- end
-
- # Extract all option values (Option1..Option10) from variant rows
- defp extract_all_variants(rows) do
- Enum.map(rows, fn row ->
- base = %{price: parse_price(row["Variant Price"])}
-
- # Add option values for each position
- Enum.reduce(1..@max_options, base, fn i, acc ->
- key = String.to_atom("option#{i}_value")
- value = get_non_empty(row, "Option#{i} Value")
- Map.put(acc, key, value)
- end)
- end)
- |> Enum.filter(& &1.price)
- end
-
- # Get option name for a position
- defp get_option_name(row, position) do
- get_non_empty(row, "Option#{position} Name")
- end
-
- # Build option slots from mappings
- defp build_option_slots_from_mappings(options, mappings) when is_list(mappings) do
- mappings
- |> Enum.map(fn mapping ->
- csv_name = mapping["csv_name"]
- slot_key = mapping["slot_key"]
- source_key = mapping["source_key"]
- label = mapping["label"] || csv_name
-
- # Find the option with matching name
- option = Enum.find(options, fn opt -> opt.name == csv_name end)
-
- if option && slot_key do
- %{
- slot: slot_key,
- source_key: source_key,
- label: label,
- values: option.values,
- position: option.position
- }
- else
- nil
- end
- end)
- |> Enum.reject(&is_nil/1)
- end
-
- defp build_option_slots_from_mappings(_, _), do: []
-
- # Private helpers
-
- defp get_non_empty(row, key) do
- case row[key] do
- nil -> nil
- "" -> nil
- value -> String.trim(value)
- end
- end
-
- defp parse_price(nil), do: nil
- defp parse_price(""), do: nil
-
- defp parse_price(str) when is_binary(str) do
- str = String.trim(str)
-
- case Decimal.parse(str) do
- {decimal, _} -> decimal
- :error -> nil
- end
- end
-
- defp build_option_data(variants, field, base_price) do
- # Get unique values preserving order of first appearance
- values =
- variants
- |> Enum.map(&Map.get(&1, field))
- |> Enum.reject(&is_nil/1)
- |> Enum.uniq()
-
- # Build price modifiers for each value
- # Group by value and take the first price for each
- price_by_value =
- variants
- |> Enum.reduce(%{}, fn v, acc ->
- value = Map.get(v, field)
-
- if value && !Map.has_key?(acc, value) do
- Map.put(acc, value, v.price)
- else
- acc
- end
- end)
-
- # Calculate modifiers as delta from base price
- modifiers =
- price_by_value
- |> Enum.reduce(%{}, fn {value, price}, acc ->
- modifier = Decimal.sub(price, base_price)
- Map.put(acc, value, Decimal.to_string(modifier))
- end)
-
- {values, modifiers}
- end
-
- defp get_unique_values(variants, field) do
- variants
- |> Enum.map(&Map.get(&1, field))
- |> Enum.reject(&is_nil/1)
- |> Enum.uniq()
- end
-end
diff --git a/lib/modules/shop/import/product_transformer.ex b/lib/modules/shop/import/product_transformer.ex
deleted file mode 100644
index 933b28061..000000000
--- a/lib/modules/shop/import/product_transformer.ex
+++ /dev/null
@@ -1,473 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.ProductTransformer do
- @moduledoc """
- Transform Shopify CSV rows into PhoenixKit Product format.
-
- Handles:
- - Basic product fields (title, description, price, etc.)
- - Option values and price modifiers in metadata
- - Slot-based options with global option mapping
- - Category assignment based on title keywords (configurable)
- - Image collection
- - Auto-creation of missing categories
-
- ## Extended Transform
-
- Use `transform_extended/5` with `option_mappings` to enable slot-based
- options that reference global options. This allows multiple uses of the
- same global option in a product (e.g., cup_color and liquid_color both
- referencing the "color" global option).
- """
-
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.Import.{Filter, OptionBuilder}
- alias PhoenixKit.Modules.Shop.SlugResolver
- alias PhoenixKit.Modules.Shop.Translations
-
- require Logger
-
- @doc """
- Transform a group of CSV rows (one product) into Product attrs.
-
- ## Arguments
-
- - handle: Product handle (slug)
- - rows: List of CSV row maps for this product
- - categories_map: Map of slug => category_uuid
- - config: Optional ImportConfig for category rules (nil = legacy defaults)
- - opts: Keyword options:
- - `:language` - Target language for imported content (default: system default language)
-
- ## Returns
-
- Map suitable for `Shop.create_product/1`
- """
- def transform(handle, rows, categories_map \\ %{}, config \\ nil, opts \\ []) do
- first_row = List.first(rows)
- options = OptionBuilder.build_from_variants(rows)
-
- # Get target language for localized fields
- language = Keyword.get(opts, :language, Translations.default_language())
-
- # Determine category using config or legacy defaults
- title = first_row["Title"] || ""
- category_slug = Filter.categorize(title, config)
-
- # Get category_uuid, auto-creating if necessary (with localized name/slug)
- category_uuid = resolve_category_uuid(category_slug, categories_map, language)
-
- # Build metadata with option values and price modifiers
- metadata = build_metadata(options)
-
- # Extract non-localized values
- body_html_raw = first_row["Body (HTML)"]
- description_raw = extract_description(body_html_raw)
- seo_title_raw = get_non_empty(first_row, "SEO Title")
- seo_description_raw = get_non_empty(first_row, "SEO Description")
-
- %{
- # Localized fields - stored as maps with language key
- slug: localized_map(handle, language),
- title: localized_map(title, language),
- body_html: localized_map(body_html_raw, language),
- description: localized_map(description_raw, language),
- seo_title: localized_map(seo_title_raw, language),
- seo_description: localized_map(seo_description_raw, language),
- # Non-localized fields
- vendor: get_non_empty(first_row, "Vendor"),
- tags: parse_tags(first_row["Tags"]),
- status: parse_status(first_row["Published"]),
- price: options.base_price,
- product_type: "physical",
- requires_shipping: true,
- taxable: true,
- featured_image: find_featured_image(rows),
- images: collect_images(rows),
- category_uuid: category_uuid,
- metadata: metadata
- }
- end
-
- # Build a localized field map for a single value
- # Idempotent: if value is already a map with string keys, return as-is
- defp localized_map(nil, _language), do: %{}
- defp localized_map("", _language), do: %{}
-
- defp localized_map(value, _language) when is_map(value) do
- # Already a localized map - return as-is to prevent double-wrapping
- value
- end
-
- defp localized_map(value, language) when is_binary(value), do: %{language => value}
-
- @doc """
- Resolves category UUID from slug, auto-creating if necessary.
-
- If category doesn't exist, creates it with:
- - name: Generated from slug (capitalize, replace hyphens with spaces) - localized map
- - status: "active"
- - slug: The original slug - localized map
-
- ## Arguments
-
- - category_slug: The slug string to look up
- - categories_map: Map of slug => category_uuid
- - language: Target language for localized fields (default: system default)
- """
- def resolve_category_uuid(category_slug, categories_map, language \\ nil)
-
- def resolve_category_uuid(category_slug, categories_map, language)
- when is_binary(category_slug) do
- lang = language || Translations.default_language()
-
- case Map.get(categories_map, category_slug) do
- nil ->
- # Category doesn't exist - try to create it
- maybe_create_category(category_slug, lang)
-
- category_uuid ->
- category_uuid
- end
- end
-
- def resolve_category_uuid(_, _, _), do: nil
-
- defp maybe_create_category(slug, language) when is_binary(slug) and slug != "" do
- # First check if category already exists (using localized slug search)
- case Shop.get_category_by_slug_localized(slug, language) do
- {:ok, %{uuid: uuid}} ->
- # Category exists, return its uuid
- uuid
-
- {:error, :not_found} ->
- # Category doesn't exist - create it
- create_new_category(slug, language)
- end
- end
-
- defp create_new_category(slug, language) do
- # Normalize language to dialect format (e.g., "en" -> "en-US")
- # to match how SlugResolver queries slug JSONB fields
- normalized_lang = SlugResolver.normalize_language_public(language)
-
- # Generate name from slug: "vases-planters" -> "Vases Planters"
- name =
- slug
- |> String.replace("-", " ")
- |> String.split(" ")
- |> Enum.map_join(" ", &String.capitalize/1)
-
- # Create localized attributes with normalized language key
- attrs = %{
- name: %{normalized_lang => name},
- slug: %{normalized_lang => slug},
- status: "active"
- }
-
- case Shop.create_category(attrs) do
- {:ok, category} ->
- Logger.info(
- "Auto-created category: #{slug} (uuid: #{category.uuid}) with language: #{normalized_lang}"
- )
-
- category.uuid
-
- {:error, _changeset} ->
- # Unique constraint hit - category was created by concurrent process, fetch it
- case Shop.get_category_by_slug_localized(slug, language) do
- {:ok, %{uuid: uuid}} ->
- Logger.info("Category #{slug} already exists (uuid: #{uuid}), using existing")
- uuid
-
- {:error, :not_found} ->
- Logger.warning("Failed to create or find category: #{slug}")
- nil
- end
- end
- end
-
- @doc """
- Build an updated categories_map including any auto-created categories.
-
- Call this after transform() to update the map for subsequent products.
- """
- def update_categories_map(categories_map, category_slug) when is_binary(category_slug) do
- if Map.has_key?(categories_map, category_slug) do
- categories_map
- else
- case Shop.get_category_by_slug(category_slug) do
- nil -> categories_map
- category -> Map.put(categories_map, category_slug, category.uuid)
- end
- end
- end
-
- def update_categories_map(categories_map, _), do: categories_map
-
- @doc """
- Transform with extended options support (Option3..N and slot mappings).
-
- ## Arguments
-
- - handle: Product handle (slug)
- - rows: List of CSV row maps for this product
- - categories_map: Map of slug => category_uuid
- - config: Optional ImportConfig for category rules and option mappings
- - opts: Keyword options:
- - `:language` - Target language for imported content
- - `:option_mappings` - Explicit option mappings (overrides config)
-
- ## Returns
-
- Map suitable for `Shop.create_product/1` with slot-based metadata if mappings provided.
- """
- def transform_extended(handle, rows, categories_map \\ %{}, config \\ nil, opts \\ []) do
- first_row = List.first(rows)
-
- # Get option mappings from opts or config
- option_mappings = get_option_mappings(config, opts)
-
- # Build extended options with mappings support
- options = OptionBuilder.build_extended(rows, option_mappings: option_mappings)
-
- # Get target language for localized fields
- language = Keyword.get(opts, :language, Translations.default_language())
-
- # Determine category using config or legacy defaults
- title = first_row["Title"] || ""
- category_slug = Filter.categorize(title, config)
-
- # Get category_uuid, auto-creating if necessary (with localized name/slug)
- category_uuid = resolve_category_uuid(category_slug, categories_map, language)
-
- # Build metadata with slot-based option structure
- metadata = build_metadata_extended(options)
-
- # Extract non-localized values
- body_html_raw = first_row["Body (HTML)"]
- description_raw = extract_description(body_html_raw)
- seo_title_raw = get_non_empty(first_row, "SEO Title")
- seo_description_raw = get_non_empty(first_row, "SEO Description")
-
- %{
- # Localized fields - stored as maps with language key
- slug: localized_map(handle, language),
- title: localized_map(title, language),
- body_html: localized_map(body_html_raw, language),
- description: localized_map(description_raw, language),
- seo_title: localized_map(seo_title_raw, language),
- seo_description: localized_map(seo_description_raw, language),
- # Non-localized fields
- vendor: get_non_empty(first_row, "Vendor"),
- tags: parse_tags(first_row["Tags"]),
- status: parse_status(first_row["Published"]),
- price: options.base_price,
- product_type: "physical",
- requires_shipping: true,
- taxable: true,
- featured_image: find_featured_image(rows),
- images: collect_images(rows),
- category_uuid: category_uuid,
- metadata: metadata
- }
- end
-
- # Get option mappings from config or opts
- defp get_option_mappings(config, opts) do
- explicit_mappings = Keyword.get(opts, :option_mappings)
-
- cond do
- is_list(explicit_mappings) and explicit_mappings != [] ->
- explicit_mappings
-
- config != nil and is_list(config.option_mappings) ->
- config.option_mappings
-
- true ->
- []
- end
- end
-
- # Build metadata from extended options data
- defp build_metadata_extended(%{options: options, option_slots: option_slots}) do
- result = %{}
-
- # Build _option_values from all options
- option_values =
- options
- |> Enum.filter(fn opt -> opt.values != [] end)
- |> Enum.reduce(%{}, fn opt, acc ->
- key = normalize_key(opt.name)
- Map.put(acc, key, opt.values)
- end)
-
- result =
- if option_values != %{} do
- Map.put(result, "_option_values", option_values)
- else
- result
- end
-
- # Build _price_modifiers from options that have modifiers
- price_modifiers =
- options
- |> Enum.filter(fn opt -> opt.modifiers != %{} end)
- |> Enum.reduce(%{}, fn opt, acc ->
- key = normalize_key(opt.name)
- Map.put(acc, key, opt.modifiers)
- end)
-
- result =
- if price_modifiers != %{} do
- Map.put(result, "_price_modifiers", price_modifiers)
- else
- result
- end
-
- # Build _option_slots from slot mappings
- slots =
- option_slots
- |> Enum.map(fn slot ->
- %{
- "slot" => slot.slot,
- "source_key" => slot.source_key,
- "label" => slot.label
- }
- end)
-
- result =
- if slots != [] do
- # Also update _option_values to use slot keys instead of CSV names
- slot_option_values =
- option_slots
- |> Enum.filter(fn slot -> slot.values != [] end)
- |> Enum.reduce(%{}, fn slot, acc ->
- Map.put(acc, slot.slot, slot.values)
- end)
-
- result
- |> Map.put("_option_slots", slots)
- |> Map.update("_option_values", slot_option_values, fn existing ->
- Map.merge(existing, slot_option_values)
- end)
- else
- result
- end
-
- result
- end
-
- # Private helpers
-
- defp build_metadata(options) do
- option_values = %{}
- price_modifiers = %{}
-
- # Option1 (typically Size) - affects price
- {option_values, price_modifiers} =
- if options.option1_name && options.option1_values != [] do
- key = normalize_key(options.option1_name)
-
- ov = Map.put(option_values, key, options.option1_values)
-
- pm =
- if options.option1_modifiers != %{} do
- Map.put(price_modifiers, key, options.option1_modifiers)
- else
- price_modifiers
- end
-
- {ov, pm}
- else
- {option_values, price_modifiers}
- end
-
- # Option2 (typically Color) - no price impact, just values
- option_values =
- if options.option2_name && options.option2_values != [] do
- key = normalize_key(options.option2_name)
- Map.put(option_values, key, options.option2_values)
- else
- option_values
- end
-
- result = %{}
-
- result =
- if option_values != %{} do
- Map.put(result, "_option_values", option_values)
- else
- result
- end
-
- result =
- if price_modifiers != %{} do
- Map.put(result, "_price_modifiers", price_modifiers)
- else
- result
- end
-
- result
- end
-
- defp normalize_key(name) do
- name
- |> String.downcase()
- |> String.replace(~r/\s+/, "_")
- |> String.replace(~r/[^a-z0-9_]/, "")
- end
-
- defp get_non_empty(row, key) do
- case row[key] do
- nil -> nil
- "" -> nil
- value -> String.trim(value)
- end
- end
-
- defp parse_tags(nil), do: []
- defp parse_tags(""), do: []
-
- defp parse_tags(tags) do
- tags
- |> String.split(",")
- |> Enum.map(&String.trim/1)
- |> Enum.reject(&(&1 == ""))
- end
-
- defp parse_status("true"), do: "active"
- defp parse_status("TRUE"), do: "active"
- defp parse_status(_), do: "draft"
-
- defp extract_description(nil), do: nil
- defp extract_description(""), do: nil
-
- defp extract_description(html) do
- # Extract first paragraph as description (strip HTML tags)
- html
- |> String.replace(~r/<[^>]+>/, " ")
- |> String.replace(~r/\s+/, " ")
- |> String.trim()
- |> String.slice(0, 500)
- end
-
- defp find_featured_image(rows) do
- # Find image with position 1, or first image
- featured =
- Enum.find(rows, fn row ->
- row["Image Position"] == "1"
- end)
-
- case featured do
- nil -> get_non_empty(List.first(rows), "Image Src")
- row -> get_non_empty(row, "Image Src")
- end
- end
-
- defp collect_images(rows) do
- rows
- |> Enum.map(fn row -> get_non_empty(row, "Image Src") end)
- |> Enum.reject(&is_nil/1)
- |> Enum.uniq()
- |> Enum.map(fn url -> %{"src" => url} end)
- end
-end
diff --git a/lib/modules/shop/import/prom_ua_format.ex b/lib/modules/shop/import/prom_ua_format.ex
deleted file mode 100644
index c98a6e0ce..000000000
--- a/lib/modules/shop/import/prom_ua_format.ex
+++ /dev/null
@@ -1,417 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.PromUaFormat do
- @moduledoc """
- Prom.ua CSV format adapter implementing `ImportFormat` behaviour.
-
- Handles the Prom.ua export format:
- - One row = one product (no variant grouping)
- - Bilingual: Russian + Ukrainian titles/descriptions
- - Multiple images comma-separated in a single column
- - Ukrainian column names
- - Category by name (`Назва_групи`)
- - Prices in UAH
- """
-
- @behaviour PhoenixKit.Modules.Shop.Import.ImportFormat
-
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.Translations
-
- require Logger
-
- # Prom.ua CSVs use comma separator (standard CSV)
- NimbleCSV.define(PromUaCSV, separator: ",", escape: "\"")
-
- @marker_columns ["Назва_позиції", "Ціна", "Номер_групи"]
-
- @impl true
- def detect?(headers) do
- header_set = MapSet.new(headers)
- Enum.all?(@marker_columns, &MapSet.member?(header_set, &1))
- end
-
- @impl true
- def requires_option_mapping?, do: false
-
- @impl true
- def count(path, _config) do
- parse_rows(path) |> length()
- end
-
- @impl true
- def parse_and_transform(path, categories_map, _config, _opts) do
- parse_rows(path)
- |> Enum.map(fn row -> transform_row(row, categories_map) end)
- end
-
- @impl true
- def default_config_attrs do
- %{
- name: "prom_ua_default",
- skip_filter: true,
- category_rules: [],
- required_columns: ["Назва_позиції", "Ціна"],
- is_default: false,
- active: true,
- download_images: true,
- include_keywords: [],
- exclude_keywords: [],
- exclude_phrases: [],
- option_mappings: []
- }
- end
-
- # ============================================
- # PARSING
- # ============================================
-
- defp parse_rows(path) do
- {headers, rows} =
- path
- |> File.stream!([:utf8])
- |> PromUaCSV.parse_stream(skip_headers: false)
- |> Enum.reduce({nil, []}, fn
- row, {nil, []} ->
- {row, []}
-
- row, {headers, acc} ->
- # Pad row to match header length (handles short rows)
- padded = pad_row(row, length(headers))
- row_map = Enum.zip(headers, padded) |> Map.new()
- {headers, [row_map | acc]}
- end)
-
- if headers == nil do
- []
- else
- rows
- |> Enum.reverse()
- |> Enum.filter(fn row ->
- name = row["Назва_позиції"] || ""
- String.trim(name) != ""
- end)
- end
- end
-
- defp pad_row(row, target_length) when length(row) >= target_length, do: row
-
- defp pad_row(row, target_length) do
- row ++ List.duplicate("", target_length - length(row))
- end
-
- # ============================================
- # TRANSFORMATION
- # ============================================
-
- defp transform_row(row, categories_map) do
- slug = extract_slug(row)
- category_uuid = resolve_category(row, categories_map)
- {price, compare_at_price} = parse_price_and_discount(row)
- image_urls = parse_image_urls(row["Посилання_зображення"])
- images = Enum.map(image_urls, fn url -> %{"src" => url} end)
-
- %{
- slug: bilingual_map(slug),
- title:
- localized_map(
- non_empty(row["Назва_позиції"]) || "",
- non_empty(row["Назва_позиції_укр"]) || ""
- ),
- body_html: localized_map(row["Опис"] || "", row["Опис_укр"] || ""),
- description:
- localized_map(extract_description(row["Опис"]), extract_description(row["Опис_укр"])),
- seo_title:
- localized_map(
- non_empty(row["HTML_заголовок"]) || "",
- non_empty(row["HTML_заголовок_укр"]) || ""
- ),
- seo_description:
- localized_map(non_empty(row["HTML_опис"]) || "", non_empty(row["HTML_опис_укр"]) || ""),
- vendor: non_empty(row["Виробник"]),
- tags: parse_tags(row["Пошукові_запити"]),
- status: parse_availability(row["Наявність"]),
- price: price,
- compare_at_price: compare_at_price,
- product_type: "physical",
- requires_shipping: true,
- taxable: true,
- featured_image: List.first(image_urls),
- images: images,
- category_uuid: category_uuid,
- weight_grams: parse_weight(row["Вага,кг"]),
- metadata: build_metadata(row)
- }
- end
-
- # ============================================
- # SLUG
- # ============================================
-
- defp extract_slug(row) do
- url = row["Продукт_на_сайті"] || ""
-
- slug =
- case Regex.run(~r|/p\d+-(.+?)\.html|, url) do
- [_, slug_part] -> slug_part
- _ -> nil
- end
-
- slug = slug || fallback_slug(row)
- slug
- end
-
- defp fallback_slug(row) do
- uid = non_empty(row["Унікальний_ідентифікатор"])
-
- if uid do
- "prom-#{uid}"
- else
- # Last resort: generate from product name
- name = row["Назва_позиції"] || "product"
-
- name
- |> String.downcase()
- |> String.replace(~r/[^a-z0-9\s-]/, "")
- |> String.replace(~r/\s+/, "-")
- |> String.slice(0, 60)
- end
- end
-
- defp bilingual_map(value) do
- default_lang = Translations.default_language()
-
- %{"ru" => value, "uk" => value}
- |> maybe_put_default_lang(default_lang, value)
- end
-
- # Ensure the system's default language key is always present in localized maps.
- # Uses the Russian value as fallback for the default language.
- defp localized_map(ru_value, uk_value) do
- default_lang = Translations.default_language()
-
- %{"ru" => ru_value, "uk" => uk_value}
- |> maybe_put_default_lang(default_lang, ru_value)
- end
-
- defp maybe_put_default_lang(map, lang, _fallback) when lang in ["ru", "uk"], do: map
- defp maybe_put_default_lang(map, lang, fallback), do: Map.put_new(map, lang, fallback)
-
- # ============================================
- # CATEGORY
- # ============================================
-
- defp resolve_category(row, categories_map) do
- group_name = non_empty(row["Назва_групи"])
- group_number = non_empty(row["Номер_групи"])
-
- if group_name do
- # Build a slug from the group number for lookup
- category_slug = if group_number, do: "group-#{group_number}", else: slugify(group_name)
-
- case Map.get(categories_map, category_slug) do
- nil ->
- # Auto-create category with ru name and generated slug
- maybe_create_prom_category(group_name, category_slug)
-
- category_uuid ->
- category_uuid
- end
- else
- nil
- end
- end
-
- defp maybe_create_prom_category(group_name, slug) do
- lang = Translations.default_language()
-
- case Shop.get_category_by_slug_localized(slug, lang) do
- {:ok, %{uuid: uuid}} ->
- uuid
-
- {:error, :not_found} ->
- attrs = %{
- name: localized_map(group_name, group_name),
- slug: localized_map(slug, slug),
- status: "active"
- }
-
- case Shop.create_category(attrs) do
- {:ok, category} ->
- Logger.info("Auto-created Prom.ua category: #{slug} (#{group_name})")
- category.uuid
-
- {:error, changeset} ->
- Logger.warning("Failed to create category #{slug}: #{inspect(changeset.errors)}")
- nil
- end
- end
- end
-
- defp slugify(name) do
- name
- |> String.downcase()
- |> String.replace(~r/[^a-zа-яёіїєґ0-9\s-]/u, "")
- |> String.replace(~r/\s+/, "-")
- |> String.slice(0, 80)
- end
-
- # ============================================
- # PRICE & DISCOUNT
- # ============================================
-
- defp parse_price_and_discount(row) do
- price_str = row["Ціна"] || "0"
- discount_str = row["Знижка"] || ""
-
- price =
- case Decimal.parse(String.trim(price_str)) do
- {decimal, _} -> decimal
- :error -> Decimal.new(0)
- end
-
- compare_at_price = calculate_compare_at_price(price, String.trim(discount_str))
-
- {price, compare_at_price}
- end
-
- defp calculate_compare_at_price(_price, ""), do: nil
-
- defp calculate_compare_at_price(price, discount_str) do
- if String.ends_with?(discount_str, "%") do
- # Percentage discount: "10%", "15%", "20%"
- percent_str = String.trim_trailing(discount_str, "%")
-
- case Decimal.parse(percent_str) do
- {percent, _} ->
- divisor = Decimal.sub(Decimal.new(1), Decimal.div(percent, Decimal.new(100)))
-
- if Decimal.gt?(divisor, Decimal.new(0)) do
- Decimal.div(price, divisor) |> Decimal.round(2)
- else
- nil
- end
-
- :error ->
- nil
- end
- else
- # Absolute discount: "1550.00", "360.00"
- case Decimal.parse(discount_str) do
- {absolute_discount, _} ->
- if Decimal.gt?(absolute_discount, Decimal.new(0)) do
- Decimal.add(price, absolute_discount)
- else
- nil
- end
-
- :error ->
- nil
- end
- end
- end
-
- # ============================================
- # IMAGES
- # ============================================
-
- defp parse_image_urls(nil), do: []
- defp parse_image_urls(""), do: []
-
- defp parse_image_urls(urls_string) do
- urls_string
- |> String.split(", ")
- |> Enum.map(&String.trim/1)
- |> Enum.reject(&(&1 == ""))
- end
-
- # ============================================
- # AVAILABILITY
- # ============================================
-
- defp parse_availability(nil), do: "draft"
- defp parse_availability(""), do: "draft"
-
- defp parse_availability(value) do
- trimmed = String.trim(value)
-
- cond do
- trimmed in ["+", "!", "@"] -> "active"
- trimmed == "-" || trimmed == "0" -> "draft"
- # Numeric values > 0 mean in stock
- match?({n, ""} when n > 0, Integer.parse(trimmed)) -> "active"
- true -> "draft"
- end
- end
-
- # ============================================
- # WEIGHT
- # ============================================
-
- defp parse_weight(nil), do: nil
- defp parse_weight(""), do: nil
-
- defp parse_weight(kg_str) do
- case Float.parse(String.trim(kg_str)) do
- {kg, _} -> round(kg * 1000)
- :error -> nil
- end
- end
-
- # ============================================
- # TAGS
- # ============================================
-
- defp parse_tags(nil), do: []
- defp parse_tags(""), do: []
-
- defp parse_tags(tags_str) do
- tags_str
- |> String.split(",")
- |> Enum.map(&String.trim/1)
- |> Enum.reject(&(&1 == ""))
- end
-
- # ============================================
- # DESCRIPTION
- # ============================================
-
- defp extract_description(nil), do: ""
- defp extract_description(""), do: ""
-
- defp extract_description(html) do
- html
- |> String.replace(~r/<[^>]+>/, " ")
- |> String.replace(~r/&[a-z]+;/, " ")
- |> String.replace(~r/\s+/, " ")
- |> String.trim()
- |> String.slice(0, 500)
- end
-
- # ============================================
- # METADATA
- # ============================================
-
- defp build_metadata(row) do
- metadata = %{}
-
- metadata = put_if_present(metadata, "sku", row["Код_товару"])
- metadata = put_if_present(metadata, "prom_id", row["Ідентифікатор_товару"])
- metadata = put_if_present(metadata, "prom_uid", row["Унікальний_ідентифікатор"])
- metadata = put_if_present(metadata, "country", row["Країна_виробник"])
- metadata = put_if_present(metadata, "currency", row["Валюта"])
- metadata = put_if_present(metadata, "group_id", row["Номер_групи"])
-
- metadata
- end
-
- defp put_if_present(map, _key, nil), do: map
- defp put_if_present(map, _key, ""), do: map
- defp put_if_present(map, key, value), do: Map.put(map, key, String.trim(value))
-
- # ============================================
- # HELPERS
- # ============================================
-
- defp non_empty(nil), do: nil
- defp non_empty(""), do: nil
- defp non_empty(value), do: String.trim(value)
-end
diff --git a/lib/modules/shop/import/shopify_csv.ex b/lib/modules/shop/import/shopify_csv.ex
deleted file mode 100644
index 9f09f1c7d..000000000
--- a/lib/modules/shop/import/shopify_csv.ex
+++ /dev/null
@@ -1,329 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.ShopifyCSV do
- @moduledoc """
- Main orchestrator for Shopify CSV import.
-
- Coordinates CSV parsing, validation, filtering, transformation, and product creation.
-
- ## Usage
-
- # Dry run - see what would be imported
- ShopifyCSV.import("/path/to/products.csv", dry_run: true)
-
- # Full import
- ShopifyCSV.import("/path/to/products.csv")
-
- # Import with custom config
- config = Shop.get_import_config!(config_uuid)
- ShopifyCSV.import("/path/to/products.csv", config: config)
-
- # Import to specific category
- category = Shop.get_category_by_slug("shelves")
- ShopifyCSV.import("/path/to/products.csv", category_uuid: category.uuid)
- """
-
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.Import.{CSVParser, CSVValidator, Filter, ProductTransformer}
- alias PhoenixKit.Modules.Shop.ImportConfig
- alias PhoenixKit.Modules.Shop.Translations
-
- require Logger
-
- @doc """
- Import products from Shopify CSV file.
-
- ## Options
-
- - `:dry_run` - If true, don't create products, just return what would be created
- - `:category_uuid` - Override category for all products
- - `:skip_existing` - If true, skip products with existing slugs (default: true)
- - `:update_existing` - If true, update existing products instead of skipping (default: false)
- - `:config` - ImportConfig struct for filtering/categorization (nil = use defaults)
- - `:validate` - If true, validate CSV before import (default: true)
-
- Note: When `update_existing: true`, `skip_existing` is ignored.
-
- ## Returns
-
- Summary map with:
- - `:imported` - count of newly created products
- - `:updated` - count of updated existing products
- - `:skipped` - count of skipped (existing or filtered out)
- - `:errors` - count of failed imports
- - `:dry_run` - count of products in dry run
- - `:error_details` - list of error tuples
- - `:validation_report` - CSV validation report (if validate: true)
- """
- def import(file_path, opts \\ []) do
- dry_run = Keyword.get(opts, :dry_run, false)
- category_uuid = Keyword.get(opts, :category_uuid)
- skip_existing = Keyword.get(opts, :skip_existing, true)
- update_existing = Keyword.get(opts, :update_existing, false)
- config = Keyword.get(opts, :config)
- validate = Keyword.get(opts, :validate, true)
- language = Keyword.get(opts, :language)
-
- # Get required columns from config if provided
- required_columns = get_required_columns(config)
-
- # Validate CSV first if requested
- validation_result =
- if validate do
- case CSVValidator.validate_headers(file_path, required_columns) do
- {:ok, _headers} ->
- {:ok,
- CSVValidator.get_validation_report(file_path, required_columns: required_columns)}
-
- {:error, reason} ->
- {:error, reason}
- end
- else
- {:ok, nil}
- end
-
- case validation_result do
- {:error, reason} ->
- %{
- imported: 0,
- updated: 0,
- dry_run: 0,
- skipped: 0,
- errors: 1,
- error_details: [{:validation_failed, format_validation_error(reason)}],
- validation_report: nil
- }
-
- {:ok, validation_report} ->
- do_import(file_path, %{
- dry_run: dry_run,
- category_uuid: category_uuid,
- skip_existing: skip_existing,
- update_existing: update_existing,
- config: config,
- validation_report: validation_report,
- language: language
- })
- end
- end
-
- defp get_required_columns(%ImportConfig{required_columns: cols}) when is_list(cols), do: cols
- defp get_required_columns(_), do: ImportConfig.default_required_columns()
-
- defp format_validation_error({:missing_columns, cols}),
- do: "Missing columns: #{Enum.join(cols, ", ")}"
-
- defp format_validation_error(:file_not_found), do: "File not found"
- defp format_validation_error(:empty_file), do: "File is empty"
- defp format_validation_error({:parse_error, msg}), do: "CSV parse error: #{msg}"
- defp format_validation_error(other), do: inspect(other)
-
- defp do_import(file_path, opts) do
- %{
- dry_run: dry_run,
- category_uuid: category_uuid,
- skip_existing: skip_existing,
- update_existing: update_existing,
- config: config,
- validation_report: validation_report,
- language: language
- } = opts
-
- # Build categories map for auto-assignment
- categories_map = build_categories_map()
-
- # Parse and group CSV
- Logger.info("Parsing CSV: #{file_path}")
- grouped = CSVParser.parse_and_group(file_path)
- Logger.info("Found #{map_size(grouped)} unique handles")
-
- # Filter and import
- results =
- grouped
- |> Enum.map(fn {handle, rows} ->
- process_product(handle, rows, %{
- dry_run: dry_run,
- category_uuid: category_uuid,
- categories_map: categories_map,
- skip_existing: skip_existing,
- update_existing: update_existing,
- config: config,
- language: language
- })
- end)
-
- summary = summarize(results)
- Map.put(summary, :validation_report, validation_report)
- end
-
- @doc """
- Quick dry run - just parse and filter, show what would be imported.
- """
- def preview(file_path, opts \\ []) do
- config = Keyword.get(opts, :config)
-
- grouped = CSVParser.parse_and_group(file_path)
-
- filtered =
- grouped
- |> Enum.filter(fn {_handle, rows} -> Filter.should_include?(rows, config) end)
-
- Logger.info("Total products in CSV: #{map_size(grouped)}")
- Logger.info("Would import (matching filter): #{length(filtered)}")
- Logger.info("Would skip (filtered out): #{map_size(grouped) - length(filtered)}")
-
- # Show sample
- filtered
- |> Enum.take(5)
- |> Enum.each(fn {handle, rows} ->
- first = List.first(rows)
- category = Filter.categorize(first["Title"] || "", config)
- Logger.info(" #{handle} -> #{category}")
- end)
-
- %{
- total: map_size(grouped),
- would_import: length(filtered),
- would_skip: map_size(grouped) - length(filtered)
- }
- end
-
- @doc """
- Validates CSV file without importing.
-
- Returns validation report with headers, row count, and any warnings.
- """
- def validate(file_path, opts \\ []) do
- config = Keyword.get(opts, :config)
- required_columns = get_required_columns(config)
-
- CSVValidator.get_validation_report(file_path, required_columns: required_columns)
- end
-
- # Private helpers
-
- defp build_categories_map do
- lang = Translations.default_language()
-
- Shop.list_categories()
- |> Enum.reduce(%{}, fn cat, acc ->
- # Extract string slug from JSONB map for map key
- slug = Translations.get(cat, :slug, lang)
-
- if slug && slug != "" do
- Map.put(acc, slug, cat.uuid)
- else
- acc
- end
- end)
- end
-
- defp process_product(handle, rows, opts) do
- config = opts.config
-
- if Filter.should_include?(rows, config) do
- do_process_product(handle, rows, opts)
- else
- {:skipped, handle, :filtered}
- end
- end
-
- defp do_process_product(handle, rows, opts) do
- %{
- dry_run: dry_run,
- category_uuid: override_category_uuid,
- categories_map: categories_map,
- config: config,
- language: language
- } = opts
-
- # Transform with config and language
- transform_opts = if language, do: [language: language], else: []
- attrs = ProductTransformer.transform(handle, rows, categories_map, config, transform_opts)
-
- # Override category if specified
- attrs =
- if override_category_uuid do
- Map.put(attrs, :category_uuid, override_category_uuid)
- else
- attrs
- end
-
- if dry_run do
- {:dry_run, handle, attrs}
- else
- save_product(handle, attrs, opts)
- end
- end
-
- defp save_product(handle, attrs, opts) do
- %{skip_existing: skip_existing, update_existing: update_existing} = opts
-
- cond do
- update_existing ->
- upsert_product(handle, attrs)
-
- skip_existing && product_exists?(handle) ->
- {:skipped, handle, :exists}
-
- true ->
- create_product(handle, attrs)
- end
- end
-
- defp product_exists?(slug) do
- case Shop.get_product_by_slug(slug) do
- nil -> false
- _ -> true
- end
- end
-
- defp create_product(handle, attrs) do
- case Shop.create_product(attrs) do
- {:ok, product} ->
- Logger.debug("Created: #{handle}")
- {:ok, product}
-
- {:error, changeset} ->
- Logger.warning("Failed: #{handle} - #{inspect(changeset.errors)}")
- {:error, handle, changeset}
- end
- end
-
- defp upsert_product(handle, attrs) do
- case Shop.upsert_product(attrs) do
- {:ok, product, :inserted} ->
- Logger.debug("Created: #{handle}")
- {:ok, product}
-
- {:ok, product, :updated} ->
- Logger.debug("Updated: #{handle}")
- {:updated, product}
-
- {:error, changeset} ->
- Logger.warning("Failed: #{handle} - #{inspect(changeset.errors)}")
- {:error, handle, changeset}
- end
- end
-
- defp summarize(results) do
- ok_count = Enum.count(results, &match?({:ok, _}, &1))
- updated_count = Enum.count(results, &match?({:updated, _}, &1))
- dry_count = Enum.count(results, &match?({:dry_run, _, _}, &1))
- skipped_count = Enum.count(results, &match?({:skipped, _, _}, &1))
- errors = Enum.filter(results, &match?({:error, _, _}, &1))
-
- summary = %{
- imported: ok_count,
- updated: updated_count,
- dry_run: dry_count,
- skipped: skipped_count,
- errors: length(errors),
- error_details: errors
- }
-
- Logger.info(
- "Import complete: #{ok_count} imported, #{updated_count} updated, #{dry_count} dry run, #{skipped_count} skipped, #{length(errors)} errors"
- )
-
- summary
- end
-end
diff --git a/lib/modules/shop/import/shopify_format.ex b/lib/modules/shop/import/shopify_format.ex
deleted file mode 100644
index 8dffc9b05..000000000
--- a/lib/modules/shop/import/shopify_format.ex
+++ /dev/null
@@ -1,63 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Import.ShopifyFormat do
- @moduledoc """
- Shopify CSV format adapter implementing `ImportFormat` behaviour.
-
- Wraps existing CSVParser, Filter, and ProductTransformer modules
- behind the uniform import format interface. No logic changes — pure delegation.
- """
-
- @behaviour PhoenixKit.Modules.Shop.Import.ImportFormat
-
- alias PhoenixKit.Modules.Shop.Import.{CSVParser, Filter, ProductTransformer}
- alias PhoenixKit.Modules.Shop.ImportConfig
-
- @shopify_markers ["Handle", "Title", "Variant Price"]
-
- @impl true
- def detect?(headers) do
- header_set = MapSet.new(headers)
- Enum.all?(@shopify_markers, &MapSet.member?(header_set, &1))
- end
-
- @impl true
- def requires_option_mapping?, do: true
-
- @impl true
- def count(path, config) do
- CSVParser.parse_and_group(path)
- |> Enum.count(fn {_handle, rows} -> Filter.should_include?(rows, config) end)
- end
-
- @impl true
- def parse_and_transform(path, categories_map, config, opts) do
- language = Keyword.get(opts, :language)
- option_mappings = Keyword.get(opts, :option_mappings, [])
-
- CSVParser.parse_and_group(path)
- |> Enum.filter(fn {_handle, rows} -> Filter.should_include?(rows, config) end)
- |> Enum.map(fn {handle, rows} ->
- transform_opts = [language: language, option_mappings: option_mappings]
-
- if option_mappings != [] do
- ProductTransformer.transform_extended(
- handle,
- rows,
- categories_map,
- config,
- transform_opts
- )
- else
- ProductTransformer.transform(handle, rows, categories_map, config, transform_opts)
- end
- end)
- end
-
- @impl true
- def default_config_attrs do
- config = ImportConfig.from_legacy_defaults()
-
- config
- |> Map.from_struct()
- |> Map.drop([:__meta__, :id, :uuid, :inserted_at, :updated_at])
- end
-end
diff --git a/lib/modules/shop/options/metadata_validator.ex b/lib/modules/shop/options/metadata_validator.ex
deleted file mode 100644
index 315afd16c..000000000
--- a/lib/modules/shop/options/metadata_validator.ex
+++ /dev/null
@@ -1,340 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Options.MetadataValidator do
- @moduledoc """
- Validates and normalizes product metadata for options and pricing.
-
- This module handles:
- - Format normalization (object -> string for price modifiers)
- - Consistency validation between _option_values and _price_modifiers
- - Cleanup of orphaned modifiers for removed values
-
- ## Price Modifier Formats
-
- The canonical format is a simple string representing the price delta:
-
- %{"_price_modifiers" => %{
- "size" => %{"M" => "5.00", "L" => "10.00"},
- "color" => %{"Gold" => "8.00"}
- }}
-
- Legacy object format is also supported for backward compatibility:
-
- %{"_price_modifiers" => %{
- "size" => %{"M" => %{"type" => "fixed", "value" => "5.00"}}
- }}
-
- Both formats are normalized to string format when saving.
- """
-
- @doc """
- Validates metadata structure against option schema.
-
- Returns `:ok` or `{:error, errors}` where errors is a list of error tuples.
-
- ## Examples
-
- schema = [%{"key" => "size", "type" => "select", "options" => ["S", "M", "L"]}]
-
- MetadataValidator.validate(%{"size" => "M"}, schema)
- # => :ok
-
- MetadataValidator.validate(%{"size" => "XL"}, schema)
- # => {:error, [{"size", "must be one of: S, M, L"}]}
- """
- def validate(metadata, option_schema) when is_map(metadata) and is_list(option_schema) do
- errors = validate_values(metadata, option_schema) ++ validate_consistency(metadata)
-
- case errors do
- [] -> :ok
- _ -> {:error, errors}
- end
- end
-
- def validate(_, _), do: :ok
-
- @doc """
- Validates consistency between _option_values and _price_modifiers.
-
- Ensures that:
- - All keys in _price_modifiers have corresponding entries in _option_values (or are schema options)
- - All values in _price_modifiers exist in their respective option values
-
- Returns a list of error tuples (empty if valid).
- """
- def validate_consistency(metadata) when is_map(metadata) do
- option_values = Map.get(metadata, "_option_values", %{})
- price_modifiers = Map.get(metadata, "_price_modifiers", %{})
-
- # Guard against non-map price_modifiers
- if is_map(price_modifiers) do
- Enum.flat_map(price_modifiers, fn
- {option_key, values} when is_map(values) ->
- available_values = Map.get(option_values, option_key, [])
- validate_option_modifiers(option_key, values, available_values)
-
- {option_key, _invalid} ->
- # Skip non-map values but could log warning
- [{option_key, "price_modifiers values must be a map"}]
- end)
- else
- [{"_price_modifiers", "must be a map"}]
- end
- end
-
- def validate_consistency(_), do: []
-
- defp validate_option_modifiers(_option_key, _values, []), do: []
-
- defp validate_option_modifiers(option_key, values, available_values) do
- Enum.flat_map(values, fn {value, _modifier} ->
- validate_single_modifier(option_key, value, available_values)
- end)
- end
-
- defp validate_single_modifier(option_key, value, available_values) do
- if value in available_values do
- []
- else
- [{option_key, "modifier for '#{value}' has no corresponding option value"}]
- end
- end
-
- @doc """
- Removes orphaned modifiers for values not in _option_values.
-
- This cleans up price modifiers when option values are removed.
-
- ## Examples
-
- metadata = %{
- "_option_values" => %{"size" => ["M", "L"]},
- "_price_modifiers" => %{"size" => %{"S" => "0", "M" => "5.00", "L" => "10.00"}}
- }
-
- MetadataValidator.clean_orphaned_modifiers(metadata)
- # => %{
- # "_option_values" => %{"size" => ["M", "L"]},
- # "_price_modifiers" => %{"size" => %{"M" => "5.00", "L" => "10.00"}}
- # }
- """
- def clean_orphaned_modifiers(metadata) when is_map(metadata) do
- option_values = Map.get(metadata, "_option_values", %{})
- price_modifiers = Map.get(metadata, "_price_modifiers", %{})
-
- if price_modifiers == %{} do
- metadata
- else
- cleaned_modifiers = clean_all_modifiers(price_modifiers, option_values)
- apply_cleaned_modifiers(metadata, cleaned_modifiers)
- end
- end
-
- def clean_orphaned_modifiers(metadata), do: metadata
-
- defp clean_all_modifiers(price_modifiers, option_values) when is_map(price_modifiers) do
- price_modifiers
- |> Enum.flat_map(fn
- {option_key, values} when is_map(values) ->
- available_values = Map.get(option_values, option_key, [])
- [{option_key, clean_option_modifiers(values, available_values)}]
-
- {_option_key, _invalid} ->
- # Skip non-map values
- []
- end)
- |> Enum.reject(fn {_k, v} -> v == %{} end)
- |> Map.new()
- end
-
- defp clean_all_modifiers(_invalid, _option_values), do: %{}
-
- # If no option_values for this key, keep all modifiers (schema-based)
- defp clean_option_modifiers(values, []), do: values
-
- defp clean_option_modifiers(values, available_values) do
- Map.filter(values, fn {value, _} -> value in available_values end)
- end
-
- defp apply_cleaned_modifiers(metadata, cleaned) when cleaned == %{},
- do: Map.delete(metadata, "_price_modifiers")
-
- defp apply_cleaned_modifiers(metadata, cleaned),
- do: Map.put(metadata, "_price_modifiers", cleaned)
-
- @doc """
- Normalizes all price modifiers to string format.
-
- Converts object format to string format:
- - `%{"type" => "fixed", "value" => "10.00"}` -> `"10.00"`
- - `%{"value" => "10.00"}` -> `"10.00"`
- - `%{"final_price" => "30.00"}` with base_price 20 -> `"10.00"`
-
- Already-string values are passed through unchanged.
-
- ## Examples
-
- metadata = %{
- "_price_modifiers" => %{
- "size" => %{
- "M" => %{"type" => "fixed", "value" => "5.00"},
- "L" => "10.00"
- }
- }
- }
-
- MetadataValidator.normalize_price_modifiers(metadata)
- # => %{
- # "_price_modifiers" => %{
- # "size" => %{"M" => "5.00", "L" => "10.00"}
- # }
- # }
- """
- def normalize_price_modifiers(metadata, base_price \\ nil)
-
- def normalize_price_modifiers(metadata, base_price) when is_map(metadata) do
- case Map.get(metadata, "_price_modifiers") do
- nil ->
- metadata
-
- price_modifiers when is_map(price_modifiers) ->
- normalized =
- Enum.map(price_modifiers, fn {option_key, values} ->
- normalized_values =
- Enum.map(values, fn {value, modifier} ->
- {value, normalize_modifier_value(modifier, base_price)}
- end)
- |> Enum.reject(fn {_k, v} -> is_nil(v) end)
- |> Map.new()
-
- {option_key, normalized_values}
- end)
- |> Enum.reject(fn {_k, v} -> v == %{} end)
- |> Map.new()
-
- if normalized == %{} do
- Map.delete(metadata, "_price_modifiers")
- else
- Map.put(metadata, "_price_modifiers", normalized)
- end
-
- _ ->
- metadata
- end
- end
-
- def normalize_price_modifiers(metadata, _base_price), do: metadata
-
- @doc """
- Normalizes a complete set of product attributes before saving.
-
- This function:
- 1. Normalizes price modifiers to string format
- 2. Cleans orphaned modifiers
- 3. Removes empty _option_values and _price_modifiers maps
-
- ## Examples
-
- attrs = %{
- "title" => "My Product",
- "metadata" => %{
- "_option_values" => %{"size" => ["M", "L"]},
- "_price_modifiers" => %{
- "size" => %{
- "M" => %{"type" => "fixed", "value" => "5.00"},
- "S" => "orphaned"
- }
- }
- }
- }
-
- MetadataValidator.normalize_product_attrs(attrs)
- # Normalizes modifiers and removes orphaned "S" entry
- """
- def normalize_product_attrs(attrs) when is_map(attrs) do
- case attrs do
- %{"metadata" => metadata, "price" => price} when is_map(metadata) ->
- base_price = parse_decimal(price)
- normalized = normalize_and_clean(metadata, base_price)
- Map.put(attrs, "metadata", normalized)
-
- %{"metadata" => metadata} when is_map(metadata) ->
- normalized = normalize_and_clean(metadata, nil)
- Map.put(attrs, "metadata", normalized)
-
- _ ->
- attrs
- end
- end
-
- def normalize_product_attrs(attrs), do: attrs
-
- # Private helpers
-
- defp normalize_and_clean(metadata, base_price) do
- metadata
- |> normalize_price_modifiers(base_price)
- |> clean_orphaned_modifiers()
- |> clean_empty_maps()
- end
-
- defp clean_empty_maps(metadata) do
- metadata
- |> maybe_remove_empty_key("_option_values")
- |> maybe_remove_empty_key("_price_modifiers")
- end
-
- defp maybe_remove_empty_key(metadata, key) do
- case Map.get(metadata, key) do
- val when val == %{} or val == nil -> Map.delete(metadata, key)
- _ -> metadata
- end
- end
-
- defp normalize_modifier_value(modifier, base_price) when is_map(modifier) do
- cond do
- # Object with value key
- Map.has_key?(modifier, "value") and modifier["value"] != "" ->
- modifier["value"]
-
- # Object with final_price key (needs conversion)
- Map.has_key?(modifier, "final_price") and modifier["final_price"] != "" and
- not is_nil(base_price) ->
- final_price = parse_decimal(modifier["final_price"])
- delta = Decimal.sub(final_price, base_price)
- Decimal.to_string(Decimal.round(delta, 2))
-
- # Empty or invalid object
- true ->
- nil
- end
- end
-
- defp normalize_modifier_value(modifier, _base_price) when is_binary(modifier) do
- # Already in string format
- if modifier == "" do
- nil
- else
- modifier
- end
- end
-
- defp normalize_modifier_value(_, _), do: nil
-
- defp validate_values(_metadata, _schema) do
- # Delegate to Options.validate_metadata for value validation
- # This avoids duplicating the validation logic
- []
- end
-
- defp parse_decimal(nil), do: Decimal.new("0")
- defp parse_decimal(""), do: Decimal.new("0")
-
- defp parse_decimal(value) when is_binary(value) do
- case Decimal.parse(value) do
- {decimal, _} -> decimal
- :error -> Decimal.new("0")
- end
- end
-
- defp parse_decimal(%Decimal{} = value), do: value
- defp parse_decimal(_), do: Decimal.new("0")
-end
diff --git a/lib/modules/shop/options/option_types.ex b/lib/modules/shop/options/option_types.ex
deleted file mode 100644
index b23461644..000000000
--- a/lib/modules/shop/options/option_types.ex
+++ /dev/null
@@ -1,434 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.OptionTypes do
- @moduledoc """
- Supported option types for product options.
-
- ## Supported Types
-
- - `text` - Free-form text input
- - `number` - Numeric input (optional min/max/step validation)
- - `boolean` - Checkbox/toggle
- - `select` - Single choice dropdown (requires options)
- - `multiselect` - Multiple choice selection (requires options)
-
- ## Option Schema Format (Simple)
-
- %{
- "key" => "material",
- "label" => "Material",
- "type" => "select",
- "options" => ["PLA", "ABS", "PETG"],
- "default" => "PLA",
- "required" => false,
- "unit" => nil,
- "position" => 0,
- "affects_price" => true,
- "modifier_type" => "fixed",
- "price_modifiers" => %{
- "PLA" => "0",
- "ABS" => "5.00",
- "PETG" => "10.00"
- }
- }
-
- ## Option Schema Format (Enhanced with Localization)
-
- %{
- "key" => "color",
- "label" => %{"en" => "Color", "ru" => "Цвет"},
- "type" => "select",
- "allow_multiple_slots" => true,
- "options" => [
- %{"value" => "red", "label" => %{"en" => "Red", "ru" => "Красный"}, "hex" => "#FF0000"},
- %{"value" => "blue", "label" => %{"en" => "Blue", "ru" => "Синий"}, "hex" => "#0000FF"}
- ]
- }
-
- ## Multiple Slots
-
- When `allow_multiple_slots: true`, the same global option can be used
- multiple times in a product with different slot names. For example:
-
- - Global option "color" can be used as "cup_color" and "liquid_color"
- - Slots are stored in product metadata["_option_slots"]
- - Each slot references the source global option key
-
- ## Price Modifiers
-
- For `select` and `multiselect` types, you can enable price modifiers:
- - `affects_price` - Boolean indicating if this option affects product price
- - `modifier_type` - "fixed" or "percent"
- - `price_modifiers` - Map of option value to price delta (as string decimal)
- - `allow_override` - Boolean, allows overriding price modifiers per-product
-
- ## Modifier Types
-
- - `fixed` - Add exact amount to base price (e.g., +$10)
- - `percent` - Add percentage of base price (e.g., +20% of $20 = +$4)
-
- ## Allow Override
-
- When `allow_override: true`, the price modifier values can be customized
- for each individual product. The global values serve as defaults.
- Overridden values are stored in product's metadata["_price_modifiers"].
-
- ## Price Calculation Order
-
- 1. Sum all fixed modifiers
- 2. Add to base price (intermediate price)
- 3. Sum all percent modifiers
- 4. Apply percent to intermediate price
-
- Example:
- - Base price: $20
- - Material: PETG (+$10 fixed)
- - Finish: Premium (+20% percent)
- - Final: ($20 + $10) * 1.20 = $36
- """
-
- @supported_types ["text", "number", "boolean", "select", "multiselect"]
- @modifier_types ["fixed", "percent"]
-
- @doc """
- Returns list of supported option types.
- """
- def supported_types, do: @supported_types
-
- @doc """
- Returns list of supported modifier types.
- """
- def modifier_types, do: @modifier_types
-
- @doc """
- Checks if a type is valid.
- """
- def valid_type?(type) when is_binary(type), do: type in @supported_types
- def valid_type?(_), do: false
-
- @doc """
- Checks if a modifier type is valid.
- """
- def valid_modifier_type?(type) when is_binary(type), do: type in @modifier_types
- def valid_modifier_type?(_), do: false
-
- @doc """
- Extracts option values from options list.
-
- Works with both simple string format and enhanced map format:
- - Simple: ["Red", "Blue"] -> ["Red", "Blue"]
- - Enhanced: [%{"value" => "red", "label" => ...}] -> ["red"]
- """
- def get_option_values(options) when is_list(options) do
- Enum.map(options, &extract_option_value/1)
- end
-
- def get_option_values(_), do: []
-
- defp extract_option_value(opt) when is_binary(opt), do: opt
- defp extract_option_value(%{"value" => value}) when is_binary(value), do: value
- defp extract_option_value(_), do: nil
-
- @doc """
- Gets localized label for an option or option value.
-
- Handles both string labels and localized map labels.
- Falls back to default language or first available.
- """
- def get_label(label, language \\ "en")
-
- def get_label(label, _language) when is_binary(label), do: label
-
- def get_label(label, language) when is_map(label) do
- # Try exact language match
- case Map.get(label, language) do
- nil ->
- # Try "en" as fallback
- case Map.get(label, "en") do
- nil ->
- # Use first available value
- case Map.values(label) do
- [first | _] -> first
- [] -> ""
- end
-
- en_label ->
- en_label
- end
-
- lang_label ->
- lang_label
- end
- end
-
- def get_label(_, _), do: ""
-
- @doc """
- Checks if option allows multiple slots.
- """
- def allows_multiple_slots?(%{"allow_multiple_slots" => true}), do: true
- def allows_multiple_slots?(_), do: false
-
- @doc """
- Checks if a type requires options array.
- """
- def requires_options?("select"), do: true
- def requires_options?("multiselect"), do: true
- def requires_options?(_), do: false
-
- @doc """
- Checks if a type supports price modifiers.
- """
- def supports_price_modifiers?("select"), do: true
- def supports_price_modifiers?("multiselect"), do: true
- def supports_price_modifiers?(_), do: false
-
- @doc """
- Validates an option definition map.
-
- ## Required Keys
-
- - `key` - Unique identifier (string)
- - `label` - Display label (string)
- - `type` - One of supported types
-
- ## Optional Keys
-
- - `options` - Required for select/multiselect types
- - `default` - Default value
- - `required` - Whether field is required (boolean)
- - `unit` - Unit label (e.g., "cm", "kg")
- - `position` - Sort order (integer)
- - `affects_price` - Whether this option affects price (boolean)
- - `modifier_type` - "fixed" or "percent" (defaults to "fixed")
- - `price_modifiers` - Map of option value to price modifier
-
- ## Examples
-
- iex> OptionTypes.validate_option(%{"key" => "material", "label" => "Material", "type" => "text"})
- {:ok, %{"key" => "material", "label" => "Material", "type" => "text"}}
-
- iex> OptionTypes.validate_option(%{"key" => "color", "label" => "Color", "type" => "select", "options" => ["Red", "Blue"]})
- {:ok, %{"key" => "color", "label" => "Color", "type" => "select", "options" => ["Red", "Blue"]}}
-
- iex> OptionTypes.validate_option(%{"key" => "test"})
- {:error, "Missing required keys: label, type"}
- """
- def validate_option(opt) when is_map(opt) do
- with :ok <- validate_required_keys(opt),
- :ok <- validate_key_format(opt),
- :ok <- validate_label_format(opt),
- :ok <- validate_type(opt),
- :ok <- validate_allow_multiple_slots(opt),
- :ok <- validate_select_options(opt),
- :ok <- validate_price_modifiers(opt) do
- {:ok, normalize_option(opt)}
- end
- end
-
- def validate_option(_), do: {:error, "Option must be a map"}
-
- @doc """
- Validates a list of option definitions.
- Returns {:ok, options} or {:error, reason} on first failure.
- """
- def validate_options(options) when is_list(options) do
- results = Enum.map(options, &validate_option/1)
- errors = Enum.filter(results, &match?({:error, _}, &1))
-
- case errors do
- [] -> {:ok, Enum.map(results, fn {:ok, opt} -> opt end)}
- [{:error, reason} | _] -> {:error, reason}
- end
- end
-
- def validate_options(_), do: {:error, "Options must be a list"}
-
- # Private functions
-
- defp validate_required_keys(opt) do
- required = ["key", "label", "type"]
- missing = Enum.reject(required, &Map.has_key?(opt, &1))
-
- case missing do
- [] -> :ok
- keys -> {:error, "Missing required keys: #{Enum.join(keys, ", ")}"}
- end
- end
-
- defp validate_key_format(%{"key" => key}) when is_binary(key) do
- if String.match?(key, ~r/^[a-z][a-z0-9_]*$/) do
- :ok
- else
- {:error, "Key must be lowercase alphanumeric with underscores, starting with a letter"}
- end
- end
-
- defp validate_key_format(_), do: {:error, "Key must be a string"}
-
- # Label can be a string or a localized map
- defp validate_label_format(%{"label" => label}) when is_binary(label), do: :ok
-
- defp validate_label_format(%{"label" => label}) when is_map(label) do
- # Localized format: %{"en" => "Color", "ru" => "Цвет"}
- if Enum.all?(label, fn {k, v} -> is_binary(k) and is_binary(v) end) do
- :ok
- else
- {:error, "Localized label must be a map of language code => string"}
- end
- end
-
- defp validate_label_format(_), do: {:error, "Label must be a string or localized map"}
-
- # allow_multiple_slots is optional boolean
- defp validate_allow_multiple_slots(%{"allow_multiple_slots" => value}) when is_boolean(value),
- do: :ok
-
- defp validate_allow_multiple_slots(%{"allow_multiple_slots" => _}),
- do: {:error, "allow_multiple_slots must be a boolean"}
-
- defp validate_allow_multiple_slots(_), do: :ok
-
- defp validate_type(%{"type" => type}) do
- if valid_type?(type) do
- :ok
- else
- {:error, "Invalid type '#{type}'. Must be one of: #{Enum.join(@supported_types, ", ")}"}
- end
- end
-
- defp validate_select_options(%{"type" => type, "options" => options})
- when type in ["select", "multiselect"] do
- cond do
- not is_list(options) ->
- {:error, "Options must be a list for #{type} type"}
-
- Enum.empty?(options) ->
- {:error, "Options cannot be empty for #{type} type"}
-
- Enum.all?(options, &is_binary/1) ->
- # Simple string format - valid
- :ok
-
- Enum.all?(options, &valid_option_map?/1) ->
- # Enhanced map format - valid
- :ok
-
- true ->
- {:error, "Options must be strings or maps with 'value' key"}
- end
- end
-
- defp validate_select_options(%{"type" => type}) when type in ["select", "multiselect"] do
- {:error, "Options are required for #{type} type"}
- end
-
- defp validate_select_options(_), do: :ok
-
- # Validates an option map has required 'value' key
- defp valid_option_map?(opt) when is_map(opt) do
- value = opt["value"]
- is_binary(value) and value != ""
- end
-
- defp valid_option_map?(_), do: false
-
- # Validate price modifiers for select/multiselect types
- defp validate_price_modifiers(%{"type" => type, "affects_price" => true} = opt)
- when type in ["select", "multiselect"] do
- modifier_type = Map.get(opt, "modifier_type", "fixed")
-
- if modifier_type in @modifier_types do
- validate_price_modifiers_map(opt)
- else
- {:error, "modifier_type must be one of: #{Enum.join(@modifier_types, ", ")}"}
- end
- end
-
- defp validate_price_modifiers(%{"type" => type, "affects_price" => true})
- when type not in ["select", "multiselect"] do
- {:error, "Price modifiers are only supported for select and multiselect types"}
- end
-
- defp validate_price_modifiers(_), do: :ok
-
- defp validate_price_modifiers_map(opt) do
- case opt do
- %{"price_modifiers" => modifiers} when is_map(modifiers) ->
- # Extract option values using helper that handles both formats
- option_values = get_option_values(opt["options"] || [])
-
- # Check that all options have modifiers
- missing = Enum.filter(option_values, fn o -> !Map.has_key?(modifiers, o) end)
-
- cond do
- missing != [] ->
- {:error, "Missing price modifiers for options: #{Enum.join(missing, ", ")}"}
-
- not valid_modifiers?(modifiers) ->
- {:error, "Price modifiers must be valid decimal strings (e.g., \"5.00\")"}
-
- true ->
- :ok
- end
-
- %{"price_modifiers" => _} ->
- {:error, "Price modifiers must be a map"}
-
- _ ->
- {:error, "Price modifiers are required when affects_price is true"}
- end
- end
-
- # Check if all modifier values are valid decimal strings
- defp valid_modifiers?(modifiers) when is_map(modifiers) do
- Enum.all?(modifiers, fn {_key, value} ->
- is_binary(value) and valid_decimal_string?(value)
- end)
- end
-
- defp valid_decimal_string?(str) do
- case Decimal.parse(str) do
- {_decimal, ""} -> true
- _ -> false
- end
- end
-
- defp normalize_option(opt) do
- opt
- |> Map.put_new("required", false)
- |> Map.put_new("position", 0)
- |> Map.put_new("enabled", true)
- |> normalize_affects_price()
- end
-
- # Ensure affects_price is false for non-select types
- defp normalize_affects_price(%{"type" => type} = opt)
- when type not in ["select", "multiselect"] do
- opt
- |> Map.delete("affects_price")
- |> Map.delete("modifier_type")
- |> Map.delete("price_modifiers")
- end
-
- defp normalize_affects_price(%{"affects_price" => true} = opt) do
- # Ensure price_modifiers has "0" as default for missing options
- # Use helper that handles both simple and enhanced formats
- option_values = get_option_values(opt["options"] || [])
- modifiers = opt["price_modifiers"] || %{}
-
- normalized_modifiers =
- Enum.reduce(option_values, modifiers, fn o, acc ->
- Map.put_new(acc, o, "0")
- end)
-
- opt
- |> Map.put("price_modifiers", normalized_modifiers)
- |> Map.put_new("modifier_type", "fixed")
- |> Map.put_new("allow_override", false)
- end
-
- defp normalize_affects_price(opt) do
- opt
- |> Map.put_new("affects_price", false)
- |> Map.delete("allow_override")
- end
-end
diff --git a/lib/modules/shop/options/options.ex b/lib/modules/shop/options/options.ex
deleted file mode 100644
index 9363a4e3b..000000000
--- a/lib/modules/shop/options/options.ex
+++ /dev/null
@@ -1,1361 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Options do
- @moduledoc """
- Context for managing product options.
-
- Provides a two-level option system:
- - **Global options** - Apply to all products (stored in shop_config)
- - **Category options** - Apply to products in specific category (stored in category.option_schema)
-
- When retrieving options for a product, the system merges global and category options,
- with category options overriding global ones by key.
-
- ## Localization Note
-
- Option labels and values are currently stored as plain strings, not localized JSONB maps.
- This means options display the same in all languages. Future enhancement: convert
- option schema to support localized labels like `"label" => %{"en" => "Material", "ru" => "Материал"}`.
-
- ## Usage
-
- # Get/set global options
- Options.get_global_options()
- Options.update_global_options([%{"key" => "material", "label" => "Material", "type" => "text"}])
-
- # Get/set category options
- Options.get_category_options(category)
- Options.update_category_options(category, [%{"key" => "mounting_type", ...}])
-
- # Get merged schema for a product
- Options.get_option_schema_for_product(product)
-
- # Validate product metadata against schema
- Options.validate_metadata(product.metadata, schema)
-
- ## Price Calculation
-
- Options with `affects_price: true` can modify the final product price.
- Two modifier types are supported:
-
- - `fixed` - Add exact amount (e.g., +$10)
- - `percent` - Add percentage of base price (e.g., +20%)
-
- ## Allow Override
-
- Options with `allow_override: true` can have their price modifiers customized
- per-product. Override values are stored in product metadata under `_price_modifiers`.
- When calculating price, the system checks for overrides first, then falls back
- to the default values from the option schema.
-
- Calculation order:
- 1. Sum all fixed modifiers (checking for overrides)
- 2. Add to base price (intermediate price)
- 3. Sum all percent modifiers (checking for overrides)
- 4. Apply percent to intermediate price
-
- Example:
- - Base price: $20
- - Material: PETG (+$10 fixed)
- - Finish: Premium (+20% percent)
- - Final: ($20 + $10) * 1.20 = $36
- """
-
- alias PhoenixKit.Modules.Shop.Category
- alias PhoenixKit.Modules.Shop.OptionTypes
- alias PhoenixKit.Modules.Shop.ShopConfig
-
- @global_schema_key "global_option_schema"
-
- # ============================================
- # GLOBAL OPTIONS
- # ============================================
-
- @doc """
- Gets global option schema.
-
- Returns a list of option definitions that apply to all products.
- """
- def get_global_options do
- case repo().get(ShopConfig, @global_schema_key) do
- nil -> []
- %ShopConfig{value: %{"options" => opts}} when is_list(opts) -> opts
- %ShopConfig{value: _} -> []
- end
- end
-
- @doc """
- Gets enabled global options only.
-
- Filters out options where `enabled` is explicitly set to `false`.
- Options without the `enabled` key default to enabled (backward compatible).
- """
- def get_enabled_global_options do
- get_global_options()
- |> Enum.filter(fn opt -> Map.get(opt, "enabled", true) != false end)
- end
-
- @doc """
- Updates global option schema.
-
- ## Examples
-
- Options.update_global_options([
- %{"key" => "material", "label" => "Material", "type" => "select",
- "options" => ["PLA", "ABS", "PETG"], "default" => "PLA"}
- ])
- """
- def update_global_options(options) when is_list(options) do
- with {:ok, validated} <- OptionTypes.validate_options(options) do
- wrapped_value = %{"options" => validated}
-
- case repo().get(ShopConfig, @global_schema_key) do
- nil ->
- %ShopConfig{}
- |> ShopConfig.changeset(%{key: @global_schema_key, value: wrapped_value})
- |> repo().insert()
-
- config ->
- config
- |> ShopConfig.changeset(%{value: wrapped_value})
- |> repo().update()
- end
- end
- end
-
- @doc """
- Adds a single option to global schema.
- """
- def add_global_option(opt) when is_map(opt) do
- with {:ok, validated} <- OptionTypes.validate_option(opt) do
- current = get_global_options()
-
- # Check for duplicate key
- if Enum.any?(current, &(&1["key"] == validated["key"])) do
- {:error, "Option with key '#{validated["key"]}' already exists"}
- else
- update_global_options(current ++ [validated])
- end
- end
- end
-
- @doc """
- Removes an option from global schema by key.
- """
- def remove_global_option(key) when is_binary(key) do
- current = get_global_options()
- updated = Enum.reject(current, &(&1["key"] == key))
- update_global_options(updated)
- end
-
- @doc """
- Gets a single global option by key.
-
- Returns the option definition map or nil if not found.
-
- ## Examples
-
- Options.get_global_option_by_key("color")
- # => %{"key" => "color", "label" => "Color", "type" => "select", ...}
- """
- def get_global_option_by_key(key) when is_binary(key) do
- get_global_options()
- |> Enum.find(&(&1["key"] == key))
- end
-
- def get_global_option_by_key(_), do: nil
-
- @doc """
- Adds a new value to an existing global option.
-
- Works with both simple string options and enhanced map options.
- For enhanced format, value_map should be a map with at least "value" key.
-
- ## Examples
-
- # Simple format - adds "yellow" to options list
- Options.add_value_to_global_option("color", "yellow")
-
- # Enhanced format - adds map to options list
- Options.add_value_to_global_option("color", %{
- "value" => "yellow",
- "label" => %{"en" => "Yellow", "ru" => "Жёлтый"},
- "hex" => "#FFFF00"
- })
- """
- def add_value_to_global_option(key, value_or_map) when is_binary(key) do
- case get_global_option_by_key(key) do
- nil ->
- {:error, "Global option '#{key}' not found"}
-
- option ->
- do_add_value_to_option(key, option, value_or_map)
- end
- end
-
- defp do_add_value_to_option(key, option, value_or_map) do
- current_options = option["options"] || []
- new_value = normalize_option_value(value_or_map, current_options)
-
- if value_exists?(current_options, new_value) do
- {:ok, option}
- else
- updated_option = Map.put(option, "options", current_options ++ [new_value])
- replace_global_option(key, updated_option)
- end
- end
-
- defp replace_global_option(key, updated_option) do
- all_options = get_global_options()
-
- updated_all =
- Enum.map(all_options, fn opt ->
- if opt["key"] == key, do: updated_option, else: opt
- end)
-
- update_global_options(updated_all)
- end
-
- # Normalize value to match existing format (string or map)
- defp normalize_option_value(value, current_options) when is_binary(value) do
- # Check if current options are in enhanced format
- if Enum.any?(current_options, &is_map/1) do
- %{"value" => value, "label" => value}
- else
- value
- end
- end
-
- defp normalize_option_value(value_map, _current_options) when is_map(value_map) do
- value_map
- end
-
- defp normalize_option_value(value, _), do: to_string(value)
-
- # Check if value already exists in options list
- defp value_exists?(options, new_value) when is_binary(new_value) do
- Enum.any?(options, fn opt ->
- case opt do
- ^new_value -> true
- %{"value" => ^new_value} -> true
- _ -> false
- end
- end)
- end
-
- defp value_exists?(options, %{"value" => value}) do
- value_exists?(options, value)
- end
-
- defp value_exists?(_, _), do: false
-
- # ============================================
- # CATEGORY OPTIONS
- # ============================================
-
- @doc """
- Gets category-specific option schema.
- """
- def get_category_options(%Category{option_schema: schema}) when is_list(schema) do
- schema
- end
-
- def get_category_options(%Category{}) do
- []
- end
-
- def get_category_options(category_uuid) when is_binary(category_uuid) do
- result =
- if uuid_string?(category_uuid) do
- repo().get_by(Category, uuid: category_uuid)
- else
- nil
- end
-
- case result do
- nil -> []
- category -> get_category_options(category)
- end
- end
-
- def get_category_options(_), do: []
-
- @doc """
- Updates category option schema.
- """
- def update_category_options(%Category{} = category, options) when is_list(options) do
- with {:ok, validated} <- OptionTypes.validate_options(options) do
- category
- |> Category.changeset(%{option_schema: validated})
- |> repo().update()
- end
- end
-
- @doc """
- Adds a single option to category schema.
- """
- def add_category_option(%Category{} = category, opt) when is_map(opt) do
- with {:ok, validated} <- OptionTypes.validate_option(opt) do
- current = get_category_options(category)
-
- if Enum.any?(current, &(&1["key"] == validated["key"])) do
- {:error, "Option with key '#{validated["key"]}' already exists in this category"}
- else
- update_category_options(category, current ++ [validated])
- end
- end
- end
-
- @doc """
- Removes an option from category schema by key.
- """
- def remove_category_option(%Category{} = category, key) when is_binary(key) do
- current = get_category_options(category)
- updated = Enum.reject(current, &(&1["key"] == key))
- update_category_options(category, updated)
- end
-
- # ============================================
- # MERGED SCHEMA (Global + Category)
- # ============================================
-
- @doc """
- Gets merged option schema for a product.
-
- Combines global options with category-specific options.
- Category options override global ones with the same key.
-
- ## Examples
-
- # Product with category
- schema = Options.get_option_schema_for_product(product)
-
- # Product without category (global only)
- schema = Options.get_option_schema_for_product(product_without_category)
- """
- def get_option_schema_for_product(product) do
- global = get_enabled_global_options()
-
- category_opts =
- case product do
- %{category: %Category{} = cat} -> get_category_options(cat)
- %{category_uuid: nil} -> []
- %{category_uuid: uuid} when is_binary(uuid) -> get_category_options(uuid)
- _ -> []
- end
-
- merge_schemas(global, category_opts)
- end
-
- @doc """
- Merges two option schemas, with the second overriding the first by key.
- """
- def merge_schemas(base, override) when is_list(base) and is_list(override) do
- override_keys = Enum.map(override, & &1["key"])
-
- filtered_base =
- Enum.reject(base, fn opt ->
- opt["key"] in override_keys
- end)
-
- # Sort by position
- (filtered_base ++ override)
- |> Enum.sort_by(& &1["position"], :asc)
- end
-
- # ============================================
- # SLOT-BASED OPTIONS
- # ============================================
-
- @doc """
- Gets slot-based options for a product.
-
- Resolves `_option_slots` from product metadata to full option specs.
- Each slot references a global option via `source_key` and creates a
- customized option spec with the slot's key and label.
-
- ## Examples
-
- product.metadata = %{
- "_option_slots" => [
- %{"slot" => "cup_color", "label" => %{"en" => "Cup Color"}, "source_key" => "color"},
- %{"slot" => "liquid_color", "label" => %{"en" => "Liquid"}, "source_key" => "color"}
- ]
- }
-
- Options.get_slot_options_for_product(product)
- # => [
- # %{"key" => "cup_color", "label" => %{"en" => "Cup Color"}, "type" => "select", ...},
- # %{"key" => "liquid_color", "label" => %{"en" => "Liquid"}, "type" => "select", ...}
- # ]
- """
- def get_slot_options_for_product(product) do
- metadata = product.metadata || %{}
- slots = Map.get(metadata, "_option_slots", [])
-
- Enum.flat_map(slots, fn slot ->
- case resolve_slot_to_option(slot) do
- nil -> []
- option -> [option]
- end
- end)
- end
-
- @doc """
- Resolves a single slot definition to a full option spec.
-
- Takes a slot map with "slot", "label", and "source_key",
- finds the referenced global option, and creates a new spec
- with the slot's key and label but the source's type and values.
- """
- def resolve_slot_to_option(%{"slot" => slot_key, "source_key" => source_key} = slot) do
- case get_global_option_by_key(source_key) do
- nil ->
- nil
-
- source_option ->
- if Map.get(source_option, "enabled", true) == false do
- nil
- else
- # Create new option spec using slot key/label but source's type/options
- %{
- "key" => slot_key,
- "label" => slot["label"] || slot_key,
- "type" => source_option["type"],
- "options" => source_option["options"],
- "source_key" => source_key,
- "required" => Map.get(slot, "required", false),
- "position" => Map.get(slot, "position", 0)
- }
- |> maybe_add_price_modifiers(source_option)
- end
- end
- end
-
- def resolve_slot_to_option(_), do: nil
-
- # Copy price modifier settings from source option if present
- defp maybe_add_price_modifiers(slot_option, source_option) do
- if source_option["affects_price"] do
- slot_option
- |> Map.put("affects_price", true)
- |> Map.put("modifier_type", source_option["modifier_type"] || "fixed")
- |> Map.put("price_modifiers", source_option["price_modifiers"] || %{})
- |> Map.put("allow_override", source_option["allow_override"] || false)
- else
- slot_option
- end
- end
-
- @doc """
- Gets complete option schema for a product including slot-based options.
-
- This combines:
- 1. Global options (excluding those used as slot sources)
- 2. Category options
- 3. Slot-based options from product metadata
-
- ## Examples
-
- Options.get_complete_option_schema_for_product(product)
- """
- def get_complete_option_schema_for_product(product) do
- base_schema = get_option_schema_for_product(product)
- slot_options = get_slot_options_for_product(product)
-
- # Get source keys used by slots to exclude from base schema
- source_keys =
- slot_options
- |> Enum.map(& &1["source_key"])
- |> Enum.reject(&is_nil/1)
- |> MapSet.new()
-
- # Filter out global options that are used as slot sources
- # (but keep if allow_multiple_slots is false)
- filtered_base =
- Enum.reject(base_schema, fn opt ->
- key = opt["key"]
- MapSet.member?(source_keys, key) and OptionTypes.allows_multiple_slots?(opt)
- end)
-
- # Merge and sort by position
- (filtered_base ++ slot_options)
- |> Enum.sort_by(& &1["position"], :asc)
- end
-
- @doc """
- Builds option slots structure for product metadata.
-
- Creates the `_option_slots` array from a list of slot definitions.
-
- ## Examples
-
- Options.build_option_slots([
- %{slot: "cup_color", source_key: "color", label: %{"en" => "Cup Color"}},
- %{slot: "liquid_color", source_key: "color", label: %{"en" => "Liquid"}}
- ])
- # => [
- # %{"slot" => "cup_color", "source_key" => "color", "label" => %{"en" => "Cup Color"}},
- # %{"slot" => "liquid_color", "source_key" => "color", "label" => %{"en" => "Liquid"}}
- # ]
- """
- def build_option_slots(slots) when is_list(slots) do
- Enum.map(slots, fn slot ->
- %{
- "slot" => to_string(slot[:slot] || slot["slot"]),
- "source_key" => to_string(slot[:source_key] || slot["source_key"]),
- "label" => slot[:label] || slot["label"] || slot[:slot] || slot["slot"]
- }
- |> maybe_add_position(slot)
- end)
- end
-
- def build_option_slots(_), do: []
-
- defp maybe_add_position(slot_map, source) do
- position = source[:position] || source["position"]
- if position, do: Map.put(slot_map, "position", position), else: slot_map
- end
-
- # ============================================
- # VALUE VALIDATION
- # ============================================
-
- @doc """
- Validates product metadata against option schema.
-
- Returns `:ok` or `{:error, errors}` where errors is a list of `{key, message}` tuples.
-
- ## Examples
-
- schema = [%{"key" => "material", "type" => "select", "options" => ["PLA", "ABS"], "required" => true}]
-
- Options.validate_metadata(%{"material" => "PLA"}, schema)
- # => :ok
-
- Options.validate_metadata(%{}, schema)
- # => {:error, [{"material", "is required"}]}
-
- Options.validate_metadata(%{"material" => "Invalid"}, schema)
- # => {:error, [{"material", "must be one of: PLA, ABS"}]}
- """
- def validate_metadata(metadata, schema) when is_map(metadata) and is_list(schema) do
- required_errors =
- schema
- |> Enum.filter(& &1["required"])
- |> Enum.reject(fn opt ->
- value = Map.get(metadata, opt["key"])
- value != nil and value != ""
- end)
- |> Enum.map(fn opt -> {opt["key"], "is required"} end)
-
- type_errors =
- Enum.flat_map(schema, fn opt ->
- value = Map.get(metadata, opt["key"])
- validate_value_type(opt, value)
- end)
-
- case required_errors ++ type_errors do
- [] -> :ok
- errors -> {:error, errors}
- end
- end
-
- def validate_metadata(_, _), do: :ok
-
- # Skip validation for nil/empty values (handled by required check)
- defp validate_value_type(_opt, nil), do: []
- defp validate_value_type(_opt, ""), do: []
-
- defp validate_value_type(%{"key" => key, "type" => "number"}, value) do
- cond do
- is_number(value) -> []
- is_binary(value) and String.match?(value, ~r/^-?\d+\.?\d*$/) -> []
- true -> [{key, "must be a number"}]
- end
- end
-
- defp validate_value_type(%{"key" => key, "type" => "boolean"}, value) do
- if is_boolean(value) or value in ["true", "false"] do
- []
- else
- [{key, "must be a boolean"}]
- end
- end
-
- defp validate_value_type(%{"key" => key, "type" => "select", "options" => opts}, value) do
- if value in opts do
- []
- else
- [{key, "must be one of: #{Enum.join(opts, ", ")}"}]
- end
- end
-
- defp validate_value_type(%{"key" => key, "type" => "multiselect", "options" => opts}, value) do
- values = if is_list(value), do: value, else: [value]
-
- if Enum.all?(values, &(&1 in opts)) do
- []
- else
- [{key, "must be a list of: #{Enum.join(opts, ", ")}"}]
- end
- end
-
- # text type accepts any string
- defp validate_value_type(%{"type" => "text"}, _value), do: []
-
- # Unknown type - skip validation
- defp validate_value_type(_, _), do: []
-
- # ============================================
- # HELPER FUNCTIONS
- # ============================================
-
- @doc """
- Returns option by key from a schema.
- """
- def get_option_by_key(schema, key) when is_list(schema) and is_binary(key) do
- Enum.find(schema, &(&1["key"] == key))
- end
-
- @doc """
- Checks if an option key exists in schema.
- """
- def has_option?(schema, key) when is_list(schema) and is_binary(key) do
- Enum.any?(schema, &(&1["key"] == key))
- end
-
- # ============================================
- # PRICE MODIFIER FUNCTIONS
- # ============================================
-
- @doc """
- Gets price-affecting options from a schema.
-
- Returns only options that have `affects_price: true` and are
- of type `select` or `multiselect`.
-
- ## Examples
-
- schema = [
- %{"key" => "material", "type" => "select", "affects_price" => true, ...},
- %{"key" => "notes", "type" => "text", ...}
- ]
-
- Options.get_price_affecting_specs(schema)
- # => [%{"key" => "material", ...}]
- """
- def get_price_affecting_specs(schema) when is_list(schema) do
- Enum.filter(schema, fn opt ->
- opt["affects_price"] == true and opt["type"] in ["select", "multiselect"]
- end)
- end
-
- def get_price_affecting_specs(_), do: []
-
- @doc """
- Gets all selectable options from a schema.
-
- Returns options that are of type `select` or `multiselect` and not hidden.
- Unlike `get_price_affecting_specs/1`, this includes options regardless of
- whether they affect price. Use this for UI display of all selectable options.
-
- ## Examples
-
- schema = [
- %{"key" => "color", "type" => "select", "options" => ["Red", "Blue"]},
- %{"key" => "material", "type" => "select", "affects_price" => true, ...},
- %{"key" => "notes", "type" => "text", ...}
- ]
-
- Options.get_selectable_specs(schema)
- # => [%{"key" => "color", ...}, %{"key" => "material", ...}]
- """
- def get_selectable_specs(schema) when is_list(schema) do
- Enum.filter(schema, fn opt ->
- opt["type"] in ["select", "multiselect"] and
- Map.get(opt, "hidden", false) != true
- end)
- end
-
- def get_selectable_specs(_), do: []
-
- @doc """
- Gets all selectable options for a specific product.
-
- Combines global and category options, then filters for select/multiselect types.
- Also discovers options from product metadata that have values defined.
- Unlike `get_price_affecting_specs_for_product/1`, this includes all selectable
- options regardless of whether they affect price.
-
- Use this for displaying option selectors in the product UI.
- """
- def get_selectable_specs_for_product(product) do
- schema_specs =
- product
- |> get_option_schema_for_product()
- |> get_selectable_specs()
- |> filter_by_product_option_values(product)
-
- # Discover additional options from product metadata (without price requirement)
- discovered_specs = discover_selectable_options_from_metadata(product)
-
- # Merge: schema specs take priority over discovered
- merge_discovered_specs(schema_specs, discovered_specs)
- end
-
- @doc """
- Gets all selectable options for admin product detail view.
-
- Unlike `get_selectable_specs_for_product/1`, this does NOT filter schema options
- by product's `_option_values`. Shows all schema options (global + category) plus
- discovered options from metadata, giving admins the full picture.
- """
- def get_all_selectable_specs_for_admin(product) do
- # All schema selectable specs WITHOUT filtering by _option_values
- schema_specs =
- product
- |> get_option_schema_for_product()
- |> get_selectable_specs()
-
- # Discover additional options from product metadata
- discovered_specs = discover_selectable_options_from_metadata(product)
-
- # Merge: schema specs take priority over discovered
- merge_discovered_specs(schema_specs, discovered_specs)
- end
-
- # Discovers selectable options from product metadata.
- # Creates "virtual" option specs for keys found in _option_values.
- # Unlike discover_options_from_metadata/1, this doesn't require _price_modifiers.
- defp discover_selectable_options_from_metadata(product) do
- metadata = product.metadata || %{}
- option_values = Map.get(metadata, "_option_values", %{})
- price_modifiers = Map.get(metadata, "_price_modifiers", %{})
-
- # For each key in _option_values that has values
- option_values
- |> Enum.filter(fn {_key, values} ->
- is_list(values) and values != []
- end)
- |> Enum.map(fn {key, values} ->
- # Check if this option has price modifiers with at least one non-zero value
- key_modifiers = Map.get(price_modifiers, key, %{})
- has_price = key_modifiers != %{} and has_nonzero_modifiers?(key_modifiers)
-
- base_spec = %{
- "key" => key,
- "label" => humanize_key(key),
- "type" => "select",
- "options" => values,
- "_discovered" => true
- }
-
- if has_price do
- base_spec
- |> Map.put("affects_price", true)
- |> Map.put("modifier_type", "fixed")
- |> Map.put("allow_override", true)
- |> Map.put("price_modifiers", key_modifiers)
- else
- base_spec
- end
- end)
- end
-
- @doc """
- Gets price-affecting options for a specific product.
-
- Combines global and category options, then filters for price-affecting ones.
-
- If the product has `_option_values` in metadata, only returns options
- for which the product has values. This allows products without certain
- options (e.g., Size) to skip required validation for those options.
-
- Additionally, discovers options from product metadata that have price modifiers
- but are not defined in the schema (e.g., imported products with custom options).
- """
- def get_price_affecting_specs_for_product(product) do
- schema_specs =
- product
- |> get_option_schema_for_product()
- |> get_price_affecting_specs()
- |> filter_by_product_option_values(product)
-
- # Discover additional options from product metadata
- discovered_specs = discover_options_from_metadata(product)
-
- # Merge: schema specs take priority over discovered
- merge_discovered_specs(schema_specs, discovered_specs)
- end
-
- # Filters options - keeps only those for which product has values in metadata.
- # If product has no _option_values, returns all options (backward compatibility).
- # Also keeps schema specs that have image mappings AND their own defined options.
- defp filter_by_product_option_values(specs, product) do
- metadata = product.metadata || %{}
- option_values = Map.get(metadata, "_option_values", %{})
-
- # Only filter if product has _option_values (imported products)
- if option_values != %{} do
- image_mappings = Map.get(metadata, "_image_mappings", %{})
-
- Enum.filter(specs, fn spec ->
- key = spec["key"]
-
- case Map.get(option_values, key) do
- values when is_list(values) and values != [] ->
- true
-
- _ ->
- # Keep schema specs that have their own defined options or image mappings
- has_image_mappings = is_map(image_mappings[key]) and image_mappings[key] != %{}
- has_own_options = is_list(spec["options"]) and spec["options"] != []
- has_own_options or has_image_mappings
- end
- end)
- else
- # No _option_values - return all options (backward compatibility)
- specs
- end
- end
-
- # Discovers options from product metadata that have price modifiers with non-zero values.
- # Creates "virtual" option specs for keys found in _option_values that also
- # have corresponding _price_modifiers entries with at least one non-zero modifier.
- defp discover_options_from_metadata(product) do
- metadata = product.metadata || %{}
- option_values = Map.get(metadata, "_option_values", %{})
- price_modifiers = Map.get(metadata, "_price_modifiers", %{})
-
- # For each key in _option_values that has _price_modifiers with non-zero values
- option_values
- |> Enum.filter(fn {key, values} ->
- key_modifiers = Map.get(price_modifiers, key, %{})
-
- is_list(values) and values != [] and
- key_modifiers != %{} and has_nonzero_modifiers?(key_modifiers)
- end)
- |> Enum.map(fn {key, values} ->
- %{
- "key" => key,
- "label" => humanize_key(key),
- "type" => "select",
- "options" => values,
- "affects_price" => true,
- "modifier_type" => "fixed",
- "allow_override" => true,
- "price_modifiers" => Map.get(price_modifiers, key, %{}),
- "_discovered" => true
- }
- end)
- end
-
- # Checks if a price modifiers map has at least one non-zero value.
- # Used to determine if an option group actually affects pricing.
- defp has_nonzero_modifiers?(modifiers) when is_map(modifiers) do
- Enum.any?(modifiers, fn {_key, value} ->
- decimal =
- case value do
- %{"value" => v} when is_binary(v) -> safe_parse_decimal(v)
- v when is_binary(v) -> safe_parse_decimal(v)
- _ -> nil
- end
-
- decimal != nil and Decimal.compare(decimal, Decimal.new("0")) != :eq
- end)
- end
-
- defp has_nonzero_modifiers?(_), do: false
-
- defp safe_parse_decimal(value) when is_binary(value) do
- case Decimal.parse(value) do
- {decimal, ""} -> decimal
- _ -> nil
- end
- end
-
- # Converts snake_case key to human-readable label.
- # Example: "main_color" -> "Main Color"
- defp humanize_key(key) do
- key
- |> String.replace("_", " ")
- |> String.split(" ")
- |> Enum.map_join(" ", &String.capitalize/1)
- end
-
- # Merges schema specs with discovered specs.
- # Schema specs take priority - discovered specs are only added if their key
- # is not already in the schema.
- defp merge_discovered_specs(schema_specs, discovered_specs) do
- schema_keys = Enum.map(schema_specs, & &1["key"]) |> MapSet.new()
-
- # Only add discovered specs not already in schema
- new_specs =
- Enum.reject(discovered_specs, fn spec ->
- MapSet.member?(schema_keys, spec["key"])
- end)
-
- schema_specs ++ new_specs
- end
-
- @doc """
- Gets the price modifier for a specific option value.
-
- Returns a Decimal value representing the price delta for the selected option.
- Returns Decimal.new("0") if the option has no modifier or option doesn't affect price.
-
- For "custom" modifier type, the modifiers come from product metadata.
-
- ## Examples
-
- opt = %{
- "key" => "material",
- "affects_price" => true,
- "price_modifiers" => %{"PLA" => "0", "PETG" => "10.00"}
- }
-
- Options.get_price_modifier(opt, "PETG")
- # => Decimal.new("10.00")
-
- Options.get_price_modifier(opt, "PLA")
- # => Decimal.new("0")
- """
- def get_price_modifier(%{"affects_price" => true, "price_modifiers" => modifiers}, value)
- when is_map(modifiers) and is_binary(value) do
- case Map.get(modifiers, value) do
- nil ->
- Decimal.new("0")
-
- modifier when is_binary(modifier) ->
- parse_decimal(modifier)
- end
- end
-
- def get_price_modifier(_, _), do: Decimal.new("0")
-
- @doc """
- Gets the effective modifier info (type and value) for an option, checking for product overrides.
-
- Returns `{modifier_type, modifier_value}` tuple.
-
- If the option has `allow_override: true` and the product has an override in metadata,
- uses the override type and value. Otherwise uses defaults from option's schema.
-
- ## Override Structure
-
- Overrides in metadata can be:
- - New format: `%{"type" => "fixed", "value" => "10.00"}` - custom type and value
- - Legacy format: `"10.00"` - just value, inherits option's default type
-
- ## Examples
-
- # Option with custom override (type + value)
- opt = %{"key" => "material", "allow_override" => true, "modifier_type" => "fixed", ...}
- metadata = %{"_price_modifiers" => %{"material" => %{"PETG" => %{"type" => "percent", "value" => "15"}}}}
- get_effective_modifier_info(opt, "PETG", metadata)
- # => {"percent", Decimal.new("15")}
-
- # Option with legacy override (just value)
- metadata = %{"_price_modifiers" => %{"material" => %{"PETG" => "15.00"}}}
- get_effective_modifier_info(opt, "PETG", metadata)
- # => {"fixed", Decimal.new("15.00")} # Uses option's default type
- """
- def get_effective_modifier_info(opt, selected_value, metadata)
-
- def get_effective_modifier_info(
- %{"key" => key, "allow_override" => true, "modifier_type" => default_type} = opt,
- selected_value,
- metadata
- )
- when is_binary(selected_value) and is_map(metadata) do
- case get_override_info(metadata, key, selected_value) do
- {:ok, type, value} ->
- {type || default_type, Decimal.new(value)}
-
- :not_found ->
- default_value = get_price_modifier(opt, selected_value)
- {default_type, default_value}
- end
- end
-
- def get_effective_modifier_info(
- %{"modifier_type" => default_type} = opt,
- selected_value,
- _metadata
- ) do
- # No allow_override - use defaults
- {default_type, get_price_modifier(opt, selected_value)}
- end
-
- def get_effective_modifier_info(opt, selected_value, _metadata) do
- # Fallback: fixed type
- {"fixed", get_price_modifier(opt, selected_value)}
- end
-
- # Helper to get override info from metadata (type + value)
- defp get_override_info(metadata, option_key, option_value) do
- case metadata do
- %{"_price_modifiers" => %{^option_key => modifiers}} when is_map(modifiers) ->
- case Map.get(modifiers, option_value) do
- # New format: %{"type" => "percent", "value" => "15"}
- %{"type" => type, "value" => value} when is_binary(value) and value != "" ->
- {:ok, type, value}
-
- %{"value" => value} when is_binary(value) and value != "" ->
- {:ok, nil, value}
-
- # Legacy format: just a string value
- value when is_binary(value) and value != "" ->
- {:ok, nil, value}
-
- _ ->
- :not_found
- end
-
- _ ->
- :not_found
- end
- end
-
- # Legacy function - kept for backward compatibility
- def get_effective_modifier(opt, selected_value, metadata) do
- {_type, value} = get_effective_modifier_info(opt, selected_value, metadata)
- value
- end
-
- @doc """
- Gets the price modifier for overridden values from product metadata.
-
- Used when option has `allow_override: true` and the product has custom values
- stored in metadata under `_price_modifiers` key.
-
- ## Examples
-
- product_metadata = %{
- "_price_modifiers" => %{
- "material" => %{"PLA" => "0", "PETG" => "15.00"}
- }
- }
-
- Options.get_custom_price_modifier(product_metadata, "material", "PETG")
- # => Decimal.new("15.00")
- """
- def get_custom_price_modifier(metadata, option_key, option_value)
- when is_map(metadata) and is_binary(option_key) and is_binary(option_value) do
- case metadata do
- %{"_price_modifiers" => %{^option_key => modifiers}} when is_map(modifiers) ->
- case Map.get(modifiers, option_value) do
- nil -> Decimal.new("0")
- "" -> Decimal.new("0")
- modifier when is_binary(modifier) -> Decimal.new(modifier)
- _ -> Decimal.new("0")
- end
-
- _ ->
- Decimal.new("0")
- end
- end
-
- def get_custom_price_modifier(_, _, _), do: Decimal.new("0")
-
- @doc """
- Calculates total price modifier for selected specifications.
-
- Takes a list of price-affecting options, a map of selected values, and the base price.
- Returns the final price after applying all modifiers.
-
- ## Options
-
- - `product_metadata` - Optional product metadata for custom modifier values.
- When provided, options with `modifier_type: "custom"` will use price values
- from `metadata["_price_modifiers"][option_key][option_value]`.
-
- ## Calculation Order
-
- 1. Sum all fixed modifiers (from schema price_modifiers)
- 2. Sum all custom modifiers (from product metadata)
- 3. Add to base price (intermediate price)
- 4. Sum all percent modifiers
- 5. Apply percent to intermediate price: intermediate * (1 + percent_sum/100)
-
- ## Examples
-
- specs = [
- %{"key" => "material", "affects_price" => true, "modifier_type" => "fixed",
- "price_modifiers" => %{"PLA" => "0", "PETG" => "10.00"}},
- %{"key" => "finish", "affects_price" => true, "modifier_type" => "percent",
- "price_modifiers" => %{"Standard" => "0", "Premium" => "20"}}
- ]
-
- selected = %{"material" => "PETG", "finish" => "Premium"}
- base_price = Decimal.new("20.00")
-
- Options.calculate_final_price(specs, selected, base_price)
- # => Decimal.new("36.00") # ($20 + $10) * 1.20
- """
- def calculate_final_price(specs, selected_specs, base_price, product_metadata \\ %{})
-
- def calculate_final_price(specs, selected_specs, base_price, product_metadata)
- when is_list(specs) and is_map(selected_specs) do
- base = if is_nil(base_price), do: Decimal.new("0"), else: base_price
- metadata = product_metadata || %{}
-
- # For each option, get the effective type and value (considering overrides)
- # Then group by effective type
- modifiers =
- Enum.map(specs, fn opt ->
- selected_value = Map.get(selected_specs, opt["key"])
-
- if selected_value do
- {type, value} = get_effective_modifier_info(opt, selected_value, metadata)
- {type, value}
- else
- nil
- end
- end)
- |> Enum.reject(&is_nil/1)
-
- # Split into fixed and percent based on effective type
- {fixed_modifiers, percent_modifiers} =
- Enum.split_with(modifiers, fn {type, _value} -> type == "fixed" end)
-
- # Sum fixed modifiers
- fixed_sum =
- Enum.reduce(fixed_modifiers, Decimal.new("0"), fn {_type, value}, acc ->
- Decimal.add(acc, value)
- end)
-
- # Calculate intermediate price (base + fixed)
- intermediate = Decimal.add(base, fixed_sum)
-
- # Sum percent modifiers
- percent_sum =
- Enum.reduce(percent_modifiers, Decimal.new("0"), fn {_type, value}, acc ->
- Decimal.add(acc, value)
- end)
-
- # Apply percent modifier: intermediate * (1 + percent_sum/100)
- if Decimal.compare(percent_sum, Decimal.new("0")) == :gt do
- multiplier = Decimal.add(Decimal.new("1"), Decimal.div(percent_sum, Decimal.new("100")))
- Decimal.mult(intermediate, multiplier) |> Decimal.round(2)
- else
- intermediate
- end
- end
-
- def calculate_final_price(_, _, base_price, _), do: base_price || Decimal.new("0")
-
- @doc """
- Calculates total modifier amount (for backward compatibility).
-
- This function returns just the sum of fixed modifiers.
- For full calculation with percent modifiers, use `calculate_final_price/3`.
-
- ## Examples
-
- specs = [
- %{"key" => "material", "affects_price" => true, "price_modifiers" => %{"PETG" => "10.00"}},
- %{"key" => "color", "affects_price" => true, "price_modifiers" => %{"Gold" => "8.00"}}
- ]
-
- selected = %{"material" => "PETG", "color" => "Gold"}
-
- Options.calculate_total_modifier(specs, selected)
- # => Decimal.new("18.00")
- """
- def calculate_total_modifier(specs, selected_specs)
- when is_list(specs) and is_map(selected_specs) do
- # Only sum fixed modifiers for backward compatibility
- fixed_specs =
- Enum.filter(specs, fn opt ->
- Map.get(opt, "modifier_type", "fixed") == "fixed"
- end)
-
- Enum.reduce(fixed_specs, Decimal.new("0"), fn opt, acc ->
- selected_value = Map.get(selected_specs, opt["key"])
- modifier = get_price_modifier(opt, selected_value)
- Decimal.add(acc, modifier)
- end)
- end
-
- def calculate_total_modifier(_, _), do: Decimal.new("0")
-
- @doc """
- Gets the min/max price range for a list of options.
-
- For each option, finds the minimum and maximum modifier values,
- then calculates the final price range considering both fixed and percent modifiers.
-
- Returns `{min_price, max_price}` as Decimals.
-
- ## Examples
-
- specs = [
- %{"key" => "material", "modifier_type" => "fixed",
- "price_modifiers" => %{"PLA" => "0", "PETG" => "10.00"}},
- %{"key" => "finish", "modifier_type" => "percent",
- "price_modifiers" => %{"Standard" => "0", "Premium" => "20"}}
- ]
- base_price = Decimal.new("20.00")
-
- Options.get_price_range(specs, base_price)
- # => {Decimal.new("20.00"), Decimal.new("36.00")}
- """
- def get_price_range(specs, base_price, product_metadata \\ %{})
-
- def get_price_range(specs, base_price, product_metadata) when is_list(specs) do
- base = if is_nil(base_price), do: Decimal.new("0"), else: base_price
- metadata = product_metadata || %{}
-
- if Enum.empty?(specs) do
- {base, base}
- else
- # Separate by modifier type: fixed vs percent
- {fixed_specs, percent_specs} =
- Enum.split_with(specs, fn opt ->
- Map.get(opt, "modifier_type", "fixed") == "fixed"
- end)
-
- # Calculate min/max for fixed modifiers (considering overrides)
- {fixed_min, fixed_max} = get_effective_modifier_range(fixed_specs, metadata)
-
- # Calculate min/max for percent modifiers (considering overrides)
- {percent_min, percent_max} = get_effective_modifier_range(percent_specs, metadata)
-
- # Calculate min price: (base + fixed_min) * (1 + percent_min/100)
- min_intermediate = Decimal.add(base, fixed_min)
-
- min_price =
- if Decimal.compare(percent_min, Decimal.new("0")) == :gt do
- multiplier =
- Decimal.add(Decimal.new("1"), Decimal.div(percent_min, Decimal.new("100")))
-
- Decimal.mult(min_intermediate, multiplier) |> Decimal.round(2)
- else
- min_intermediate
- end
-
- # Calculate max price: (base + fixed_max) * (1 + percent_max/100)
- max_intermediate = Decimal.add(base, fixed_max)
-
- max_price =
- if Decimal.compare(percent_max, Decimal.new("0")) == :gt do
- multiplier =
- Decimal.add(Decimal.new("1"), Decimal.div(percent_max, Decimal.new("100")))
-
- Decimal.mult(max_intermediate, multiplier) |> Decimal.round(2)
- else
- max_intermediate
- end
-
- {min_price, max_price}
- end
- end
-
- def get_price_range(_, base_price, _) do
- base = if is_nil(base_price), do: Decimal.new("0"), else: base_price
- {base, base}
- end
-
- @doc """
- Gets the min/max modifier range for a list of options.
-
- Returns `{min_total, max_total}` as Decimals.
- """
- def get_modifier_range(specs) when is_list(specs) do
- Enum.reduce(specs, {Decimal.new("0"), Decimal.new("0")}, fn opt, {min_acc, max_acc} ->
- modifiers = opt["price_modifiers"] || %{}
- values = Map.values(modifiers) |> Enum.map(&parse_decimal/1)
-
- if Enum.empty?(values) do
- {min_acc, max_acc}
- else
- {
- Decimal.add(min_acc, Enum.min(values)),
- Decimal.add(max_acc, Enum.max(values))
- }
- end
- end)
- end
-
- def get_modifier_range(_), do: {Decimal.new("0"), Decimal.new("0")}
-
- @doc """
- Gets the min/max modifier range for options, considering product overrides.
-
- For options with `allow_override: true`, checks if product has override values
- in metadata and uses those instead of defaults.
-
- Returns `{min_total, max_total}` as Decimals.
- """
- def get_effective_modifier_range(specs, metadata) when is_list(specs) and is_map(metadata) do
- Enum.reduce(specs, {Decimal.new("0"), Decimal.new("0")}, fn opt, {min_acc, max_acc} ->
- option_key = opt["key"]
- allow_override = opt["allow_override"] == true
- default_modifiers = opt["price_modifiers"] || %{}
-
- # Get modifiers: check for overrides first, then fall back to defaults
- modifiers =
- if allow_override do
- case metadata do
- %{"_price_modifiers" => %{^option_key => mods}} when is_map(mods) ->
- # Merge: override values take precedence
- Map.merge(default_modifiers, mods)
-
- _ ->
- default_modifiers
- end
- else
- default_modifiers
- end
-
- values = Map.values(modifiers) |> Enum.map(&parse_decimal/1)
-
- if Enum.empty?(values) do
- {min_acc, max_acc}
- else
- {
- Decimal.add(min_acc, Enum.min(values)),
- Decimal.add(max_acc, Enum.max(values))
- }
- end
- end)
- end
-
- def get_effective_modifier_range(specs, _metadata) when is_list(specs) do
- get_modifier_range(specs)
- end
-
- def get_effective_modifier_range(_, _), do: {Decimal.new("0"), Decimal.new("0")}
-
- defp parse_decimal(value) when is_binary(value) do
- case Decimal.parse(value) do
- {decimal, ""} ->
- decimal
-
- _ ->
- require Logger
- Logger.warning("[Shop.Options] Invalid price modifier value: #{inspect(value)}")
- Decimal.new("0")
- end
- end
-
- defp parse_decimal(value) do
- require Logger
-
- if value not in [nil, ""] do
- Logger.warning("[Shop.Options] Unexpected price modifier type: #{inspect(value)}")
- end
-
- Decimal.new("0")
- end
-
- # ============================================
- # PRIVATE
- # ============================================
-
- defp repo, do: PhoenixKit.RepoHelper.repo()
-
- defp uuid_string?(string) when is_binary(string) do
- match?({:ok, _}, Ecto.UUID.cast(string))
- end
-end
diff --git a/lib/modules/shop/schemas/cart.ex b/lib/modules/shop/schemas/cart.ex
deleted file mode 100644
index b77b0de44..000000000
--- a/lib/modules/shop/schemas/cart.ex
+++ /dev/null
@@ -1,248 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Cart do
- @moduledoc """
- Shopping cart schema with support for guest and authenticated users.
-
- ## Status Lifecycle
-
- - `active` - Cart is active and can be modified
- - `merged` - Guest cart was merged into user cart after login
- - `converted` - Cart was converted to an order
- - `abandoned` - Cart was marked as abandoned (no activity)
- - `expired` - Cart expired (past expires_at)
-
- ## Identity
-
- Each cart has either `user_uuid` (for authenticated users) or `session_id` (for guests).
- Guest carts have an `expires_at` timestamp (30 days by default).
- When a guest logs in, their cart is either converted to a user cart or merged
- with an existing user cart.
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- alias PhoenixKit.Modules.Billing.PaymentOption
- alias PhoenixKit.Modules.Shop.CartItem
- alias PhoenixKit.Modules.Shop.ShippingMethod
- alias PhoenixKit.Users.Auth.User
- alias PhoenixKit.Utils.Date, as: UtilsDate
-
- @statuses ~w(active merged converted abandoned expired)
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_carts" do
- # Identity
- belongs_to :user, User, foreign_key: :user_uuid, references: :uuid, type: UUIDv7
- field :session_id, :string
-
- # Status
- field :status, :string, default: "active"
-
- # Shipping
- belongs_to :shipping_method, ShippingMethod,
- foreign_key: :shipping_method_uuid,
- references: :uuid,
- type: UUIDv7
-
- field :shipping_country, :string
-
- # Payment
- belongs_to :payment_option, PaymentOption,
- foreign_key: :payment_option_uuid,
- references: :uuid,
- type: UUIDv7
-
- # Totals (cached)
- field :subtotal, :decimal, default: Decimal.new("0")
- field :shipping_amount, :decimal, default: Decimal.new("0")
- field :tax_amount, :decimal, default: Decimal.new("0")
- field :discount_amount, :decimal, default: Decimal.new("0")
- field :total, :decimal, default: Decimal.new("0")
- field :currency, :string, default: "USD"
-
- # Discount
- field :discount_code, :string
-
- # Calculated
- field :total_weight_grams, :integer, default: 0
- field :items_count, :integer, default: 0
-
- # Metadata
- field :metadata, :map, default: %{}
-
- # Tracking
- field :expires_at, :utc_datetime
- field :converted_at, :utc_datetime
- field :merged_into_cart_uuid, UUIDv7
-
- has_many :items, CartItem, foreign_key: :cart_uuid, references: :uuid
-
- timestamps(type: :utc_datetime)
- end
-
- @doc """
- Changeset for cart creation and updates.
- """
- def changeset(cart, attrs) do
- cart
- |> cast(attrs, [
- :user_uuid,
- :session_id,
- :status,
- :shipping_method_uuid,
- :shipping_country,
- :payment_option_uuid,
- :subtotal,
- :shipping_amount,
- :tax_amount,
- :discount_amount,
- :total,
- :currency,
- :discount_code,
- :total_weight_grams,
- :items_count,
- :metadata,
- :expires_at,
- :converted_at,
- :merged_into_cart_uuid
- ])
- |> validate_inclusion(:status, @statuses)
- |> validate_length(:currency, is: 3)
- |> validate_length(:shipping_country, max: 2)
- |> validate_identity()
- |> maybe_set_expires_at()
- end
-
- @doc """
- Changeset for updating cart totals.
- """
- def totals_changeset(cart, attrs) do
- cart
- |> cast(attrs, [
- :subtotal,
- :shipping_amount,
- :tax_amount,
- :discount_amount,
- :total,
- :total_weight_grams,
- :items_count
- ])
- end
-
- @doc """
- Changeset for setting shipping.
- """
- def shipping_changeset(cart, attrs) do
- cart
- |> cast(attrs, [
- :shipping_method_uuid,
- :shipping_country,
- :shipping_amount
- ])
- end
-
- @doc """
- Changeset for setting payment option.
- """
- def payment_changeset(cart, attrs) do
- cart
- |> cast(attrs, [:payment_option_uuid])
- end
-
- @doc """
- Changeset for status transitions.
- """
- def status_changeset(cart, new_status, extra_attrs \\ %{}) do
- attrs = Map.merge(%{status: new_status}, extra_attrs)
-
- cart
- |> cast(attrs, [:status, :converted_at, :merged_into_cart_uuid])
- |> validate_status_transition(cart.status, new_status)
- end
-
- @doc """
- Returns true if cart is active.
- """
- def active?(%__MODULE__{status: "active"}), do: true
- def active?(_), do: false
-
- @doc """
- Returns true if cart is a guest cart (no user_uuid).
- """
- def guest?(%__MODULE__{user_uuid: nil}), do: true
- def guest?(_), do: false
-
- @doc """
- Returns true if cart is empty.
- """
- def empty?(%__MODULE__{items_count: 0}), do: true
- def empty?(%__MODULE__{items_count: nil}), do: true
- def empty?(_), do: false
-
- @doc """
- Returns true if cart can be converted to order.
- """
- def convertible?(%__MODULE__{status: "active", items_count: count}) when count > 0, do: true
- def convertible?(_), do: false
-
- @doc """
- Returns true if cart has expired.
- """
- def expired?(%__MODULE__{expires_at: nil}), do: false
-
- def expired?(%__MODULE__{expires_at: expires_at}) do
- DateTime.compare(UtilsDate.utc_now(), expires_at) == :gt
- end
-
- @doc """
- Returns list of valid status values.
- """
- def statuses, do: @statuses
-
- # Private helpers
-
- defp validate_identity(changeset) do
- user_uuid = get_field(changeset, :user_uuid)
- session_id = get_field(changeset, :session_id)
-
- if is_nil(user_uuid) and is_nil(session_id) do
- add_error(changeset, :base, "Either user_uuid or session_id must be set")
- else
- changeset
- end
- end
-
- defp validate_status_transition(changeset, from, to) do
- valid_transitions = %{
- "active" => ~w(converting merged converted abandoned expired),
- "converting" => ~w(converted active),
- "merged" => [],
- "converted" => [],
- "abandoned" => ~w(active),
- "expired" => []
- }
-
- allowed = Map.get(valid_transitions, from, [])
-
- if to in allowed or from == to do
- changeset
- else
- add_error(changeset, :status, "cannot transition from #{from} to #{to}")
- end
- end
-
- defp maybe_set_expires_at(changeset) do
- user_uuid = get_field(changeset, :user_uuid)
- session_id = get_field(changeset, :session_id)
- expires_at = get_field(changeset, :expires_at)
-
- # Guest carts expire in 30 days
- if is_nil(user_uuid) and not is_nil(session_id) and is_nil(expires_at) do
- expires = UtilsDate.utc_now() |> DateTime.add(30, :day) |> DateTime.truncate(:second)
- put_change(changeset, :expires_at, expires)
- else
- changeset
- end
- end
-end
diff --git a/lib/modules/shop/schemas/cart_item.ex b/lib/modules/shop/schemas/cart_item.ex
deleted file mode 100644
index 03d6560cd..000000000
--- a/lib/modules/shop/schemas/cart_item.ex
+++ /dev/null
@@ -1,234 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.CartItem do
- @moduledoc """
- Cart item schema with price snapshot for consistency.
-
- When a product is added to the cart, we snapshot the current price and product
- details. This ensures that:
-
- 1. Price changes after adding don't affect the cart total unexpectedly
- 2. If the product is deleted, we still have the title and other info
- 3. We can show users when prices have changed since they added items
-
- ## Fields
-
- - `cart_uuid` - Reference to the cart (required)
- - `product_uuid` - Reference to the product (nullable, ON DELETE SET NULL)
- - `product_title` - Product title snapshot (required)
- - `product_slug` - Product slug snapshot
- - `product_sku` - Product SKU snapshot
- - `product_image` - Product image URL snapshot
- - `unit_price` - Price per unit at time of adding (required)
- - `compare_at_price` - Original price for showing discounts
- - `quantity` - Number of items (required, > 0)
- - `line_total` - Calculated: unit_price * quantity
- - `weight_grams` - Weight for shipping calculation
- - `taxable` - Whether item is taxable
- - `selected_specs` - JSON object for specification-based pricing (e.g., {"material": "PETG", "color": "Gold"})
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- alias PhoenixKit.Modules.Shop.Cart
- alias PhoenixKit.Modules.Shop.Product
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_cart_items" do
- belongs_to :cart, Cart, foreign_key: :cart_uuid, references: :uuid, type: UUIDv7
- belongs_to :product, Product, foreign_key: :product_uuid, references: :uuid, type: UUIDv7
- field :variant_uuid, UUIDv7
-
- # Snapshot
- field :product_title, :string
- field :product_slug, :string
- field :product_sku, :string
- field :product_image, :string
-
- # Pricing (snapshot)
- field :unit_price, :decimal
- field :compare_at_price, :decimal
- field :currency, :string, default: "USD"
-
- # Quantity
- field :quantity, :integer, default: 1
-
- # Calculated
- field :line_total, :decimal
-
- # Physical
- field :weight_grams, :integer, default: 0
- field :taxable, :boolean, default: true
-
- # Specification-based pricing
- field :selected_specs, :map, default: %{}
-
- field :metadata, :map, default: %{}
-
- timestamps(type: :utc_datetime)
- end
-
- @doc """
- Changeset for cart item creation and updates.
- """
- def changeset(item, attrs) do
- item
- |> cast(attrs, [
- :cart_uuid,
- :product_uuid,
- :variant_uuid,
- :product_title,
- :product_slug,
- :product_sku,
- :product_image,
- :unit_price,
- :compare_at_price,
- :currency,
- :quantity,
- :line_total,
- :weight_grams,
- :taxable,
- :selected_specs,
- :metadata
- ])
- |> validate_required([:cart_uuid, :product_title, :unit_price, :quantity])
- |> validate_number(:quantity, greater_than: 0)
- |> validate_number(:unit_price, greater_than_or_equal_to: 0)
- |> validate_length(:currency, is: 3)
- |> calculate_line_total()
- |> foreign_key_constraint(:cart_uuid)
- |> foreign_key_constraint(:product_uuid)
- end
-
- @doc """
- Creates changeset attributes from a product.
-
- ## Parameters
-
- - `product` - The Product struct
- - `quantity` - Number of items (default: 1)
- - `language` - Language code for localized fields (default: system default)
-
- ## Examples
-
- iex> from_product(product, 2)
- %{
- product_uuid: "01234567-...",
- product_title: "Widget",
- product_slug: "widget",
- unit_price: Decimal.new("19.99"),
- quantity: 2,
- ...
- }
-
- iex> from_product(product, 1, "ru")
- %{product_title: "Виджет", product_slug: "vidzhet", ...}
- """
- def from_product(%Product{} = product, quantity \\ 1, language \\ nil) do
- lang = language || default_language()
-
- %{
- product_uuid: product.uuid,
- product_title: get_localized_string(product.title, lang),
- product_slug: get_localized_string(product.slug, lang),
- product_image: get_product_image_url(product),
- unit_price: product.price,
- compare_at_price: product.compare_at_price,
- currency: product.currency,
- quantity: quantity,
- weight_grams: product.weight_grams || 0,
- taxable: product.taxable
- }
- end
-
- # Get product image URL, preferring new Storage system over legacy
- defp get_product_image_url(%Product{featured_image_uuid: id}) when is_binary(id) do
- alias PhoenixKit.Modules.Storage.URLSigner
-
- try do
- URLSigner.signed_url(id, "medium")
- rescue
- _ -> nil
- end
- end
-
- defp get_product_image_url(%Product{featured_image: url}) when is_binary(url), do: url
- defp get_product_image_url(_), do: nil
-
- # Extract string from localized JSONB map field
- defp get_localized_string(nil, _lang), do: nil
- defp get_localized_string(value, _lang) when is_binary(value), do: value
-
- defp get_localized_string(map, lang) when is_map(map) do
- map[lang] || map[default_language()] || first_value(map)
- end
-
- defp get_localized_string(_value, _lang), do: nil
-
- defp first_value(map) when map == %{}, do: nil
- defp first_value(map), do: map |> Map.values() |> List.first()
-
- defp default_language do
- alias PhoenixKit.Modules.Shop.Translations
- Translations.default_language()
- end
-
- @doc """
- Returns true if product data has changed since the item was added.
- Useful for showing price change warnings.
- """
- def product_changed?(%__MODULE__{product_uuid: nil}, _product), do: true
-
- def product_changed?(%__MODULE__{} = item, %Product{} = product) do
- Decimal.compare(item.unit_price, product.price) != :eq
- end
-
- @doc """
- Returns the price difference if the product price has changed.
- Positive = price increased, Negative = price decreased.
- """
- def price_difference(%__MODULE__{} = item, %Product{} = product) do
- Decimal.sub(product.price, item.unit_price)
- end
-
- @doc """
- Returns true if this item is on sale (has compare_at_price > unit_price).
- """
- def on_sale?(%__MODULE__{compare_at_price: nil}), do: false
-
- def on_sale?(%__MODULE__{compare_at_price: compare, unit_price: price}) do
- Decimal.compare(compare, price) == :gt
- end
-
- @doc """
- Returns discount percentage for sale items.
- """
- def discount_percentage(%__MODULE__{} = item) do
- if on_sale?(item) do
- diff = Decimal.sub(item.compare_at_price, item.unit_price)
-
- diff
- |> Decimal.div(item.compare_at_price)
- |> Decimal.mult(100)
- |> Decimal.round(0)
- |> Decimal.to_integer()
- else
- 0
- end
- end
-
- @doc """
- Returns true if the product has been deleted (product_uuid is nil after SET NULL).
- """
- def product_deleted?(%__MODULE__{product_uuid: nil}), do: true
- def product_deleted?(_), do: false
-
- # Private helpers
-
- defp calculate_line_total(changeset) do
- quantity = get_field(changeset, :quantity) || 1
- unit_price = get_field(changeset, :unit_price) || Decimal.new("0")
- line_total = Decimal.mult(unit_price, quantity)
- put_change(changeset, :line_total, line_total)
- end
-end
diff --git a/lib/modules/shop/schemas/category.ex b/lib/modules/shop/schemas/category.ex
deleted file mode 100644
index 10f754fbd..000000000
--- a/lib/modules/shop/schemas/category.ex
+++ /dev/null
@@ -1,358 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Category do
- @moduledoc """
- Category schema for product organization.
-
- Supports hierarchical nesting via parent_uuid.
-
- ## Fields
-
- - `name` - Category name (required)
- - `slug` - URL-friendly identifier (unique)
- - `description` - Category description
- - `featured_product_uuid` - Featured product for fallback image
- - `parent_uuid` - Parent category for nesting
- - `position` - Sort order
- - `status` - Category status: "active", "hidden", "archived"
- - `metadata` - JSONB for custom fields
- - `option_schema` - Category-specific product option definitions (JSONB array)
-
- ## Status Values
-
- - `active` - Category and products visible in storefront
- - `unlisted` - Category hidden from menu, but products still visible
- - `hidden` - Category and all products hidden from storefront
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- alias PhoenixKit.Modules.Storage.URLSigner
-
- @type t :: %__MODULE__{}
-
- @statuses ~w(active unlisted hidden)
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_categories" do
- # Localized fields (JSONB maps: %{"en" => "value", "ru" => "значение"})
- field :name, :map, default: %{}
- field :slug, :map, default: %{}
- field :description, :map, default: %{}
-
- # Non-localized fields
- field :image_uuid, Ecto.UUID
- field :position, :integer, default: 0
- field :status, :string, default: "active"
- field :metadata, :map, default: %{}
- field :option_schema, {:array, :map}, default: []
-
- # Self-referential for nesting
- belongs_to :parent, __MODULE__, foreign_key: :parent_uuid, references: :uuid, type: UUIDv7
- has_many :children, __MODULE__, foreign_key: :parent_uuid, references: :uuid
-
- # Products in this category
- has_many :products, PhoenixKit.Modules.Shop.Product,
- foreign_key: :category_uuid,
- references: :uuid
-
- # Featured product for fallback image
- belongs_to :featured_product, PhoenixKit.Modules.Shop.Product,
- foreign_key: :featured_product_uuid,
- references: :uuid,
- type: UUIDv7
-
- timestamps(type: :utc_datetime)
- end
-
- @doc "Returns list of valid category statuses"
- def statuses, do: @statuses
-
- @localized_fields [:name, :slug, :description]
-
- @doc """
- Changeset for category creation and updates.
- """
- def changeset(category, attrs) do
- category
- |> cast(attrs, [
- :name,
- :slug,
- :description,
- :image_uuid,
- :featured_product_uuid,
- :parent_uuid,
- :position,
- :status,
- :metadata,
- :option_schema
- ])
- |> normalize_map_fields(@localized_fields)
- |> validate_localized_required(:name)
- |> validate_number(:position, greater_than_or_equal_to: 0)
- |> validate_inclusion(:status, @statuses)
- |> maybe_generate_slug()
- |> validate_no_circular_parent()
- |> unique_constraint(:slug, name: "idx_shop_categories_slug_primary")
- end
-
- @doc """
- Returns the list of localized field names.
- """
- def localized_fields, do: @localized_fields
-
- @doc """
- Returns the image URL for a category.
-
- Priority:
- 1. Storage media (image_uuid) if available
- 2. Featured product's featured_image_uuid (requires :featured_product preloaded)
- 3. Featured product's legacy featured_image URL (requires :featured_product preloaded)
- 4. nil if no image
-
- ## Options
- - `:size` - Storage dimension to use (default: "large")
- """
- def get_image_url(category, opts \\ [])
-
- # Priority 1: direct Storage image
- def get_image_url(%__MODULE__{image_uuid: image_uuid}, opts)
- when is_binary(image_uuid) and image_uuid != "" do
- size = Keyword.get(opts, :size, "large")
- URLSigner.signed_url(image_uuid, size)
- end
-
- # Priority 2: featured product's Storage image (preloaded)
- def get_image_url(
- %__MODULE__{featured_product: %{featured_image_uuid: fid}},
- opts
- )
- when is_binary(fid) and fid != "" do
- size = Keyword.get(opts, :size, "large")
- URLSigner.signed_url(fid, size)
- end
-
- # Priority 3: featured product's legacy image URL (preloaded)
- def get_image_url(
- %__MODULE__{featured_product: %{featured_image: url}},
- _opts
- )
- when is_binary(url) and url != "" do
- url
- end
-
- # No image available
- def get_image_url(_category, _opts), do: nil
-
- @doc """
- Returns true if category is a root category (no parent).
- """
- def root?(%__MODULE__{parent_uuid: nil}), do: true
- def root?(%__MODULE__{}), do: false
-
- @doc """
- Returns true if category has children.
- """
- def has_children?(%__MODULE__{children: children}) when is_list(children) do
- children != []
- end
-
- def has_children?(_), do: false
-
- @doc """
- Returns true if category is active (visible in storefront).
- """
- def active?(%__MODULE__{status: "active"}), do: true
- def active?(_), do: false
-
- @doc """
- Returns true if category is unlisted (not in menu, but products visible).
- """
- def unlisted?(%__MODULE__{status: "unlisted"}), do: true
- def unlisted?(_), do: false
-
- @doc """
- Returns true if category is hidden (category and products not visible).
- """
- def hidden?(%__MODULE__{status: "hidden"}), do: true
- def hidden?(_), do: false
-
- @doc """
- Returns true if products in this category should be visible in storefront.
- Products are visible when category is active or unlisted.
- """
- def products_visible?(%__MODULE__{status: status}) when status in ["active", "unlisted"],
- do: true
-
- def products_visible?(_), do: false
-
- @doc """
- Returns true if category should appear in category menu/list.
- Only active categories appear in the menu.
- """
- def show_in_menu?(%__MODULE__{status: "active"}), do: true
- def show_in_menu?(_), do: false
-
- @doc """
- Returns the full path of category names from root to this category.
- Requires parent to be preloaded.
-
- ## Parameters
-
- - `category` - Category struct with parent preloaded
- - `language` - Language code for localized names (default: system default)
-
- ## Examples
-
- iex> breadcrumb_path(category, "en")
- ["Home", "Electronics", "Phones"]
- """
- def breadcrumb_path(category, language \\ nil)
-
- def breadcrumb_path(%__MODULE__{parent: nil} = category, language) do
- [get_localized_name(category, language)]
- end
-
- def breadcrumb_path(%__MODULE__{parent: %__MODULE__{} = parent} = category, language) do
- breadcrumb_path(parent, language) ++ [get_localized_name(category, language)]
- end
-
- def breadcrumb_path(%__MODULE__{} = category, language) do
- [get_localized_name(category, language)]
- end
-
- # Extract localized name from JSONB map
- defp get_localized_name(%__MODULE__{name: name}, language) do
- lang = language || default_language()
-
- case name do
- nil -> nil
- map when is_map(map) -> map[lang] || first_value(map)
- value when is_binary(value) -> value
- _ -> nil
- end
- end
-
- defp first_value(map) when map == %{}, do: nil
- defp first_value(map), do: map |> Map.values() |> List.first()
-
- defp default_language do
- alias PhoenixKit.Modules.Shop.Translations
- Translations.default_language()
- end
-
- # Remove empty string values from map fields
- defp normalize_map_fields(changeset, fields) do
- Enum.reduce(fields, changeset, fn field, acc ->
- case get_change(acc, field) do
- nil ->
- acc
-
- map when is_map(map) ->
- cleaned =
- map
- |> Enum.reject(fn {_k, v} -> v in [nil, ""] end)
- |> Map.new()
-
- put_change(acc, field, cleaned)
-
- _ ->
- acc
- end
- end)
- end
-
- # Validate that localized field has value for default language
- defp validate_localized_required(changeset, field) do
- value = get_field(changeset, field) || %{}
- default_lang = default_language()
-
- if Map.get(value, default_lang) in [nil, ""] do
- add_error(changeset, field, "#{default_lang} translation is required")
- else
- changeset
- end
- end
-
- # Generate slug from name for each language
- defp maybe_generate_slug(changeset) do
- name_map = get_field(changeset, :name) || %{}
- slug_map = get_field(changeset, :slug) || %{}
-
- # For each language with a name but no slug, generate one
- updated_slugs =
- Enum.reduce(name_map, slug_map, fn {lang, name}, acc ->
- if Map.get(acc, lang) in [nil, ""] and name not in [nil, ""] do
- generated = slugify(name)
- Map.put(acc, lang, generated)
- else
- acc
- end
- end)
-
- if updated_slugs != slug_map do
- put_change(changeset, :slug, updated_slugs)
- else
- changeset
- end
- end
-
- # Prevent category from being its own parent or creating circular references
- defp validate_no_circular_parent(changeset) do
- parent_uuid = get_change(changeset, :parent_uuid)
- category_uuid = changeset.data.uuid
-
- cond do
- is_nil(parent_uuid) ->
- changeset
-
- parent_uuid == category_uuid ->
- add_error(changeset, :parent_uuid, "cannot be self")
-
- true ->
- check_ancestor_cycle(changeset, category_uuid, parent_uuid)
- end
- end
-
- defp check_ancestor_cycle(changeset, target_uuid, current_uuid) do
- check_ancestor_cycle(changeset, target_uuid, current_uuid, %{})
- end
-
- defp check_ancestor_cycle(changeset, target_uuid, current_uuid, visited) do
- if Map.has_key?(visited, current_uuid) do
- changeset
- else
- repo = PhoenixKit.RepoHelper.repo()
-
- case repo.get_by(__MODULE__, uuid: current_uuid) do
- nil ->
- changeset
-
- %{parent_uuid: nil} ->
- changeset
-
- %{parent_uuid: ^target_uuid} ->
- add_error(changeset, :parent_uuid, "would create a circular reference")
-
- %{parent_uuid: next_uuid} ->
- check_ancestor_cycle(
- changeset,
- target_uuid,
- next_uuid,
- Map.put(visited, current_uuid, true)
- )
- end
- end
- end
-
- defp slugify(text) when is_binary(text) do
- text
- |> String.downcase()
- |> String.replace(~r/[^\w\s-]/, "")
- |> String.replace(~r/\s+/, "-")
- |> String.replace(~r/-+/, "-")
- |> String.trim("-")
- end
-
- defp slugify(_), do: ""
-end
diff --git a/lib/modules/shop/schemas/import_config.ex b/lib/modules/shop/schemas/import_config.ex
deleted file mode 100644
index c50b1068f..000000000
--- a/lib/modules/shop/schemas/import_config.ex
+++ /dev/null
@@ -1,236 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.ImportConfig do
- @moduledoc """
- ImportConfig schema for configurable CSV import filtering.
-
- Allows defining custom filtering rules per import type instead of
- using hardcoded keywords.
-
- ## Fields
-
- - `name` - Config name (e.g., "decor_3d", "general")
- - `include_keywords` - Keywords that must be present for inclusion
- - `exclude_keywords` - Keywords that cause exclusion
- - `exclude_phrases` - Phrases that cause exclusion
- - `skip_filter` - If true, skip all filtering (import everything)
- - `category_rules` - List of maps: `[%{keywords: [...], slug: "category-slug"}]`
- - `default_category_slug` - Fallback category when no rules match
- - `required_columns` - CSV columns that must be present
- - `is_default` - Use this config when none specified
- - `active` - Config is available for use
- - `option_mappings` - Mappings from CSV option columns to global options
-
- ## Example Category Rules
-
- [
- %{"keywords" => ["shelf"], "slug" => "shelves"},
- %{"keywords" => ["mask"], "slug" => "masks"},
- %{"keywords" => ["vase", "planter"], "slug" => "vases-planters"}
- ]
-
- ## Example Option Mappings
-
- [
- %{
- "csv_name" => "Cup Color",
- "slot_key" => "cup_color",
- "source_key" => "color",
- "auto_add" => true,
- "label" => %{"en" => "Cup Color", "ru" => "Цвет чашки"}
- },
- %{
- "csv_name" => "Liquid Color",
- "slot_key" => "liquid_color",
- "source_key" => "color",
- "auto_add" => true
- }
- ]
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- @type t :: %__MODULE__{}
-
- @default_required_columns ["Handle", "Title", "Variant Price"]
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_import_configs" do
- field :name, :string
-
- # Filtering keywords (PostgreSQL TEXT[] arrays)
- field :include_keywords, {:array, :string}, default: []
- field :exclude_keywords, {:array, :string}, default: []
- field :exclude_phrases, {:array, :string}, default: []
- field :skip_filter, :boolean, default: false
-
- # Category assignment rules (JSONB)
- field :category_rules, {:array, :map}, default: []
- field :default_category_slug, :string
-
- # CSV validation
- field :required_columns, {:array, :string}, default: @default_required_columns
-
- # Status flags
- field :is_default, :boolean, default: false
- field :active, :boolean, default: true
-
- # Image migration options
- field :download_images, :boolean, default: false
-
- # Option mappings for CSV import (JSONB)
- field :option_mappings, {:array, :map}, default: []
-
- timestamps(type: :utc_datetime)
- end
-
- @doc """
- Changeset for creating/updating an import config.
- """
- def changeset(config \\ %__MODULE__{}, attrs) do
- config
- |> cast(attrs, [
- :name,
- :include_keywords,
- :exclude_keywords,
- :exclude_phrases,
- :skip_filter,
- :category_rules,
- :default_category_slug,
- :required_columns,
- :is_default,
- :active,
- :download_images,
- :option_mappings
- ])
- |> validate_required([:name])
- |> unique_constraint(:name)
- |> unique_constraint(:uuid)
- |> validate_category_rules()
- |> validate_option_mappings()
- end
-
- defp validate_category_rules(changeset) do
- case get_field(changeset, :category_rules) do
- nil ->
- changeset
-
- rules when is_list(rules) ->
- if Enum.all?(rules, &valid_category_rule?/1) do
- changeset
- else
- add_error(
- changeset,
- :category_rules,
- "each rule must have 'keywords' (list) and 'slug' (string)"
- )
- end
-
- _ ->
- add_error(changeset, :category_rules, "must be a list of rule objects")
- end
- end
-
- defp valid_category_rule?(rule) when is_map(rule) do
- keywords = rule["keywords"] || rule[:keywords]
- slug = rule["slug"] || rule[:slug]
-
- is_list(keywords) and is_binary(slug) and slug != ""
- end
-
- defp valid_category_rule?(_), do: false
-
- defp validate_option_mappings(changeset) do
- case get_field(changeset, :option_mappings) do
- nil ->
- changeset
-
- mappings when is_list(mappings) ->
- if Enum.all?(mappings, &valid_option_mapping?/1) do
- changeset
- else
- add_error(
- changeset,
- :option_mappings,
- "each mapping must have 'csv_name' (string) and 'slot_key' (string)"
- )
- end
-
- _ ->
- add_error(changeset, :option_mappings, "must be a list of mapping objects")
- end
- end
-
- defp valid_option_mapping?(mapping) when is_map(mapping) do
- csv_name = mapping["csv_name"] || mapping[:csv_name]
- slot_key = mapping["slot_key"] || mapping[:slot_key]
-
- is_binary(csv_name) and csv_name != "" and
- is_binary(slot_key) and slot_key != ""
- end
-
- defp valid_option_mapping?(_), do: false
-
- @doc """
- Returns default required columns for CSV validation.
- """
- def default_required_columns, do: @default_required_columns
-
- @doc """
- Builds a config struct from legacy hardcoded values (for backward compatibility).
- """
- def from_legacy_defaults do
- %__MODULE__{
- name: "legacy_default",
- include_keywords:
- ~w(3d printed shelf mask vase planter holder stand lamp light figurine sculpture statue),
- exclude_keywords: ~w(decal sticker mural wallpaper poster tapestry canvas),
- exclude_phrases: ["wall art"],
- skip_filter: false,
- category_rules: [
- %{"keywords" => ["shelf"], "slug" => "shelves"},
- %{"keywords" => ["mask"], "slug" => "masks"},
- %{"keywords" => ["vase", "planter"], "slug" => "vases-planters"},
- %{"keywords" => ["holder", "stand"], "slug" => "holders-stands"},
- %{"keywords" => ["lamp", "light"], "slug" => "lamps"},
- %{"keywords" => ["figurine", "sculpture", "statue"], "slug" => "figurines"}
- ],
- default_category_slug: "other-3d",
- required_columns: @default_required_columns,
- is_default: true,
- active: true
- }
- end
-
- @doc """
- Builds a default config for Prom.ua imports (no filtering, import everything).
- """
- def from_prom_ua_defaults do
- %__MODULE__{
- name: "prom_ua_default",
- skip_filter: true,
- category_rules: [],
- required_columns: ["Назва_позиції", "Ціна"],
- is_default: false,
- active: true,
- download_images: true,
- include_keywords: [],
- exclude_keywords: [],
- exclude_phrases: []
- }
- end
-
- @doc """
- Builds a "no filter" config that imports everything.
- """
- def no_filter_config do
- %__MODULE__{
- name: "no_filter",
- skip_filter: true,
- category_rules: [],
- required_columns: @default_required_columns,
- is_default: false,
- active: true
- }
- end
-end
diff --git a/lib/modules/shop/schemas/import_log.ex b/lib/modules/shop/schemas/import_log.ex
deleted file mode 100644
index e5b93a61a..000000000
--- a/lib/modules/shop/schemas/import_log.ex
+++ /dev/null
@@ -1,170 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.ImportLog do
- @moduledoc """
- ImportLog schema for tracking CSV import history.
-
- ## Fields
-
- - `filename` - Original filename (required)
- - `file_path` - Server path to uploaded file
- - `status` - pending | processing | completed | failed
- - `total_rows` - Total rows in CSV
- - `processed_rows` - Rows processed so far
- - `imported_count` - New products created
- - `updated_count` - Existing products updated
- - `skipped_count` - Products skipped (filtered)
- - `error_count` - Products with errors
- - `options` - Import options (JSONB)
- - `error_details` - List of error objects
- - `started_at` - Processing start time
- - `completed_at` - Processing end time
- - `user_uuid` - User who initiated import
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- alias PhoenixKit.Users.Auth.User
- alias PhoenixKit.Utils.Date, as: UtilsDate
-
- @statuses ["pending", "processing", "completed", "failed"]
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_import_logs" do
- field :filename, :string
- field :file_path, :string
- field :status, :string, default: "pending"
-
- # Statistics
- field :total_rows, :integer, default: 0
- field :processed_rows, :integer, default: 0
- field :imported_count, :integer, default: 0
- field :updated_count, :integer, default: 0
- field :skipped_count, :integer, default: 0
- field :error_count, :integer, default: 0
-
- # Metadata
- field :options, :map, default: %{}
- field :error_details, {:array, :map}, default: []
- field :product_uuids, {:array, Ecto.UUID}, default: []
-
- # Timing
- field :started_at, :utc_datetime
- field :completed_at, :utc_datetime
-
- # Associations
- belongs_to :user, User, foreign_key: :user_uuid, references: :uuid, type: UUIDv7
-
- timestamps(type: :utc_datetime)
- end
-
- @doc """
- Changeset for creating a new import log.
- """
- def create_changeset(import_log \\ %__MODULE__{}, attrs) do
- import_log
- |> cast(attrs, [:filename, :file_path, :options, :user_uuid])
- |> validate_required([:filename])
- end
-
- @doc """
- Changeset for updating import log status and stats.
- """
- def update_changeset(import_log, attrs) do
- import_log
- |> cast(attrs, [
- :status,
- :total_rows,
- :processed_rows,
- :imported_count,
- :updated_count,
- :skipped_count,
- :error_count,
- :error_details,
- :started_at,
- :completed_at
- ])
- |> validate_inclusion(:status, @statuses)
- end
-
- @doc """
- Mark import as started.
- """
- def start_changeset(import_log, total_rows) do
- import_log
- |> change(%{
- status: "processing",
- total_rows: total_rows,
- started_at: UtilsDate.utc_now()
- })
- end
-
- @doc """
- Update progress during import.
- """
- def progress_changeset(import_log, attrs) do
- import_log
- |> cast(attrs, [
- :processed_rows,
- :imported_count,
- :updated_count,
- :skipped_count,
- :error_count
- ])
- end
-
- @doc """
- Mark import as completed.
- """
- def complete_changeset(import_log, stats) do
- import_log
- |> cast(stats, [
- :imported_count,
- :updated_count,
- :skipped_count,
- :error_count,
- :error_details,
- :product_uuids
- ])
- |> change(%{
- status: "completed",
- processed_rows: import_log.total_rows,
- completed_at: UtilsDate.utc_now()
- })
- end
-
- @doc """
- Mark import as failed.
- """
- def fail_changeset(import_log, error) do
- error_details = [%{"error" => inspect(error), "timestamp" => UtilsDate.utc_now()}]
-
- import_log
- |> change(%{
- status: "failed",
- error_details: error_details,
- completed_at: UtilsDate.utc_now()
- })
- end
-
- @doc """
- Returns the percentage of completion.
- """
- def progress_percent(%__MODULE__{total_rows: 0}), do: 0
-
- def progress_percent(%__MODULE__{processed_rows: processed, total_rows: total}) do
- trunc(processed / total * 100)
- end
-
- @doc """
- Check if import is in progress.
- """
- def in_progress?(%__MODULE__{status: "processing"}), do: true
- def in_progress?(_), do: false
-
- @doc """
- Check if import is finished (completed or failed).
- """
- def finished?(%__MODULE__{status: status}) when status in ["completed", "failed"], do: true
- def finished?(_), do: false
-end
diff --git a/lib/modules/shop/schemas/product.ex b/lib/modules/shop/schemas/product.ex
deleted file mode 100644
index d16b9995e..000000000
--- a/lib/modules/shop/schemas/product.ex
+++ /dev/null
@@ -1,297 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Product do
- @moduledoc """
- Product schema for e-commerce shop.
-
- Supports both physical and digital products with JSONB flexibility.
-
- ## Fields
-
- - `title` - Product title (required)
- - `slug` - URL-friendly identifier (unique)
- - `description` - Short description
- - `body_html` - Full rich text description
- - `status` - draft | active | archived
- - `product_type` - physical | digital
- - `vendor` - Brand/manufacturer
- - `tags` - JSONB array of tags
- - `price` - Base price (required)
- - `compare_at_price` - Original price for discounts
- - `cost_per_item` - Cost for profit calculation
- - `currency` - ISO currency code (default: USD)
- - `taxable` - Subject to tax
- - `weight_grams` - Weight for shipping
- - `requires_shipping` - Needs physical delivery
- - `made_to_order` - Always available regardless of inventory
- - `images` - JSONB array of image objects
- - `featured_image` - Main image URL
- - `seo_title` - SEO title
- - `seo_description` - SEO description
- - `file_uuid` - Storage file reference (digital products)
- - `download_limit` - Max downloads (digital)
- - `download_expiry_days` - Days until download expires
- - `metadata` - JSONB for custom fields
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- @type t :: %__MODULE__{}
-
- @statuses ["draft", "active", "archived"]
- @product_types ["physical", "digital"]
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_products" do
- # Localized fields (JSONB maps: %{"en" => "value", "ru" => "значение"})
- field :title, :map, default: %{}
- field :slug, :map, default: %{}
- field :description, :map, default: %{}
- field :body_html, :map, default: %{}
-
- # Status (non-localized)
- field :status, :string, default: "draft"
-
- # Type
- field :product_type, :string, default: "physical"
- field :vendor, :string
- field :tags, {:array, :string}, default: []
-
- # Pricing
- field :price, :decimal
- field :compare_at_price, :decimal
- field :cost_per_item, :decimal
- field :currency, :string, default: "USD"
- field :taxable, :boolean, default: true
-
- # Physical properties
- field :weight_grams, :integer, default: 0
- field :requires_shipping, :boolean, default: true
-
- # Availability
- field :made_to_order, :boolean, default: false
-
- # Media (legacy URL-based)
- field :images, {:array, :map}, default: []
- field :featured_image, :string
-
- # Media (Storage integration)
- field :featured_image_uuid, Ecto.UUID
- field :image_uuids, {:array, Ecto.UUID}, default: []
-
- # SEO (localized JSONB maps)
- field :seo_title, :map, default: %{}
- field :seo_description, :map, default: %{}
-
- # Digital products
- field :file_uuid, Ecto.UUID
- field :download_limit, :integer
- field :download_expiry_days, :integer
-
- # Extensibility
- field :metadata, :map, default: %{}
-
- # Relations
- belongs_to :category, PhoenixKit.Modules.Shop.Category,
- foreign_key: :category_uuid,
- references: :uuid,
- type: UUIDv7
-
- belongs_to :created_by_user, PhoenixKit.Users.Auth.User,
- foreign_key: :created_by_uuid,
- references: :uuid,
- type: UUIDv7
-
- timestamps(type: :utc_datetime)
- end
-
- @doc """
- Changeset for product creation and updates.
- """
- @localized_fields [:title, :slug, :description, :body_html, :seo_title, :seo_description]
-
- def changeset(product, attrs) do
- product
- |> cast(attrs, [
- :title,
- :slug,
- :description,
- :body_html,
- :status,
- :product_type,
- :vendor,
- :tags,
- :price,
- :compare_at_price,
- :cost_per_item,
- :currency,
- :taxable,
- :weight_grams,
- :requires_shipping,
- :made_to_order,
- :images,
- :featured_image,
- :featured_image_uuid,
- :image_uuids,
- :seo_title,
- :seo_description,
- :file_uuid,
- :download_limit,
- :download_expiry_days,
- :metadata,
- :category_uuid,
- :created_by_uuid
- ])
- |> normalize_map_fields(@localized_fields)
- |> validate_required([:price])
- |> validate_localized_required(:title)
- |> validate_inclusion(:status, @statuses)
- |> validate_inclusion(:product_type, @product_types)
- |> validate_number(:price, greater_than_or_equal_to: 0)
- |> validate_number(:compare_at_price, greater_than_or_equal_to: 0)
- |> validate_number(:cost_per_item, greater_than_or_equal_to: 0)
- |> validate_number(:weight_grams, greater_than_or_equal_to: 0)
- |> validate_number(:download_limit, greater_than: 0)
- |> validate_number(:download_expiry_days, greater_than: 0)
- |> validate_length(:currency, is: 3)
- |> maybe_generate_slug()
- end
-
- @doc """
- Returns the list of localized field names.
- """
- def localized_fields, do: @localized_fields
-
- @doc """
- Returns true if product is active.
- """
- def active?(%__MODULE__{status: "active"}), do: true
- def active?(_), do: false
-
- @doc """
- Returns true if product is physical.
- """
- def physical?(%__MODULE__{product_type: "physical"}), do: true
- def physical?(_), do: false
-
- @doc """
- Returns true if product is digital.
- """
- def digital?(%__MODULE__{product_type: "digital"}), do: true
- def digital?(_), do: false
-
- @doc """
- Returns true if product requires shipping.
- """
- def requires_shipping?(%__MODULE__{product_type: "digital"}), do: false
- def requires_shipping?(%__MODULE__{requires_shipping: requires}), do: requires
-
- @doc """
- Returns the display price (compare_at_price if set, otherwise price).
- """
- def display_price(%__MODULE__{compare_at_price: nil, price: price}), do: price
- def display_price(%__MODULE__{compare_at_price: compare}), do: compare
-
- @doc """
- Returns true if product has a discount (compare_at_price > price).
- """
- def on_sale?(%__MODULE__{compare_at_price: nil}), do: false
-
- def on_sale?(%__MODULE__{compare_at_price: compare, price: price}) do
- Decimal.compare(compare, price) == :gt
- end
-
- @doc """
- Calculates discount percentage.
- """
- def discount_percentage(%__MODULE__{} = product) do
- if on_sale?(product) do
- diff = Decimal.sub(product.compare_at_price, product.price)
- percentage = Decimal.div(diff, product.compare_at_price)
- Decimal.mult(percentage, 100) |> Decimal.round(0) |> Decimal.to_integer()
- else
- 0
- end
- end
-
- # Remove empty string values from map fields
- defp normalize_map_fields(changeset, fields) do
- Enum.reduce(fields, changeset, fn field, acc ->
- case get_change(acc, field) do
- nil ->
- acc
-
- map when is_map(map) ->
- cleaned =
- map
- |> Enum.reject(fn {_k, v} -> v in [nil, ""] end)
- |> Map.new()
-
- put_change(acc, field, cleaned)
-
- _ ->
- acc
- end
- end)
- end
-
- # Validate that localized field has value for default language
- defp validate_localized_required(changeset, field) do
- value = get_field(changeset, field) || %{}
- default_lang = default_language()
-
- if Map.get(value, default_lang) in [nil, ""] do
- add_error(changeset, field, "#{default_lang} translation is required")
- else
- changeset
- end
- end
-
- # Generate slug from title for each language
- defp maybe_generate_slug(changeset) do
- title_map = get_field(changeset, :title) || %{}
- slug_map = get_field(changeset, :slug) || %{}
-
- # For each language with a title but no slug, generate one
- updated_slugs =
- Enum.reduce(title_map, slug_map, fn {lang, title}, acc ->
- if Map.get(acc, lang) in [nil, ""] and title not in [nil, ""] do
- generated = slugify(title)
- Map.put(acc, lang, generated)
- else
- acc
- end
- end)
-
- if updated_slugs != slug_map do
- put_change(changeset, :slug, updated_slugs)
- else
- changeset
- end
- end
-
- defp slugify(text) when is_binary(text) do
- text
- |> String.downcase()
- |> String.replace(~r/[^\w\s-]/, "")
- |> String.replace(~r/\s+/, "-")
- |> String.replace(~r/-+/, "-")
- |> String.trim("-")
- end
-
- defp slugify(_), do: ""
-
- defp default_language do
- alias PhoenixKit.Modules.Languages
-
- if Code.ensure_loaded?(Languages) and function_exported?(Languages, :enabled?, 0) and
- Languages.enabled?() do
- case Languages.get_default_language() do
- %{code: code} -> code
- _ -> "en"
- end
- else
- "en"
- end
- end
-end
diff --git a/lib/modules/shop/schemas/shipping_method.ex b/lib/modules/shop/schemas/shipping_method.ex
deleted file mode 100644
index ea46bd407..000000000
--- a/lib/modules/shop/schemas/shipping_method.ex
+++ /dev/null
@@ -1,271 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.ShippingMethod do
- @moduledoc """
- Shipping method schema for E-Commerce module.
-
- Supports weight-based, price-based, and geographic restrictions.
-
- ## Fields
-
- - `name` - Method name (required)
- - `slug` - URL-friendly identifier (unique, auto-generated)
- - `description` - Method description
- - `price` - Shipping cost
- - `free_above_amount` - Free shipping threshold
- - `min_weight_grams`, `max_weight_grams` - Weight limits
- - `min_order_amount`, `max_order_amount` - Order amount limits
- - `countries` - Allowed countries (empty = all)
- - `excluded_countries` - Excluded countries
- - `active` - Enabled/disabled
- - `position` - Sort order
- - `estimated_days_min`, `estimated_days_max` - Delivery estimate
- - `tracking_supported` - Tracking available
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- @primary_key {:uuid, UUIDv7, autogenerate: true}
-
- schema "phoenix_kit_shop_shipping_methods" do
- field :name, :string
- field :slug, :string
- field :description, :string
-
- # Pricing
- field :price, :decimal, default: Decimal.new("0")
- field :currency, :string, default: "USD"
- field :free_above_amount, :decimal
-
- # Constraints
- field :min_weight_grams, :integer, default: 0
- field :max_weight_grams, :integer
- field :min_order_amount, :decimal
- field :max_order_amount, :decimal
-
- # Geographic
- field :countries, {:array, :string}, default: []
- field :excluded_countries, {:array, :string}, default: []
-
- # Status
- field :active, :boolean, default: true
- field :position, :integer, default: 0
-
- # Delivery info
- field :estimated_days_min, :integer
- field :estimated_days_max, :integer
- field :tracking_supported, :boolean, default: false
-
- field :metadata, :map, default: %{}
-
- timestamps(type: :utc_datetime)
- end
-
- @required_fields [:name, :price]
- @optional_fields [
- :slug,
- :description,
- :currency,
- :free_above_amount,
- :min_weight_grams,
- :max_weight_grams,
- :min_order_amount,
- :max_order_amount,
- :countries,
- :excluded_countries,
- :active,
- :position,
- :estimated_days_min,
- :estimated_days_max,
- :tracking_supported,
- :metadata
- ]
-
- @doc """
- Changeset for shipping method creation and updates.
- """
- def changeset(method, attrs) do
- attrs = normalize_booleans(attrs, [:active, :tracking_supported])
-
- method
- |> cast(attrs, @required_fields ++ @optional_fields)
- |> validate_required(@required_fields)
- |> validate_length(:name, max: 255)
- |> validate_length(:slug, max: 100)
- |> validate_length(:currency, is: 3)
- |> validate_number(:price, greater_than_or_equal_to: 0)
- |> validate_number(:free_above_amount, greater_than: 0)
- |> validate_number(:min_weight_grams, greater_than_or_equal_to: 0)
- |> validate_number(:max_weight_grams, greater_than: 0)
- |> validate_number(:min_order_amount, greater_than: 0)
- |> validate_number(:max_order_amount, greater_than: 0)
- |> validate_number(:position, greater_than_or_equal_to: 0)
- |> validate_number(:estimated_days_min, greater_than_or_equal_to: 0)
- |> validate_number(:estimated_days_max, greater_than: 0)
- |> maybe_generate_slug()
- |> unique_constraint(:slug)
- end
-
- @doc """
- Checks if this method is available for given cart parameters.
-
- ## Examples
-
- iex> available_for?(method, %{weight_grams: 500, subtotal: Decimal.new("50"), country: "EE"})
- true
- """
- def available_for?(%__MODULE__{active: false}, _params), do: false
-
- def available_for?(%__MODULE__{} = method, %{
- weight_grams: weight,
- subtotal: subtotal,
- country: country
- }) do
- weight_ok?(method, weight) &&
- amount_ok?(method, subtotal) &&
- country_ok?(method, country)
- end
-
- def available_for?(%__MODULE__{} = method, params) when is_map(params) do
- weight = Map.get(params, :weight_grams, 0)
- subtotal = Map.get(params, :subtotal, Decimal.new("0"))
- country = Map.get(params, :country)
-
- available_for?(method, %{weight_grams: weight, subtotal: subtotal, country: country})
- end
-
- @doc """
- Calculates shipping cost for given subtotal.
- Returns 0 if free shipping threshold is met.
- """
- def calculate_cost(%__MODULE__{free_above_amount: nil, price: price}, _subtotal) do
- price
- end
-
- def calculate_cost(%__MODULE__{free_above_amount: threshold, price: price}, subtotal) do
- if Decimal.compare(subtotal, threshold) != :lt do
- Decimal.new("0")
- else
- price
- end
- end
-
- @doc """
- Returns estimated delivery string.
-
- ## Examples
-
- iex> delivery_estimate(%ShippingMethod{estimated_days_min: 3, estimated_days_max: 5})
- "3-5 days"
-
- iex> delivery_estimate(%ShippingMethod{estimated_days_min: 1, estimated_days_max: 1})
- "1 day"
- """
- def delivery_estimate(%__MODULE__{estimated_days_min: nil}), do: nil
-
- def delivery_estimate(%__MODULE__{estimated_days_min: min, estimated_days_max: nil}) do
- "#{min}+ days"
- end
-
- def delivery_estimate(%__MODULE__{estimated_days_min: 1, estimated_days_max: 1}) do
- "1 day"
- end
-
- def delivery_estimate(%__MODULE__{estimated_days_min: min, estimated_days_max: max})
- when min == max do
- "#{min} days"
- end
-
- def delivery_estimate(%__MODULE__{estimated_days_min: min, estimated_days_max: max}) do
- "#{min}-#{max} days"
- end
-
- @doc """
- Returns true if method is active.
- """
- def active?(%__MODULE__{active: true}), do: true
- def active?(_), do: false
-
- @doc """
- Checks if shipping is free for the given subtotal.
- """
- def free_for?(%__MODULE__{free_above_amount: nil}, _subtotal), do: false
-
- def free_for?(%__MODULE__{free_above_amount: threshold}, subtotal) do
- Decimal.compare(subtotal, threshold) != :lt
- end
-
- # Private helpers
-
- defp weight_ok?(%{min_weight_grams: min, max_weight_grams: max}, weight) do
- min_ok = is_nil(min) or weight >= min
- max_ok = is_nil(max) or weight <= max
- min_ok and max_ok
- end
-
- defp amount_ok?(%{min_order_amount: min, max_order_amount: max}, amount) do
- min_ok = is_nil(min) or Decimal.compare(amount, min) != :lt
- max_ok = is_nil(max) or Decimal.compare(amount, max) != :gt
- min_ok and max_ok
- end
-
- defp country_ok?(%{countries: [], excluded_countries: []}, _country), do: true
-
- defp country_ok?(%{countries: [], excluded_countries: excluded}, country) do
- is_nil(country) or country not in excluded
- end
-
- defp country_ok?(%{countries: allowed, excluded_countries: excluded}, country) do
- (is_nil(country) or country in allowed) and
- (is_nil(country) or country not in excluded)
- end
-
- defp maybe_generate_slug(changeset) do
- case get_change(changeset, :slug) do
- nil ->
- case get_change(changeset, :name) do
- nil -> changeset
- name -> put_change(changeset, :slug, slugify(name))
- end
-
- _ ->
- changeset
- end
- end
-
- defp slugify(text) do
- text
- |> String.downcase()
- |> String.replace(~r/[^\w\s-]/, "")
- |> String.replace(~r/\s+/, "-")
- |> String.replace(~r/-+/, "-")
- |> String.trim("-")
- end
-
- defp normalize_booleans(attrs, fields) when is_map(attrs) do
- Enum.reduce(fields, attrs, fn field, acc ->
- str_key = to_string(field)
-
- cond do
- Map.has_key?(acc, field) ->
- Map.update!(acc, field, &to_boolean/1)
-
- Map.has_key?(acc, str_key) ->
- Map.update!(acc, str_key, &to_boolean/1)
-
- true ->
- acc
- end
- end)
- end
-
- defp to_boolean(true), do: true
- defp to_boolean(false), do: false
- defp to_boolean("true"), do: true
- defp to_boolean("false"), do: false
- defp to_boolean(1), do: true
- defp to_boolean(0), do: false
- defp to_boolean("1"), do: true
- defp to_boolean("0"), do: false
- defp to_boolean(nil), do: nil
- defp to_boolean(other), do: other
-end
diff --git a/lib/modules/shop/schemas/shop_config.ex b/lib/modules/shop/schemas/shop_config.ex
deleted file mode 100644
index 291623de6..000000000
--- a/lib/modules/shop/schemas/shop_config.ex
+++ /dev/null
@@ -1,45 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.ShopConfig do
- @moduledoc """
- Shop configuration storage schema (key-value JSONB).
-
- Used for storing global Shop module settings like:
- - `global_attribute_schema` - Global product attribute definitions
-
- ## Attribute Schema Format
-
- %{
- "key" => "material",
- "label" => "Material",
- "type" => "select",
- "options" => ["PLA", "ABS", "PETG"],
- "default" => "PLA",
- "required" => false,
- "unit" => nil,
- "position" => 0
- }
-
- Supported types: `text`, `number`, `boolean`, `select`, `multiselect`
- """
-
- use Ecto.Schema
- import Ecto.Changeset
-
- @primary_key {:key, :string, autogenerate: false}
- @timestamps_opts [type: :utc_datetime]
-
- schema "phoenix_kit_shop_config" do
- field :value, :map
-
- timestamps()
- end
-
- @doc """
- Changeset for shop configuration.
- """
- def changeset(config, attrs) do
- config
- |> cast(attrs, [:key, :value])
- |> validate_required([:key, :value])
- |> validate_length(:key, max: 100)
- end
-end
diff --git a/lib/modules/shop/services/image_downloader.ex b/lib/modules/shop/services/image_downloader.ex
deleted file mode 100644
index 80bb01194..000000000
--- a/lib/modules/shop/services/image_downloader.ex
+++ /dev/null
@@ -1,484 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Services.ImageDownloader do
- @moduledoc """
- Service for downloading images from external URLs and storing them in the Storage module.
-
- Handles HTTP download with proper error handling, content type detection,
- and integration with PhoenixKit.Modules.Storage for persistent storage.
-
- ## Usage
-
- # Download and store a single image
- {:ok, file_uuid} = ImageDownloader.download_and_store(url, user_uuid)
-
- # Download with options
- {:ok, file_uuid} = ImageDownloader.download_and_store(url, user_uuid, timeout: 30_000)
-
- # Batch download multiple images
- results = ImageDownloader.download_batch(urls, user_uuid)
- # => [{url, {:ok, file_uuid}}, {url, {:error, reason}}, ...]
-
- """
-
- require Logger
-
- alias PhoenixKit.Modules.Storage
-
- @default_timeout 30_000
- # 50 MB max
- @max_file_size 50 * 1024 * 1024
- @allowed_content_types ~w(image/jpeg image/png image/gif image/webp image/svg+xml)
-
- @doc """
- Downloads an image from a URL to a temporary file.
-
- Returns `{:ok, temp_path, content_type, size}` on success.
-
- ## Options
-
- * `:timeout` - HTTP request timeout in milliseconds (default: 30_000)
-
- ## Examples
-
- iex> download_image("https://example.com/image.jpg")
- {:ok, "/tmp/phx_img_abc123", "image/jpeg", 12345}
-
- iex> download_image("https://example.com/404.jpg")
- {:error, :not_found}
-
- """
- @spec download_image(String.t(), keyword()) ::
- {:ok, String.t(), String.t(), non_neg_integer()} | {:error, atom() | String.t()}
- def download_image(url, opts \\ []) when is_binary(url) do
- timeout = Keyword.get(opts, :timeout, @default_timeout)
-
- with {:ok, url} <- validate_url(url),
- {:ok, response} <- do_http_request(url, timeout),
- {:ok, content_type} <- extract_content_type(response),
- :ok <- validate_content_type(content_type),
- :ok <- validate_size(response.body),
- {:ok, temp_path} <- write_temp_file(response.body, content_type) do
- {:ok, temp_path, content_type, byte_size(response.body)}
- end
- end
-
- @doc """
- Downloads an image from a URL and stores it in the Storage module.
-
- Returns `{:ok, file_uuid}` where file_uuid is a UUID that can be used to reference
- the stored file.
-
- ## Options
-
- * `:timeout` - HTTP request timeout in milliseconds (default: 30_000)
- * `:metadata` - Additional metadata to store with the file
-
- ## Examples
-
- iex> download_and_store("https://cdn.shopify.com/image.jpg", user_uuid)
- {:ok, "018f1234-5678-7890-abcd-ef1234567890"}
-
- iex> download_and_store("https://example.com/404.jpg", user_uuid)
- {:error, :not_found}
-
- """
- @spec download_and_store(String.t(), String.t() | nil, keyword()) ::
- {:ok, String.t()} | {:error, atom() | String.t()}
- def download_and_store(url, user_uuid, opts \\ []) when is_binary(url) do
- metadata = Keyword.get(opts, :metadata, %{})
-
- with {:ok, temp_path, content_type, size} <- download_image(url, opts) do
- # Check for global deduplication by file hash AND original filename
- file_checksum = calculate_file_hash(temp_path)
- filename = extract_filename_from_url(url, content_type)
-
- case find_existing_file(file_checksum, filename) do
- %{uuid: existing_uuid} = _existing_file ->
- # File with same content and name already exists - reuse it
- Logger.info(
- "[ImageDownloader] Reusing existing file #{existing_uuid} for URL #{url} (checksum: #{file_checksum}, filename: #{filename})"
- )
-
- cleanup_temp_file(temp_path)
- {:ok, existing_uuid}
-
- nil ->
- # No existing file matches - store new file
- Logger.info(
- "[ImageDownloader] Storing new file from URL #{url}, temp_path=#{temp_path}, size=#{size}"
- )
-
- store_new_file(temp_path, filename, content_type, size, user_uuid, url, metadata)
- end
- end
- end
-
- # Store a new file after verifying it exists
- defp store_new_file(temp_path, filename, content_type, size, user_uuid, url, metadata) do
- if File.exists?(temp_path) do
- result =
- Storage.store_file(temp_path,
- filename: filename,
- content_type: content_type,
- size_bytes: size,
- user_uuid: user_uuid,
- metadata: Map.merge(metadata, %{"source_url" => url})
- )
-
- Logger.info("[ImageDownloader] Storage result: #{inspect(result)}")
- cleanup_temp_file(temp_path)
- handle_storage_result(result)
- else
- Logger.error("[ImageDownloader] Temp file disappeared before storage: #{temp_path}")
- {:error, :temp_file_missing}
- end
- end
-
- defp handle_storage_result({:ok, file}) do
- Logger.info("[ImageDownloader] Successfully stored file with ID: #{file.uuid}")
- {:ok, file.uuid}
- end
-
- defp handle_storage_result({:error, reason}) do
- Logger.error("[ImageDownloader] Storage failed: #{inspect(reason)}")
- {:error, reason}
- end
-
- # Find existing file by checksum AND original filename
- defp find_existing_file(file_checksum, filename) do
- import Ecto.Query
-
- repo = PhoenixKit.Config.get_repo()
-
- query =
- from(f in PhoenixKit.Modules.Storage.File,
- where: f.file_checksum == ^file_checksum and f.original_file_name == ^filename,
- limit: 1
- )
-
- repo.one(query)
- end
-
- # Calculate SHA256 hash of file content
- defp calculate_file_hash(file_path) do
- Elixir.File.stream!(file_path, 2048)
- |> Enum.reduce(:crypto.hash_init(:sha256), fn chunk, acc ->
- :crypto.hash_update(acc, chunk)
- end)
- |> :crypto.hash_final()
- |> Base.encode16(case: :lower)
- end
-
- @doc """
- Downloads and stores multiple images in batch.
-
- Returns a list of tuples `{url, result}` where result is either
- `{:ok, file_uuid}` or `{:error, reason}`.
-
- ## Options
-
- * `:timeout` - HTTP request timeout for each image (default: 30_000)
- * `:concurrency` - Number of concurrent downloads (default: 5)
- * `:on_progress` - Callback function called after each download: `fn(url, result, index, total) -> :ok end`
-
- ## Examples
-
- iex> download_batch(["url1", "url2", "url3"], user_uuid)
- [{"url1", {:ok, "uuid-1"}}, {"url2", {:ok, "uuid-2"}}, {"url3", {:error, :timeout}}]
-
- """
- @spec download_batch([String.t()], String.t() | nil, keyword()) ::
- [{String.t(), {:ok, String.t()} | {:error, atom() | String.t()}}]
- def download_batch(urls, user_uuid, opts \\ []) when is_list(urls) do
- concurrency = Keyword.get(opts, :concurrency, 5)
- on_progress = Keyword.get(opts, :on_progress)
- total = length(urls)
-
- # Create indexed list to preserve URL even on task crash
- indexed_urls = Enum.with_index(urls, 1)
-
- indexed_urls
- |> Task.async_stream(
- fn {url, index} ->
- result = download_and_store(url, user_uuid, opts)
-
- if on_progress do
- on_progress.(url, result, index, total)
- end
-
- {index, url, result}
- end,
- max_concurrency: concurrency,
- timeout: Keyword.get(opts, :timeout, @default_timeout) + 5_000,
- on_timeout: :kill_task,
- ordered: true
- )
- |> Enum.zip(indexed_urls)
- |> Enum.map(fn
- {{:ok, {_index, url, result}}, _original} ->
- {url, result}
-
- {{:exit, reason}, {url, _index}} ->
- # Recover URL from original indexed list when task exits
- Logger.warning("Task exited for URL #{url}: #{inspect(reason)}")
- {url, {:error, {:task_exit, reason}}}
- end)
- end
-
- @doc """
- Validates URLs are accessible before batch download.
-
- Performs HEAD requests to verify URLs are accessible and return valid
- image content types. Returns a tuple of `{valid_urls, invalid_urls}`.
-
- ## Options
-
- * `:timeout` - HTTP request timeout in milliseconds (default: 5_000)
- * `:concurrency` - Number of concurrent validations (default: 10)
-
- ## Examples
-
- iex> validate_urls(["https://example.com/image.jpg", "https://example.com/404.jpg"])
- {["https://example.com/image.jpg"], ["https://example.com/404.jpg"]}
-
- """
- @spec validate_urls([String.t()], keyword()) :: {[String.t()], [String.t()]}
- def validate_urls(urls, opts \\ []) when is_list(urls) do
- timeout = Keyword.get(opts, :timeout, 5_000)
- concurrency = Keyword.get(opts, :concurrency, 10)
-
- results =
- urls
- |> Task.async_stream(
- fn url -> {url, valid_image_url?(url, timeout)} end,
- max_concurrency: concurrency,
- timeout: timeout + 2_000,
- on_timeout: :kill_task
- )
- |> Enum.map(fn
- {:ok, {url, true}} -> {:valid, url}
- {:ok, {url, false}} -> {:invalid, url}
- {:exit, _reason} -> {:timeout, nil}
- end)
- |> Enum.reject(fn {_status, url} -> is_nil(url) end)
-
- valid = for {:valid, url} <- results, do: url
- invalid = for {:invalid, url} <- results, do: url
-
- {valid, invalid}
- end
-
- @doc """
- Checks if a URL points to a valid image that can be downloaded.
-
- Performs a HEAD request to verify the URL is accessible and returns
- an image content type.
-
- ## Examples
-
- iex> valid_image_url?("https://example.com/image.jpg")
- true
-
- iex> valid_image_url?("https://example.com/document.pdf")
- false
-
- """
- @spec valid_image_url?(String.t()) :: boolean()
- def valid_image_url?(url) when is_binary(url) do
- valid_image_url?(url, 5_000)
- end
-
- @spec valid_image_url?(String.t(), non_neg_integer()) :: boolean()
- defp valid_image_url?(url, timeout) when is_binary(url) do
- case validate_url(url) do
- {:ok, url} ->
- case Req.head(url, receive_timeout: timeout) do
- {:ok, %{status: status, headers: headers}} when status in 200..299 ->
- content_type = get_header_value(headers, "content-type")
- validate_content_type(content_type) == :ok
-
- _ ->
- false
- end
-
- _ ->
- false
- end
- end
-
- # Private functions
-
- defp validate_url(url) do
- uri = URI.parse(url)
-
- cond do
- uri.scheme not in ["http", "https"] ->
- {:error, :invalid_scheme}
-
- is_nil(uri.host) or uri.host == "" ->
- {:error, :invalid_host}
-
- true ->
- # Upgrade HTTP to HTTPS for security
- url =
- if uri.scheme == "http",
- do: String.replace_prefix(url, "http://", "https://"),
- else: url
-
- {:ok, url}
- end
- end
-
- defp do_http_request(url, timeout) do
- opts = [
- receive_timeout: timeout,
- max_redirects: 5,
- headers: [
- {"user-agent", "PhoenixKit/1.0 (Image Downloader)"},
- {"accept", "image/*"}
- ]
- ]
-
- case Req.get(url, opts) do
- {:ok, %{status: 200} = response} ->
- {:ok, response}
-
- {:ok, %{status: 301}} ->
- {:error, :redirect_loop}
-
- {:ok, %{status: 302}} ->
- {:error, :redirect_loop}
-
- {:ok, %{status: 404}} ->
- {:error, :not_found}
-
- {:ok, %{status: 403}} ->
- {:error, :forbidden}
-
- {:ok, %{status: 429}} ->
- {:error, :rate_limited}
-
- {:ok, %{status: status}} when status >= 500 ->
- {:error, :server_error}
-
- {:ok, %{status: status}} ->
- {:error, {:http_error, status}}
-
- {:error, %Req.TransportError{reason: :timeout}} ->
- {:error, :timeout}
-
- {:error, %Req.TransportError{reason: reason}} ->
- {:error, {:transport_error, reason}}
-
- {:error, reason} ->
- {:error, {:request_failed, reason}}
- end
- end
-
- defp extract_content_type(%{headers: headers}) do
- case get_header_value(headers, "content-type") do
- nil ->
- {:error, :missing_content_type}
-
- content_type ->
- # Extract just the MIME type, ignoring charset or other parameters
- mime_type =
- content_type
- |> String.split(";")
- |> List.first()
- |> String.trim()
- |> String.downcase()
-
- {:ok, mime_type}
- end
- end
-
- defp get_header_value(headers, key) do
- key_lower = String.downcase(key)
-
- headers
- |> Enum.find(fn {k, _v} -> String.downcase(k) == key_lower end)
- |> case do
- {_, value} when is_list(value) -> List.first(value)
- {_, value} -> value
- nil -> nil
- end
- end
-
- defp validate_content_type(content_type) when content_type in @allowed_content_types, do: :ok
-
- defp validate_content_type(content_type) do
- Logger.warning("Invalid content type for image download: #{content_type}")
- {:error, {:invalid_content_type, content_type}}
- end
-
- defp validate_size(body) when byte_size(body) <= @max_file_size, do: :ok
-
- defp validate_size(body) do
- size_mb = Float.round(byte_size(body) / 1024 / 1024, 2)
-
- {:error,
- {:file_too_large, "#{size_mb} MB exceeds limit of #{@max_file_size / 1024 / 1024} MB"}}
- end
-
- defp write_temp_file(body, content_type) do
- ext = content_type_to_extension(content_type)
- temp_path = generate_temp_path(ext)
-
- case File.write(temp_path, body) do
- :ok -> {:ok, temp_path}
- {:error, reason} -> {:error, {:write_failed, reason}}
- end
- end
-
- defp generate_temp_path(ext) do
- random = :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
- Path.join(System.tmp_dir!(), "phx_img_#{random}.#{ext}")
- end
-
- defp extract_filename_from_url(url, content_type) do
- uri = URI.parse(url)
-
- # Try to get filename from path
- base_name =
- case uri.path do
- nil ->
- "image"
-
- path ->
- path
- |> Path.basename()
- |> String.split("?")
- |> List.first()
- |> case do
- "" -> "image"
- name -> Path.rootname(name)
- end
- end
-
- # Ensure proper extension
- ext = content_type_to_extension(content_type)
- "#{base_name}.#{ext}"
- end
-
- defp content_type_to_extension(content_type) do
- case content_type do
- "image/jpeg" -> "jpg"
- "image/png" -> "png"
- "image/gif" -> "gif"
- "image/webp" -> "webp"
- "image/svg+xml" -> "svg"
- _ -> "jpg"
- end
- end
-
- defp cleanup_temp_file(temp_path) do
- case File.rm(temp_path) do
- :ok ->
- :ok
-
- {:error, reason} ->
- Logger.warning("Failed to cleanup temp file #{temp_path}: #{inspect(reason)}")
- :ok
- end
- end
-end
diff --git a/lib/modules/shop/services/image_migration.ex b/lib/modules/shop/services/image_migration.ex
deleted file mode 100644
index ceca6178e..000000000
--- a/lib/modules/shop/services/image_migration.ex
+++ /dev/null
@@ -1,482 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Services.ImageMigration do
- @moduledoc """
- Orchestrates batch migration of product images from external URLs to Storage module.
-
- Provides functions to query migration status, queue migration jobs,
- and migrate individual products.
-
- ## Usage
-
- # Get migration statistics
- stats = ImageMigration.migration_stats()
- # => %{total: 100, migrated: 25, pending: 75, failed: 0}
-
- # Queue all pending products for migration
- {:ok, count} = ImageMigration.queue_all_migrations(user_uuid)
- # => {:ok, 75}
-
- # Migrate a single product synchronously
- {:ok, product} = ImageMigration.migrate_product(product_uuid, user_uuid)
-
- """
-
- require Logger
-
- import Ecto.Query
-
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.Product
- alias PhoenixKit.Modules.Shop.Services.ImageDownloader
- alias PhoenixKit.Modules.Shop.Workers.ImageMigrationWorker
-
- @doc """
- Returns products that need image migration.
-
- A product needs migration if it has legacy image URLs but no Storage UUIDs.
-
- ## Options
-
- * `:limit` - Maximum number of products to return (default: all)
- * `:offset` - Number of products to skip (default: 0)
-
- ## Examples
-
- iex> products_needing_migration()
- [%Product{}, %Product{}, ...]
-
- iex> products_needing_migration(limit: 10)
- [%Product{}, ...]
-
- """
- @spec products_needing_migration(keyword()) :: [Product.t()]
- def products_needing_migration(opts \\ []) do
- limit = Keyword.get(opts, :limit)
- offset = Keyword.get(opts, :offset, 0)
-
- query =
- from(p in Product,
- # Has legacy images (JSONB array) or featured_image URL
- # No Storage-based images yet
- where:
- (fragment("jsonb_array_length(?) > 0", p.images) or
- (not is_nil(p.featured_image) and p.featured_image != "")) and
- is_nil(p.featured_image_uuid) and
- fragment("COALESCE(array_length(?, 1), 0) = 0", p.image_uuids),
- order_by: [asc: p.inserted_at]
- )
-
- query = if offset > 0, do: offset(query, ^offset), else: query
- query = if limit, do: limit(query, ^limit), else: query
-
- repo().all(query)
- end
-
- @doc """
- Returns the count of products needing migration.
-
- ## Examples
-
- iex> products_needing_migration_count()
- 75
-
- """
- @spec products_needing_migration_count() :: non_neg_integer()
- def products_needing_migration_count do
- query =
- from(p in Product,
- where:
- (fragment("jsonb_array_length(?) > 0", p.images) or
- (not is_nil(p.featured_image) and p.featured_image != "")) and
- is_nil(p.featured_image_uuid) and
- fragment("COALESCE(array_length(?, 1), 0) = 0", p.image_uuids),
- select: count(p.uuid)
- )
-
- repo().one(query) || 0
- end
-
- @doc """
- Returns the count of products that have been migrated.
-
- ## Examples
-
- iex> products_migrated_count()
- 25
-
- """
- @spec products_migrated_count() :: non_neg_integer()
- def products_migrated_count do
- query =
- from(p in Product,
- where:
- not is_nil(p.featured_image_uuid) or
- fragment("array_length(?, 1) > 0", p.image_uuids),
- select: count(p.uuid)
- )
-
- repo().one(query) || 0
- end
-
- @doc """
- Returns migration statistics.
-
- ## Returns
-
- A map with the following keys:
- * `:total` - Total products with any images (legacy or storage)
- * `:migrated` - Products that have storage-based images
- * `:pending` - Products with legacy images but no storage images
- * `:failed` - Count of failed migration jobs (from Oban)
- * `:in_progress` - Count of currently running migration jobs
-
- ## Examples
-
- iex> migration_stats()
- %{total: 100, migrated: 25, pending: 75, failed: 0, in_progress: 5}
-
- """
- @spec migration_stats() :: map()
- def migration_stats do
- pending = products_needing_migration_count()
- migrated = products_migrated_count()
- total = pending + migrated
-
- # Get job stats from Oban
- {in_progress, failed} = get_oban_job_stats()
-
- %{
- total: total,
- migrated: migrated,
- pending: pending,
- failed: failed,
- in_progress: in_progress
- }
- end
-
- defp get_oban_job_stats do
- # Count executing and available jobs
- in_progress_query =
- from(j in Oban.Job,
- where:
- j.worker == "PhoenixKit.Modules.Shop.Workers.ImageMigrationWorker" and
- j.state in ["executing", "available", "scheduled"],
- select: count(j.id)
- )
-
- # Count failed jobs (not retrying)
- failed_query =
- from(j in Oban.Job,
- where:
- j.worker == "PhoenixKit.Modules.Shop.Workers.ImageMigrationWorker" and
- j.state == "discarded",
- select: count(j.id)
- )
-
- in_progress = repo().one(in_progress_query) || 0
- failed = repo().one(failed_query) || 0
-
- {in_progress, failed}
- end
-
- @doc """
- Queues migration jobs for all products needing migration.
-
- Creates an Oban job for each product that has legacy images but no storage images.
-
- ## Options
-
- * `:limit` - Maximum number of products to queue (default: all)
- * `:priority` - Oban job priority (default: 3)
-
- ## Returns
-
- * `{:ok, count}` - Number of jobs queued
- * `{:error, reason}` - If queuing failed
-
- ## Examples
-
- iex> queue_all_migrations(user_uuid)
- {:ok, 75}
-
- iex> queue_all_migrations(user_uuid, limit: 10)
- {:ok, 10}
-
- """
- @spec queue_all_migrations(String.t() | integer(), keyword()) ::
- {:ok, non_neg_integer()} | {:error, term()}
- def queue_all_migrations(user_uuid, opts \\ []) do
- limit = Keyword.get(opts, :limit)
- priority = Keyword.get(opts, :priority, 3)
-
- products = products_needing_migration(limit: limit)
- count = length(products)
-
- Logger.info("Queuing image migration for #{count} products")
-
- jobs =
- Enum.map(products, fn product ->
- ImageMigrationWorker.new(
- %{product_uuid: product.uuid, user_uuid: user_uuid},
- priority: priority
- )
- end)
-
- inserted = Oban.insert_all(jobs)
- broadcast_migration_started(count)
- {:ok, length(inserted)}
- end
-
- @doc """
- Cancels all pending migration jobs.
-
- ## Returns
-
- * `{:ok, count}` - Number of jobs cancelled
-
- """
- @spec cancel_pending_migrations() :: {:ok, non_neg_integer()}
- def cancel_pending_migrations do
- query =
- from(j in Oban.Job,
- where:
- j.worker == "PhoenixKit.Modules.Shop.Workers.ImageMigrationWorker" and
- j.state in ["available", "scheduled"]
- )
-
- {count, _} = repo().delete_all(query)
-
- Logger.info("Cancelled #{count} pending migration jobs")
- broadcast_migration_cancelled(count)
-
- {:ok, count}
- end
-
- @doc """
- Migrates a single product synchronously.
-
- Downloads all legacy images and updates the product with storage UUIDs.
-
- ## Returns
-
- * `{:ok, product}` - Updated product with storage image IDs
- * `{:error, :already_migrated}` - Product already has storage images
- * `{:error, :no_images}` - Product has no legacy images to migrate
- * `{:error, reason}` - Migration failed
-
- ## Examples
-
- iex> migrate_product(product_uuid, user_uuid)
- {:ok, %Product{featured_image_uuid: "uuid-1", image_uuids: ["uuid-1", "uuid-2"]}}
-
- """
- @spec migrate_product(String.t(), String.t() | integer()) ::
- {:ok, Product.t()} | {:error, term()}
- def migrate_product(product_uuid, user_uuid) do
- case Shop.get_product(product_uuid) do
- nil ->
- {:error, :product_not_found}
-
- product ->
- do_migrate_product(product, user_uuid)
- end
- end
-
- defp do_migrate_product(product, user_uuid) do
- # Check if already migrated
- if has_storage_images?(product) do
- {:error, :already_migrated}
- else
- # Validate product has required fields
- with :ok <- validate_product_for_migration(product) do
- # Collect image URLs
- image_urls = collect_image_urls(product)
-
- if Enum.empty?(image_urls) do
- {:error, :no_images}
- else
- migrate_images_for_product(product, image_urls, user_uuid)
- end
- end
- end
- end
-
- defp validate_product_for_migration(product) do
- cond do
- is_nil(product.title) or product.title == %{} ->
- Logger.warning("Product #{product.uuid} missing title, skipping migration")
- {:error, :missing_title}
-
- is_nil(product.slug) or product.slug == %{} ->
- Logger.warning("Product #{product.uuid} missing slug, skipping migration")
- {:error, :missing_slug}
-
- true ->
- :ok
- end
- end
-
- defp has_storage_images?(product) do
- not is_nil(product.featured_image_uuid) or
- (is_list(product.image_uuids) and product.image_uuids != [])
- end
-
- defp collect_image_urls(product) do
- urls = []
-
- # Add featured_image URL if present
- urls =
- if is_binary(product.featured_image) and String.starts_with?(product.featured_image, "http") do
- [product.featured_image | urls]
- else
- urls
- end
-
- # Add all images from the legacy images array
- legacy_image_urls =
- (product.images || [])
- |> Enum.flat_map(fn
- %{"src" => src} when is_binary(src) -> [src]
- src when is_binary(src) -> [src]
- _ -> []
- end)
- |> Enum.filter(&String.starts_with?(&1, "http"))
-
- (urls ++ legacy_image_urls) |> Enum.uniq()
- end
-
- defp migrate_images_for_product(product, image_urls, user_uuid) do
- # Validate URLs first to skip unavailable images
- {valid_urls, invalid_urls} = ImageDownloader.validate_urls(image_urls)
-
- if invalid_urls != [] do
- Logger.warning(
- "Product #{product.uuid}: #{length(invalid_urls)} invalid URLs skipped: #{inspect(invalid_urls)}"
- )
- end
-
- if valid_urls == [] do
- Logger.warning("Product #{product.uuid}: All image URLs invalid")
- {:error, :all_urls_invalid}
- else
- Logger.info("Migrating #{length(valid_urls)} valid images for product #{product.uuid}")
-
- # Download all images
- results =
- ImageDownloader.download_batch(valid_urls, user_uuid, concurrency: 3, timeout: 60_000)
-
- # Build URL -> file_uuid mapping
- url_to_file_uuid =
- Enum.reduce(results, %{}, fn
- {url, {:ok, file_uuid}}, acc ->
- Map.put(acc, url, file_uuid)
-
- {url, {:error, reason}}, acc ->
- Logger.warning("Failed to download #{url}: #{inspect(reason)}")
- acc
- end)
-
- if map_size(url_to_file_uuid) == 0 do
- {:error, :all_downloads_failed}
- else
- update_product_images(product, url_to_file_uuid)
- end
- end
- end
-
- defp update_product_images(product, url_to_file_uuid) do
- # Map featured_image to featured_image_uuid
- featured_image_uuid = Map.get(url_to_file_uuid, product.featured_image)
-
- # Map legacy images to image_uuids, preserving order from original images array
- image_uuids =
- (product.images || [])
- |> Enum.flat_map(fn
- %{"src" => src} -> [src]
- src when is_binary(src) -> [src]
- _ -> []
- end)
- |> Enum.map(&Map.get(url_to_file_uuid, &1))
- |> Enum.reject(&is_nil/1)
-
- # Use first image_id as featured if not set
- featured_image_uuid = featured_image_uuid || List.first(image_uuids)
-
- # Ensure featured image is first in image_uuids (no duplicates)
- image_uuids =
- if featured_image_uuid && featured_image_uuid in image_uuids do
- [featured_image_uuid | Enum.reject(image_uuids, &(&1 == featured_image_uuid))]
- else
- image_uuids
- end
-
- # Update image mappings in metadata
- metadata = update_image_mappings(product.metadata, url_to_file_uuid)
-
- attrs = %{
- featured_image_uuid: featured_image_uuid,
- image_uuids: image_uuids,
- metadata: metadata,
- # Clear legacy fields after successful migration
- images: [],
- featured_image: nil
- }
-
- Shop.update_product(product, attrs)
- end
-
- defp update_image_mappings(nil, _url_to_file_uuid), do: nil
-
- defp update_image_mappings(metadata, url_to_file_uuid) when is_map(metadata) do
- case Map.get(metadata, "_image_mappings") do
- nil ->
- metadata
-
- mappings when is_map(mappings) ->
- updated_mappings =
- Enum.reduce(mappings, %{}, fn {option_key, value_map}, acc ->
- updated_value_map =
- Enum.reduce(value_map, %{}, fn {value, image_ref}, inner_acc ->
- new_ref = convert_url_to_file_uuid(image_ref, url_to_file_uuid)
- Map.put(inner_acc, value, new_ref)
- end)
-
- Map.put(acc, option_key, updated_value_map)
- end)
-
- Map.put(metadata, "_image_mappings", updated_mappings)
- end
- end
-
- defp update_image_mappings(metadata, _url_to_file_uuid), do: metadata
-
- defp convert_url_to_file_uuid(image_ref, url_to_file_uuid)
- when is_binary(image_ref) do
- if String.starts_with?(image_ref, "http") do
- Map.get(url_to_file_uuid, image_ref, image_ref)
- else
- image_ref
- end
- end
-
- defp convert_url_to_file_uuid(image_ref, _url_to_file_uuid), do: image_ref
-
- # PubSub broadcasts
-
- defp broadcast_migration_started(count) do
- PhoenixKit.PubSubHelper.broadcast(
- "shop:image_migration:batch",
- {:migration_started, %{total: count}}
- )
- end
-
- defp broadcast_migration_cancelled(count) do
- PhoenixKit.PubSubHelper.broadcast(
- "shop:image_migration:batch",
- {:migration_cancelled, %{cancelled: count}}
- )
- end
-
- defp repo do
- PhoenixKit.Config.get_repo()
- end
-end
diff --git a/lib/modules/shop/shop.ex b/lib/modules/shop/shop.ex
deleted file mode 100644
index 3b5b6cea7..000000000
--- a/lib/modules/shop/shop.ex
+++ /dev/null
@@ -1,3530 +0,0 @@
-defmodule PhoenixKit.Modules.Shop do
- @moduledoc """
- E-commerce Shop Module for PhoenixKit.
-
- Provides comprehensive e-commerce functionality including products, categories,
- options-based pricing, and cart management.
-
- ## Features
-
- - **Products**: Physical and digital products with JSONB flexibility
- - **Categories**: Hierarchical product categories
- - **Options**: Product options with dynamic pricing (fixed or percent modifiers)
- - **Inventory**: Stock tracking with reservation system
- - **Cart**: Persistent shopping cart (DB-backed for cross-device support)
-
- ## System Enable/Disable
-
- # Check if shop is enabled
- PhoenixKit.Modules.Shop.enabled?()
-
- # Enable/disable shop system
- PhoenixKit.Modules.Shop.enable_system()
- PhoenixKit.Modules.Shop.disable_system()
-
- ## Integration with Billing
-
- Shop integrates with the Billing module for orders and payments.
- Order line_items include shop metadata for product tracking.
- """
-
- use PhoenixKit.Module
-
- import Ecto.Query, warn: false
- require Logger
-
- alias PhoenixKit.Dashboard.Tab
- alias PhoenixKit.Modules.Billing
- alias PhoenixKit.Modules.Billing.Currency
- alias PhoenixKit.Modules.Billing.PaymentOption
- alias PhoenixKit.Modules.Languages
- alias PhoenixKit.Modules.Languages.DialectMapper
- alias PhoenixKit.Modules.Shop.Cart
- alias PhoenixKit.Modules.Shop.CartItem
- alias PhoenixKit.Modules.Shop.Category
- alias PhoenixKit.Modules.Shop.Events
- alias PhoenixKit.Modules.Shop.ImportConfig
- alias PhoenixKit.Modules.Shop.Options
- alias PhoenixKit.Modules.Shop.Options.MetadataValidator
- alias PhoenixKit.Modules.Shop.Product
- alias PhoenixKit.Modules.Shop.ShippingMethod
- alias PhoenixKit.Modules.Shop.ShopConfig
- alias PhoenixKit.Modules.Shop.SlugResolver
- alias PhoenixKit.Modules.Shop.Translations
- alias PhoenixKit.Settings
- alias PhoenixKit.Users.Auth
- alias PhoenixKit.Utils.Date, as: UtilsDate
- alias PhoenixKit.Utils.Routes
- alias PhoenixKit.Utils.UUID, as: UUIDUtils
-
- # ============================================
- # SYSTEM ENABLE/DISABLE
- # ============================================
-
- @impl PhoenixKit.Module
- @doc """
- Checks if the shop system is enabled.
- """
- def enabled? do
- Settings.get_boolean_setting("shop_enabled", false)
- end
-
- @impl PhoenixKit.Module
- @doc """
- Enables the shop system.
- """
- def enable_system do
- result = Settings.update_boolean_setting_with_module("shop_enabled", true, "shop")
- refresh_dashboard_tabs()
- result
- end
-
- @impl PhoenixKit.Module
- @doc """
- Disables the shop system.
- """
- def disable_system do
- result = Settings.update_boolean_setting_with_module("shop_enabled", false, "shop")
- refresh_dashboard_tabs()
- result
- end
-
- defp refresh_dashboard_tabs do
- if Code.ensure_loaded?(PhoenixKit.Dashboard.Registry) and
- PhoenixKit.Dashboard.Registry.initialized?() do
- PhoenixKit.Dashboard.Registry.load_defaults()
- end
- end
-
- @impl PhoenixKit.Module
- @doc """
- Returns the current shop configuration.
- """
- def get_config do
- %{
- enabled: enabled?(),
- currency: get_default_currency_code(),
- tax_enabled: Settings.get_setting_cached("shop_tax_enabled", "true") == "true",
- tax_rate: Settings.get_setting_cached("shop_tax_rate", "20"),
- inventory_tracking:
- Settings.get_setting_cached("shop_inventory_tracking", "true") == "true",
- allow_price_override:
- Settings.get_setting_cached("shop_allow_price_override", "false") == "true",
- products_count: count_products(),
- categories_count: count_categories()
- }
- end
-
- @doc """
- Returns dashboard statistics for the shop.
- """
- def get_dashboard_stats do
- %{
- total_products: count_products(),
- active_products: count_products_by_status("active"),
- draft_products: count_products_by_status("draft"),
- archived_products: count_products_by_status("archived"),
- total_categories: count_categories(),
- physical_products: count_products_by_type("physical"),
- digital_products: count_products_by_type("digital"),
- default_currency: get_default_currency_code()
- }
- end
-
- @doc """
- Gets the default currency code from Billing module.
- Falls back to "USD" if Billing has no default currency configured.
- """
- def get_default_currency_code do
- case Billing.get_default_currency() do
- %{code: code} -> code
- nil -> "USD"
- end
- end
-
- @doc """
- Gets the default currency struct from Billing module.
- """
- def get_default_currency do
- Billing.get_default_currency()
- end
-
- # ============================================
- # MODULE BEHAVIOUR CALLBACKS
- # ============================================
-
- @impl PhoenixKit.Module
- def module_key, do: "shop"
-
- @impl PhoenixKit.Module
- def module_name, do: "E-Commerce"
-
- @impl PhoenixKit.Module
- def permission_metadata do
- %{
- key: "shop",
- label: "E-Commerce",
- icon: "hero-shopping-cart",
- description: "Product catalog, orders, and e-commerce management"
- }
- end
-
- @impl PhoenixKit.Module
- def admin_tabs do
- [
- Tab.new!(
- id: :admin_shop,
- label: "E-Commerce",
- icon: "hero-shopping-bag",
- path: "shop",
- priority: 530,
- level: :admin,
- permission: "shop",
- match: :exact,
- group: :admin_modules,
- subtab_display: :when_active,
- highlight_with_subtabs: false
- ),
- Tab.new!(
- id: :admin_shop_dashboard,
- label: "Dashboard",
- icon: "hero-home",
- path: "shop",
- priority: 531,
- level: :admin,
- permission: "shop",
- parent: :admin_shop,
- match: :exact
- ),
- Tab.new!(
- id: :admin_shop_products,
- label: "Products",
- icon: "hero-cube",
- path: "shop/products",
- priority: 532,
- level: :admin,
- permission: "shop",
- parent: :admin_shop
- ),
- Tab.new!(
- id: :admin_shop_categories,
- label: "Categories",
- icon: "hero-folder",
- path: "shop/categories",
- priority: 533,
- level: :admin,
- permission: "shop",
- parent: :admin_shop
- ),
- Tab.new!(
- id: :admin_shop_shipping,
- label: "Shipping",
- icon: "hero-truck",
- path: "shop/shipping",
- priority: 534,
- level: :admin,
- permission: "shop",
- parent: :admin_shop
- ),
- Tab.new!(
- id: :admin_shop_carts,
- label: "Carts",
- icon: "hero-shopping-cart",
- path: "shop/carts",
- priority: 535,
- level: :admin,
- permission: "shop",
- parent: :admin_shop
- ),
- Tab.new!(
- id: :admin_shop_imports,
- label: "CSV Import",
- icon: "hero-cloud-arrow-up",
- path: "shop/imports",
- priority: 536,
- level: :admin,
- permission: "shop",
- parent: :admin_shop
- )
- ]
- end
-
- @impl PhoenixKit.Module
- def settings_tabs do
- [
- Tab.new!(
- id: :admin_settings_shop,
- label: "E-Commerce",
- icon: "hero-shopping-bag",
- path: "/admin/shop/settings",
- priority: 927,
- level: :admin,
- parent: :admin_settings,
- permission: "shop"
- )
- ]
- end
-
- @impl PhoenixKit.Module
- def user_dashboard_tabs do
- [
- Tab.new!(
- id: :dashboard_shop,
- label: "Shop",
- icon: "hero-building-storefront",
- path: "/shop",
- priority: 300,
- match: :prefix,
- group: :shop
- ),
- Tab.new!(
- id: :dashboard_cart,
- label: "My Cart",
- icon: "hero-shopping-cart",
- path: "/cart",
- priority: 310,
- match: :prefix,
- group: :shop
- )
- ]
- end
-
- @impl PhoenixKit.Module
- def route_module, do: PhoenixKitWeb.Routes.ShopRoutes
-
- # ============================================
- # PRODUCTS
- # ============================================
-
- @doc """
- Lists all products with optional filters.
-
- ## Options
- - `:status` - Filter by status (draft, active, archived)
- - `:product_type` - Filter by type (physical, digital)
- - `:category_uuid` - Filter by category
- - `:search` - Search in title and description
- - `:page` - Page number
- - `:per_page` - Items per page
- - `:preload` - Associations to preload
- """
- def list_products(opts \\ []) do
- Product
- |> apply_product_filters(opts)
- |> order_by([p], desc: p.inserted_at)
- |> maybe_preload(Keyword.get(opts, :preload))
- |> repo().all()
- end
-
- @doc """
- Lists products with count for pagination.
- """
- def list_products_with_count(opts \\ []) do
- page = Keyword.get(opts, :page, 1)
- per_page = Keyword.get(opts, :per_page, 25)
- offset = (page - 1) * per_page
-
- base_query =
- Product
- |> apply_product_filters(opts)
-
- total = repo().aggregate(base_query, :count)
-
- products =
- base_query
- |> order_by([p], desc: p.inserted_at)
- |> limit(^per_page)
- |> offset(^offset)
- |> maybe_preload(Keyword.get(opts, :preload, [:category]))
- |> repo().all()
-
- {products, total}
- end
-
- @doc """
- Lists products by their IDs.
-
- Returns products in the order of the provided IDs.
- """
- def list_products_by_ids([]), do: []
-
- def list_products_by_ids(ids) when is_list(ids) do
- Product |> where([p], p.uuid in ^ids) |> repo().all()
- end
-
- # ============================================
- # STOREFRONT FILTERS
- # ============================================
-
- @storefront_filters_key "storefront_filters"
-
- @doc """
- Gets storefront filter configuration from shop_config.
-
- Returns a list of filter definition maps with keys:
- key, type, label, enabled, position.
-
- Default: price filter only.
- """
- def get_storefront_filters do
- case repo().get(ShopConfig, @storefront_filters_key) do
- %ShopConfig{value: %{"filters" => filters}} when is_list(filters) ->
- filters
-
- _ ->
- default_storefront_filters()
- end
- end
-
- @doc """
- Returns only enabled storefront filters, sorted by position.
- """
- def get_enabled_storefront_filters do
- get_storefront_filters()
- |> Enum.filter(& &1["enabled"])
- |> Enum.sort_by(& &1["position"])
- end
-
- @doc """
- Saves storefront filter configuration.
- """
- def update_storefront_filters(filters) when is_list(filters) do
- value = %{"filters" => filters}
-
- case repo().get(ShopConfig, @storefront_filters_key) do
- nil ->
- %ShopConfig{}
- |> ShopConfig.changeset(%{key: @storefront_filters_key, value: value})
- |> repo().insert()
-
- config ->
- config
- |> ShopConfig.changeset(%{value: value})
- |> repo().update()
- end
- end
-
- @doc """
- Aggregates filter values for sidebar display.
-
- Returns a map of filter_key => aggregated data.
- For price_range: %{min: Decimal, max: Decimal}
- For vendor: [%{value: "Vendor", count: 5}, ...]
- For metadata_option: [%{value: "8 inches", count: 3}, ...]
-
- Options:
- - `:category_uuid` - Scope aggregation to a specific category by UUID
- """
- def aggregate_filter_values(opts \\ []) do
- filters = get_enabled_storefront_filters()
- category_uuid = Keyword.get(opts, :category_uuid)
-
- Enum.reduce(filters, %{}, fn filter, acc ->
- Map.put(acc, filter["key"], aggregate_single_filter(filter, category_uuid))
- end)
- end
-
- defp aggregate_single_filter(%{"type" => "price_range"}, category_uuid) do
- query =
- Product
- |> where([p], p.status == "active")
- |> maybe_filter_category(category_uuid)
-
- min_price = repo().aggregate(query, :min, :price)
- max_price = repo().aggregate(query, :max, :price)
- %{min: min_price, max: max_price}
- rescue
- _ -> %{min: nil, max: nil}
- end
-
- defp aggregate_single_filter(%{"type" => "vendor"}, category_uuid) do
- query =
- Product
- |> where([p], p.status == "active" and not is_nil(p.vendor) and p.vendor != "")
- |> maybe_filter_category(category_uuid)
- |> group_by([p], p.vendor)
- |> select([p], %{value: p.vendor, count: count(p.uuid)})
- |> order_by([p], desc: count(p.uuid))
-
- repo().all(query)
- rescue
- _ -> []
- end
-
- defp aggregate_single_filter(%{"type" => "metadata_option", "option_key" => key}, category_uuid)
- when is_binary(key) do
- # Query distinct option values from metadata->'_option_values'->key JSONB array
- sql = """
- SELECT val AS value, COUNT(DISTINCT p.uuid) AS count
- FROM phoenix_kit_shop_products p,
- jsonb_array_elements_text(COALESCE(p.metadata->'_option_values'->$1, '[]'::jsonb)) AS val
- WHERE p.status = 'active'
- #{if category_uuid, do: "AND p.category_uuid = $2", else: ""}
- GROUP BY val
- ORDER BY count DESC
- """
-
- params =
- if category_uuid do
- {:ok, uuid_bin} = Ecto.UUID.dump(category_uuid)
- [key, uuid_bin]
- else
- [key]
- end
-
- case repo().query(sql, params) do
- {:ok, %{rows: rows}} ->
- Enum.map(rows, fn [value, count] -> %{value: value, count: count} end)
-
- _ ->
- []
- end
- rescue
- _ -> []
- end
-
- defp aggregate_single_filter(_filter, _category_uuid), do: []
-
- defp maybe_filter_category(query, nil), do: query
- defp maybe_filter_category(query, uuid), do: where(query, [p], p.category_uuid == ^uuid)
-
- @doc """
- Discovers filterable option keys from product metadata.
-
- Returns a list of {key, product_count} tuples sorted by count descending.
- Used by admin UI to auto-suggest available filters.
- """
- def discover_filterable_options do
- sql = """
- SELECT key, COUNT(DISTINCT p.uuid) AS product_count
- FROM phoenix_kit_shop_products p,
- jsonb_object_keys(COALESCE(p.metadata->'_option_values', '{}'::jsonb)) AS key
- WHERE p.status = 'active'
- GROUP BY key
- ORDER BY product_count DESC
- """
-
- case repo().query(sql, []) do
- {:ok, %{rows: rows}} ->
- Enum.map(rows, fn [key, count] -> %{key: key, count: count} end)
-
- _ ->
- []
- end
- rescue
- _ -> []
- end
-
- @doc """
- Returns the default storefront filter configuration.
- """
- def default_storefront_filters do
- [
- %{
- "key" => "price",
- "type" => "price_range",
- "label" => "Price",
- "enabled" => true,
- "position" => 0
- },
- %{
- "key" => "vendor",
- "type" => "vendor",
- "label" => "Vendor",
- "enabled" => false,
- "position" => 1
- }
- ]
- end
-
- @doc """
- Gets a product by ID or UUID.
- """
- def get_product(id, opts \\ [])
-
- def get_product(id, opts) when is_binary(id) do
- if UUIDUtils.valid?(id) do
- Product
- |> where([p], p.uuid == ^id)
- |> maybe_preload(Keyword.get(opts, :preload))
- |> repo().one()
- else
- nil
- end
- end
-
- def get_product(_, _opts), do: nil
-
- @doc """
- Gets a product by ID or UUID, raises if not found.
- """
- def get_product!(id, opts \\ []) do
- case get_product(id, opts) do
- nil -> raise Ecto.NoResultsError, queryable: Product
- product -> product
- end
- end
-
- @doc """
- Gets a product by slug.
-
- Supports localized slugs stored as JSONB maps.
-
- ## Options
-
- - `:language` - Language code for slug lookup (default: system default)
- - `:preload` - Associations to preload
-
- ## Examples
-
- iex> get_product_by_slug("planter")
- %Product{}
-
- iex> get_product_by_slug("kashpo", language: "ru")
- %Product{}
- """
- def get_product_by_slug(slug, opts \\ []) do
- language = Keyword.get(opts, :language, Translations.default_language())
- preload = Keyword.get(opts, :preload, [])
-
- case SlugResolver.find_product_by_slug(slug, language, preload: preload) do
- {:ok, product} -> product
- {:error, :not_found} -> nil
- end
- end
-
- @doc """
- Creates a new product.
-
- Automatically normalizes metadata (price modifiers, option values)
- before saving to ensure consistent storage format.
- """
- def create_product(attrs) do
- attrs = MetadataValidator.normalize_product_attrs(attrs)
-
- result =
- %Product{}
- |> Product.changeset(attrs)
- |> repo().insert()
-
- case result do
- {:ok, product} ->
- Events.broadcast_product_created(product)
- {:ok, product}
-
- error ->
- error
- end
- end
-
- @doc """
- Updates a product.
-
- Automatically normalizes metadata (price modifiers, option values)
- before saving to ensure consistent storage format.
- """
- def update_product(%Product{} = product, attrs) do
- attrs = MetadataValidator.normalize_product_attrs(attrs)
-
- result =
- product
- |> Product.changeset(attrs)
- |> repo().update()
-
- case result do
- {:ok, updated_product} ->
- Events.broadcast_product_updated(updated_product)
- {:ok, updated_product}
-
- error ->
- error
- end
- end
-
- @doc """
- Deletes a product.
- """
- def delete_product(%Product{} = product) do
- product_uuid = product.uuid
-
- case repo().delete(product) do
- {:ok, _} = result ->
- Events.broadcast_product_deleted(product_uuid)
- result
-
- error ->
- error
- end
- end
-
- @doc """
- Returns a changeset for product form.
- """
- def change_product(%Product{} = product, attrs \\ %{}) do
- Product.changeset(product, attrs)
- end
-
- @doc """
- Bulk update product status.
- Returns count of updated products.
- """
- def bulk_update_product_status(ids, status) when is_list(ids) and is_binary(status) do
- query = Product |> where([p], p.uuid in ^ids)
-
- {count, _} =
- query
- |> repo().update_all(set: [status: status, updated_at: UtilsDate.utc_now()])
-
- if count > 0 do
- Events.broadcast_products_bulk_status_changed(ids, status)
- end
-
- count
- end
-
- @doc """
- Bulk update product category.
- Returns count of updated products.
- """
- def bulk_update_product_category(uuids, category_uuid) when is_list(uuids) do
- cat_uuid =
- if category_uuid do
- case repo().get_by(Category, uuid: category_uuid) do
- nil -> nil
- cat -> cat.uuid
- end
- else
- nil
- end
-
- # Don't unassign category if a specific category was requested but not found
- if category_uuid && is_nil(cat_uuid) do
- 0
- else
- query = Product |> where([p], p.uuid in ^uuids)
-
- {count, _} =
- query
- |> repo().update_all(
- set: [
- category_uuid: cat_uuid,
- updated_at: UtilsDate.utc_now()
- ]
- )
-
- count
- end
- end
-
- @doc """
- Bulk delete products.
- Returns count of deleted products.
- """
- def bulk_delete_products(ids) when is_list(ids) do
- query = Product |> where([p], p.uuid in ^ids)
-
- {count, _} = repo().delete_all(query)
-
- count
- end
-
- @doc """
- Collects all storage file UUIDs associated with a single product.
- """
- def collect_product_file_uuids(%Product{} = product) do
- [product.featured_image_uuid, product.file_uuid | product.image_uuids || []]
- |> Enum.reject(&is_nil/1)
- |> Enum.uniq()
- end
-
- @doc """
- Collects all storage file UUIDs for a list of product UUIDs.
- """
- def collect_products_file_uuids(product_uuids) when is_list(product_uuids) do
- from(p in Product,
- where: p.uuid in ^product_uuids,
- select: %{
- featured_image_uuid: p.featured_image_uuid,
- file_uuid: p.file_uuid,
- image_uuids: p.image_uuids
- }
- )
- |> repo().all()
- |> Enum.flat_map(fn p ->
- [p.featured_image_uuid, p.file_uuid | p.image_uuids || []]
- end)
- |> Enum.reject(&is_nil/1)
- |> Enum.uniq()
- end
-
- # ============================================
- # OPTIONS-BASED PRICING
- # ============================================
-
- @doc """
- Calculates the final price for a product based on selected specifications.
-
- Applies option price modifiers (fixed and percent) to the base price.
- Fixed modifiers are applied first, then percent modifiers.
-
- ## Example
-
- product = %Product{price: Decimal.new("20.00")}
- selected_specs = %{"material" => "PETG", "finish" => "Premium"}
-
- # If PETG has +$10 fixed and Premium has +20% percent:
- calculate_product_price(product, selected_specs)
- # => Decimal.new("36.00") # ($20 + $10) * 1.20
- """
- def calculate_product_price(%Product{} = product, selected_specs) when is_map(selected_specs) do
- base_price = product.price || Decimal.new("0")
- metadata = product.metadata || %{}
-
- # Get price-affecting options for this product
- price_affecting_specs = Options.get_price_affecting_specs_for_product(product)
-
- # Calculate final price with fixed and percent modifiers
- # Pass metadata to apply custom per-product price overrides
- Options.calculate_final_price(price_affecting_specs, selected_specs, base_price, metadata)
- end
-
- def calculate_product_price(%Product{} = product, _) do
- product.price || Decimal.new("0")
- end
-
- @doc """
- Gets the price range for a product based on option modifiers.
-
- Returns `{min_price, max_price}` where:
- - min_price = minimum possible price (base + min modifiers)
- - max_price = maximum possible price (base + max modifiers)
-
- ## Example
-
- # Product with base $20, material options (0, +5, +10), finish options (0%, +20%)
- get_price_range(product)
- # => {Decimal.new("20.00"), Decimal.new("36.00")}
- """
- def get_price_range(%Product{} = product) do
- base_price = product.price || Decimal.new("0")
- metadata = product.metadata || %{}
-
- # Get price-affecting options
- price_affecting_specs = Options.get_price_affecting_specs_for_product(product)
-
- if Enum.empty?(price_affecting_specs) do
- {base_price, base_price}
- else
- # Pass metadata to apply custom per-product price overrides
- Options.get_price_range(price_affecting_specs, base_price, metadata)
- end
- end
-
- @doc """
- Formats the product price for catalog display.
-
- Returns:
- - "$19.99" for products without price-affecting options
- - "From $19.99" if options have different price modifiers
- - "$19.99 - $38.00" for range display
- """
- def format_product_price(%Product{} = product, currency, style \\ :from) do
- {min_price, max_price} = get_price_range(product)
-
- format_fn = fn price ->
- case currency do
- %{} = c -> Currency.format_amount(price, c)
- nil -> "$#{Decimal.round(price, 2)}"
- end
- end
-
- if Decimal.compare(min_price, max_price) == :eq do
- format_fn.(min_price)
- else
- case style do
- :from -> "From #{format_fn.(min_price)}"
- :range -> "#{format_fn.(min_price)} - #{format_fn.(max_price)}"
- end
- end
- end
-
- @doc """
- Gets price-affecting options for a product.
-
- Convenience wrapper around `Options.get_price_affecting_specs_for_product/1`.
- """
- def get_price_affecting_specs(%Product{} = product) do
- Options.get_price_affecting_specs_for_product(product)
- end
-
- @doc """
- Gets all selectable options for a product (for UI display).
-
- Returns all select/multiselect options regardless of whether they affect price.
- This includes options like Color that may not have price modifiers but should
- still be selectable in the UI.
-
- Convenience wrapper around `Options.get_selectable_specs_for_product/1`.
- """
- def get_selectable_specs(%Product{} = product) do
- Options.get_selectable_specs_for_product(product)
- end
-
- # ============================================
- # CATEGORIES
- # ============================================
-
- @doc """
- Lists all categories.
-
- ## Options
- - `:parent_uuid` - Filter by parent UUID (nil for root categories)
- - `:status` - Filter by status: "active", "hidden", "archived", or list of statuses
- - `:search` - Search in name
- - `:preload` - Associations to preload
- """
- def list_categories(opts \\ []) do
- Category
- |> apply_category_filters(opts)
- |> order_by([c], [c.position, c.name])
- |> maybe_preload(Keyword.get(opts, :preload))
- |> repo().all()
- end
-
- @doc """
- Returns a map of category_uuid => product_count for all categories.
- """
- def product_counts_by_category do
- Product
- |> where([p], not is_nil(p.category_uuid))
- |> group_by([p], p.category_uuid)
- |> select([p], {p.category_uuid, count(p.uuid)})
- |> repo().all()
- |> Map.new()
- rescue
- e ->
- Logger.warning("Failed to load product counts by category: #{inspect(e)}")
- %{}
- end
-
- @doc """
- Lists root categories (no parent).
- """
- def list_root_categories(opts \\ []) do
- list_categories(Keyword.put(opts, :parent_uuid, nil))
- end
-
- @doc """
- Lists active categories only (for storefront display).
- """
- def list_active_categories(opts \\ []) do
- list_categories(Keyword.put(opts, :status, "active"))
- end
-
- @doc """
- Lists categories visible in storefront navigation/menu.
- Only active categories appear in menus.
- Semantic alias for list_active_categories/1.
- """
- def list_menu_categories(opts \\ []) do
- list_active_categories(opts)
- end
-
- @doc """
- Lists categories whose products are visible in storefront.
- Includes both active and unlisted categories.
- Use for product filtering, not for navigation menus.
- """
- def list_visible_categories(opts \\ []) do
- list_categories(Keyword.put(opts, :status, ["active", "unlisted"]))
- end
-
- @doc """
- Lists categories with count for pagination.
- """
- def list_categories_with_count(opts \\ []) do
- page = Keyword.get(opts, :page, 1)
- per_page = Keyword.get(opts, :per_page, 25)
- offset = (page - 1) * per_page
-
- base_query =
- Category
- |> apply_category_filters(opts)
-
- total = repo().aggregate(base_query, :count)
-
- categories =
- base_query
- |> order_by([c], [c.position, c.name])
- |> limit(^per_page)
- |> offset(^offset)
- |> maybe_preload(Keyword.get(opts, :preload))
- |> repo().all()
-
- {categories, total}
- end
-
- @doc """
- Gets a category by ID or UUID.
- """
- def get_category(id, opts \\ [])
-
- def get_category(id, opts) when is_binary(id) do
- if UUIDUtils.valid?(id) do
- Category
- |> where([c], c.uuid == ^id)
- |> maybe_preload(Keyword.get(opts, :preload))
- |> repo().one()
- else
- nil
- end
- end
-
- def get_category(_, _opts), do: nil
-
- @doc """
- Gets a category by ID or UUID, raises if not found.
- """
- def get_category!(id, opts \\ []) do
- case get_category(id, opts) do
- nil -> raise Ecto.NoResultsError, queryable: Category
- category -> category
- end
- end
-
- @doc """
- Gets a category by slug.
-
- Supports localized slugs stored as JSONB maps.
-
- ## Options
-
- - `:language` - Language code for slug lookup (default: system default)
- - `:preload` - Associations to preload
-
- ## Examples
-
- iex> get_category_by_slug("planters")
- %Category{}
-
- iex> get_category_by_slug("kashpo", language: "ru")
- %Category{}
- """
- def get_category_by_slug(slug, opts \\ []) do
- language = Keyword.get(opts, :language, Translations.default_language())
- preload = Keyword.get(opts, :preload, [])
-
- case SlugResolver.find_category_by_slug(slug, language, preload: preload) do
- {:ok, category} -> category
- {:error, :not_found} -> nil
- end
- end
-
- @doc """
- Creates a new category.
- """
- def create_category(attrs) do
- result =
- %Category{}
- |> Category.changeset(attrs)
- |> repo().insert()
-
- case result do
- {:ok, category} ->
- Events.broadcast_category_created(category)
- {:ok, category}
-
- error ->
- error
- end
- end
-
- @doc """
- Updates a category.
- """
- def update_category(%Category{} = category, attrs) do
- result =
- category
- |> Category.changeset(attrs)
- |> repo().update()
-
- case result do
- {:ok, updated_category} ->
- Events.broadcast_category_updated(updated_category)
- {:ok, updated_category}
-
- error ->
- error
- end
- end
-
- @doc """
- Lists categories that have no products assigned.
- """
- def list_empty_categories do
- subquery = from(p in Product, select: p.category_uuid, where: not is_nil(p.category_uuid))
-
- from(c in Category, where: c.uuid not in subquery(subquery))
- |> repo().all()
- end
-
- @doc """
- Deletes a category.
- """
- def delete_category(%Category{} = category) do
- category_uuid = category.uuid
-
- case repo().delete(category) do
- {:ok, _} = result ->
- Events.broadcast_category_deleted(category_uuid)
- result
-
- error ->
- error
- end
- end
-
- @doc """
- Returns a changeset for category form.
- """
- def change_category(%Category{} = category, attrs \\ %{}) do
- Category.changeset(category, attrs)
- end
-
- @doc """
- Bulk update category status.
- Returns count of updated categories.
- """
- def bulk_update_category_status(ids, status) when is_list(ids) and is_binary(status) do
- query = Category |> where([c], c.uuid in ^ids)
-
- {count, _} =
- query
- |> repo().update_all(set: [status: status, updated_at: UtilsDate.utc_now()])
-
- if count > 0 do
- Events.broadcast_categories_bulk_status_changed(ids, status)
- end
-
- count
- end
-
- @doc """
- Bulk update category parent.
- Returns count of updated categories. Excludes the target parent from the update set
- to prevent self-reference. Uses a single UPDATE with subquery to resolve parent_uuid.
- """
- def bulk_update_category_parent(ids, parent_uuid) when is_list(ids) do
- # Exclude the target parent and its ancestors from update set to prevent cycles
- ids_to_update =
- if parent_uuid do
- ancestors = collect_ancestor_uuids(parent_uuid, %{})
-
- Enum.reject(ids, &(&1 == parent_uuid or Map.has_key?(ancestors, &1)))
- else
- ids
- end
-
- if ids_to_update == [] do
- 0
- else
- now = UtilsDate.utc_now()
-
- {count, _} =
- if is_nil(parent_uuid) do
- # Make root — set parent to nil
- Category
- |> where([c], c.uuid in ^ids_to_update)
- |> repo().update_all(set: [parent_uuid: nil, updated_at: now])
- else
- # Set parent_uuid directly
- Category
- |> where([c], c.uuid in ^ids_to_update)
- |> repo().update_all(set: [parent_uuid: parent_uuid, updated_at: now])
- end
-
- if count > 0 do
- Events.broadcast_categories_bulk_parent_changed(ids_to_update, parent_uuid)
- end
-
- count
- end
- end
-
- defp collect_ancestor_uuids(nil, acc), do: acc
-
- defp collect_ancestor_uuids(uuid, acc) do
- if Map.has_key?(acc, uuid) do
- acc
- else
- case repo().get_by(Category, uuid: uuid) do
- nil -> acc
- %{parent_uuid: parent} -> collect_ancestor_uuids(parent, Map.put(acc, uuid, true))
- end
- end
- end
-
- @doc """
- Bulk delete categories.
- Returns count of deleted categories. Nullifies category references on orphaned products.
- """
- def bulk_delete_categories(ids) when is_list(ids) do
- # Nullify category references on products to prevent orphans
- orphan_query = Product |> where([p], p.category_uuid in ^ids)
-
- repo().update_all(orphan_query,
- set: [category_uuid: nil, updated_at: UtilsDate.utc_now()]
- )
-
- # Delete categories
- category_query = Category |> where([c], c.uuid in ^ids)
-
- {count, _} = repo().delete_all(category_query)
-
- if count > 0 do
- Events.broadcast_categories_bulk_deleted(ids)
- end
-
- count
- end
-
- @doc """
- Returns categories as options for select input.
- Returns list of {localized_name, id} tuples.
- """
- def category_options do
- default_lang = Translations.default_language()
-
- Category
- |> order_by([c], [c.position, c.name])
- |> repo().all()
- |> Enum.map(fn cat ->
- {Translations.get(cat, :name, default_lang), cat.uuid}
- end)
- end
-
- @doc """
- Ensures a category has a featured_product_uuid set.
-
- If the category has no image_uuid and no featured_product_uuid, auto-detects the
- first active product with an image and saves it. Returns the (possibly updated)
- category with :featured_product preloaded.
- """
- def ensure_featured_product(
- %Category{featured_product_uuid: nil, image_uuid: nil, uuid: cat_uuid} = cat
- ) do
- case find_default_featured_product(cat_uuid) do
- nil ->
- cat
-
- product_uuid ->
- {:ok, updated} =
- update_category(cat, %{
- featured_product_uuid: product_uuid
- })
-
- repo().preload(updated, :featured_product)
- end
- end
-
- def ensure_featured_product(cat), do: cat
-
- defp find_default_featured_product(category_uuid) do
- from(p in Product,
- where: p.category_uuid == ^category_uuid,
- where: p.status == "active",
- where:
- not is_nil(p.featured_image_uuid) or
- (not is_nil(p.featured_image) and p.featured_image != ""),
- order_by: [asc: p.inserted_at],
- limit: 1,
- select: p.uuid
- )
- |> repo().one()
- end
-
- @doc """
- Returns a list of {name, id} tuples for products in a category that have images.
- Used for the featured product dropdown in the admin category form.
- """
- def list_category_product_options(category_uuid) do
- default_lang = Translations.default_language()
-
- query = category_product_options_query(category_uuid)
-
- if query do
- query
- |> repo().all()
- |> Enum.map(fn {title_map, uuid} ->
- name =
- case title_map do
- %{} = map -> map[default_lang] || map |> Map.values() |> List.first()
- _ -> "Product #{uuid}"
- end
-
- {name, uuid}
- end)
- else
- []
- end
- end
-
- defp category_product_options_query(category_uuid) when is_binary(category_uuid) do
- if match?({:ok, _}, Ecto.UUID.cast(category_uuid)) do
- from(p in Product,
- where: p.category_uuid == ^category_uuid,
- where: p.status == "active",
- where:
- not is_nil(p.featured_image_uuid) or
- (not is_nil(p.featured_image) and p.featured_image != ""),
- order_by: [asc: p.uuid],
- select: {p.title, p.uuid}
- )
- end
- end
-
- defp category_product_options_query(_), do: nil
-
- # ============================================
- # SHIPPING METHODS
- # ============================================
-
- @doc """
- Lists all shipping methods.
-
- ## Options
- - `:active` - Filter by active status
- - `:country` - Filter by country availability
- """
- def list_shipping_methods(opts \\ []) do
- ShippingMethod
- |> filter_shipping_by_active(Keyword.get(opts, :active))
- |> order_by([s], [s.position, s.name])
- |> repo().all()
- end
-
- @doc """
- Gets available shipping methods for a cart.
- Filters by weight, subtotal, and country.
- """
- def get_available_shipping_methods(%Cart{} = cart) do
- ShippingMethod
- |> where([s], s.active == true)
- |> order_by([s], [s.position, s.name])
- |> repo().all()
- |> Enum.filter(fn method ->
- ShippingMethod.available_for?(method, %{
- weight_grams: cart.total_weight_grams || 0,
- subtotal: cart.subtotal || Decimal.new("0"),
- country: cart.shipping_country
- })
- end)
- end
-
- @doc """
- Gets a shipping method by ID or UUID.
- """
- def get_shipping_method(id) when is_binary(id) do
- if UUIDUtils.valid?(id) do
- repo().get_by(ShippingMethod, uuid: id)
- else
- nil
- end
- end
-
- def get_shipping_method(_), do: nil
-
- @doc """
- Gets a shipping method by ID or UUID, raises if not found.
- """
- def get_shipping_method!(id) do
- case get_shipping_method(id) do
- nil -> raise Ecto.NoResultsError, queryable: ShippingMethod
- method -> method
- end
- end
-
- @doc """
- Gets a shipping method by slug.
- """
- def get_shipping_method_by_slug(slug) do
- ShippingMethod
- |> where([s], s.slug == ^slug)
- |> repo().one()
- end
-
- @doc """
- Creates a new shipping method.
- """
- def create_shipping_method(attrs) do
- %ShippingMethod{}
- |> ShippingMethod.changeset(attrs)
- |> repo().insert()
- end
-
- @doc """
- Updates a shipping method.
- """
- def update_shipping_method(%ShippingMethod{} = method, attrs) do
- method
- |> ShippingMethod.changeset(attrs)
- |> repo().update()
- end
-
- @doc """
- Deletes a shipping method.
- """
- def delete_shipping_method(%ShippingMethod{} = method) do
- repo().delete(method)
- end
-
- @doc """
- Returns a changeset for shipping method form.
- """
- def change_shipping_method(%ShippingMethod{} = method, attrs \\ %{}) do
- ShippingMethod.changeset(method, attrs)
- end
-
- # ============================================
- # CARTS
- # ============================================
-
- @doc """
- Gets or creates a cart for the current user/session.
-
- ## Options
- - `:user_uuid` - User UUID (for authenticated users)
- - `:session_id` - Session ID (for guests)
- """
- def get_or_create_cart(opts) do
- user_uuid = Keyword.get(opts, :user_uuid)
- session_id = Keyword.get(opts, :session_id)
-
- case find_active_cart(user_uuid: user_uuid, session_id: session_id) do
- nil -> create_cart(user_uuid: user_uuid, session_id: session_id)
- cart -> {:ok, cart}
- end
- end
-
- @doc """
- Finds active cart by user_uuid or session_id.
-
- Search priority:
- 1. If user_uuid is provided, search by user_uuid first
- 2. If not found and session_id is provided, search by session_id (handles guest->login transition)
- 3. If only session_id is provided, search by session_id with no user_uuid
- """
- def find_active_cart(opts) do
- user_uuid = Keyword.get(opts, :user_uuid)
- session_id = Keyword.get(opts, :session_id)
-
- base_query =
- Cart
- |> where([c], c.status == "active")
- |> preload([:items, :shipping_method, :payment_option])
-
- cond do
- not is_nil(user_uuid) ->
- # First try to find by user_uuid
- case base_query |> where([c], c.user_uuid == ^user_uuid) |> repo().one() do
- nil when not is_nil(session_id) ->
- # Fallback: try session_id (cart created before login)
- base_query |> where([c], c.session_id == ^session_id) |> repo().one()
-
- result ->
- result
- end
-
- not is_nil(session_id) ->
- # Guest user - search by session_id only
- base_query
- |> where([c], c.session_id == ^session_id and is_nil(c.user_uuid))
- |> repo().one()
-
- true ->
- # No identity provided
- nil
- end
- end
-
- @doc """
- Creates a new cart.
- """
- def create_cart(opts) do
- attrs = %{
- user_uuid: Keyword.get(opts, :user_uuid),
- session_id: Keyword.get(opts, :session_id),
- currency: get_default_currency_code()
- }
-
- case %Cart{} |> Cart.changeset(attrs) |> repo().insert() do
- {:ok, cart} -> {:ok, repo().preload(cart, [:items, :shipping_method])}
- error -> error
- end
- end
-
- @doc """
- Gets a cart by ID or UUID with items preloaded.
- """
- def get_cart(uuid) when is_binary(uuid) do
- if UUIDUtils.valid?(uuid) do
- Cart
- |> where([c], c.uuid == ^uuid)
- |> preload([:items, :shipping_method, :payment_option])
- |> repo().one()
- else
- nil
- end
- end
-
- def get_cart(_), do: nil
-
- @doc """
- Gets a cart by ID or UUID, raises if not found.
- """
- def get_cart!(id) do
- case get_cart(id) do
- nil -> raise Ecto.NoResultsError, queryable: Cart
- cart -> cart
- end
- end
-
- @doc """
- Adds item to cart.
-
- ## Options
- - `:selected_specs` - Map of selected specifications (for dynamic pricing)
-
- ## Examples
-
- # Add simple product
- add_to_cart(cart, product, 2)
-
- # Add product with specification-based pricing
- add_to_cart(cart, product, 1, selected_specs: %{"material" => "PETG", "color" => "Gold"})
- """
- def add_to_cart(cart, product, quantity \\ 1, opts \\ [])
-
- def add_to_cart(%Cart{} = cart, %Product{} = product, quantity, opts) when is_list(opts) do
- selected_specs = Keyword.get(opts, :selected_specs, %{})
- skip_validation = Keyword.get(opts, :skip_spec_validation, false)
-
- # Validate selected_specs against product's option schema
- with :ok <- maybe_validate_specs(product, selected_specs, skip_validation) do
- if map_size(selected_specs) > 0 do
- add_product_with_specs_to_cart(cart, product, quantity, selected_specs)
- else
- add_simple_product_to_cart(cart, product, quantity)
- end
- end
- end
-
- def add_to_cart(%Cart{} = cart, %Product{} = product, quantity, _opts)
- when is_integer(quantity) do
- add_simple_product_to_cart(cart, product, quantity)
- end
-
- defp add_simple_product_to_cart(cart, product, quantity) do
- result =
- repo().transaction(fn ->
- # Lock product row to prevent price changes during cart update
- # This ensures price snapshot is consistent with current product state
- locked_product =
- Product
- |> where([p], p.uuid == ^product.uuid)
- |> lock("FOR UPDATE")
- |> repo().one!()
-
- # Use unified price calculation path (same as add_product_with_specs_to_cart)
- # With empty specs this returns base_price, but allows future extensibility
- calculated_price = calculate_product_price(locked_product, %{})
-
- # Check if product already in cart (without specs)
- existing = find_cart_item_by_specs(cart.uuid, product.uuid, %{})
-
- item =
- case existing do
- nil ->
- # Create new item with calculated price
- attrs =
- CartItem.from_product(locked_product, quantity)
- |> Map.put(:cart_uuid, cart.uuid)
- |> Map.put(:unit_price, calculated_price)
-
- %CartItem{} |> CartItem.changeset(attrs) |> repo().insert!()
-
- item ->
- # Update quantity
- new_qty = item.quantity + quantity
- item |> CartItem.changeset(%{quantity: new_qty}) |> repo().update!()
- end
-
- # Recalculate totals
- updated_cart = recalculate_cart_totals!(cart)
- {updated_cart, item}
- end)
-
- case result do
- {:ok, {updated_cart, item}} ->
- Events.broadcast_item_added(updated_cart, item)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- defp add_product_with_specs_to_cart(cart, product, quantity, selected_specs) do
- result =
- repo().transaction(fn ->
- # Lock product row to prevent price/metadata changes during cart update
- locked_product =
- Product
- |> where([p], p.uuid == ^product.uuid)
- |> lock("FOR UPDATE")
- |> repo().one!()
-
- # Calculate price with spec modifiers using locked product state
- calculated_price = calculate_product_price(locked_product, selected_specs)
-
- # Check if same product with same specs already in cart
- existing = find_cart_item_by_specs(cart.uuid, product.uuid, selected_specs)
-
- item =
- case existing do
- nil ->
- # Create new item with specs and calculated price
- attrs =
- CartItem.from_product(locked_product, quantity)
- |> Map.put(:cart_uuid, cart.uuid)
- |> Map.put(:unit_price, calculated_price)
- |> Map.put(:selected_specs, selected_specs)
-
- %CartItem{} |> CartItem.changeset(attrs) |> repo().insert!()
-
- item ->
- # Update quantity (price already frozen from first add)
- new_qty = item.quantity + quantity
- item |> CartItem.changeset(%{quantity: new_qty}) |> repo().update!()
- end
-
- # Recalculate totals
- updated_cart = recalculate_cart_totals!(cart)
- {updated_cart, item}
- end)
-
- case result do
- {:ok, {updated_cart, item}} ->
- Events.broadcast_item_added(updated_cart, item)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- # ============================================
- # SELECTED SPECS VALIDATION
- # ============================================
-
- defp maybe_validate_specs(_product, _specs, true), do: :ok
- defp maybe_validate_specs(_product, specs, _skip) when specs == %{}, do: :ok
-
- defp maybe_validate_specs(product, selected_specs, _skip) do
- validate_selected_specs(product, selected_specs)
- end
-
- @doc """
- Validates selected_specs against product's option schema.
-
- Checks:
- - All spec keys exist in the option schema
- - All spec values are in allowed values list (if defined)
- - All required options have values
-
- ## Returns
-
- - `:ok` - All specs are valid
- - `{:error, :unknown_option_key, key}` - Key not in schema
- - `{:error, :invalid_option_value, %{key: key, value: value, allowed: list}}` - Value not allowed
- - `{:error, :missing_required_option, key}` - Required option not provided
-
- ## Examples
-
- iex> validate_selected_specs(product, %{"material" => "PETG"})
- :ok
-
- iex> validate_selected_specs(product, %{"material" => "Unobtainium"})
- {:error, :invalid_option_value, %{key: "material", value: "Unobtainium", allowed: ["PLA", "PETG"]}}
- """
- def validate_selected_specs(%Product{} = product, selected_specs) when is_map(selected_specs) do
- # Use full selectable specs (includes discovered options from metadata)
- # to match what the UI actually shows to users
- schema = Options.get_selectable_specs_for_product(product)
-
- # Build lookup map: key => option definition
- schema_map = Map.new(schema, fn opt -> {opt["key"], opt} end)
-
- # Check all provided keys exist and values are valid
- with :ok <- validate_spec_keys(selected_specs, schema_map),
- :ok <- validate_spec_values(selected_specs, schema_map) do
- validate_required_options(selected_specs, schema)
- end
- end
-
- def validate_selected_specs(_product, _specs), do: :ok
-
- # Validate that all provided keys exist in schema
- defp validate_spec_keys(selected_specs, schema_map) do
- invalid_key =
- Enum.find(Map.keys(selected_specs), fn key ->
- not Map.has_key?(schema_map, key)
- end)
-
- if invalid_key do
- {:error, :unknown_option_key, invalid_key}
- else
- :ok
- end
- end
-
- # Validate that all values are in allowed list (if options defined)
- defp validate_spec_values(selected_specs, schema_map) do
- invalid =
- Enum.find(selected_specs, fn {key, value} ->
- opt = Map.get(schema_map, key)
- allowed_values = opt["options"]
-
- # Only validate if options list is defined and non-empty
- if is_list(allowed_values) and allowed_values != [] do
- value not in allowed_values
- else
- false
- end
- end)
-
- case invalid do
- nil ->
- :ok
-
- {key, value} ->
- opt = Map.get(schema_map, key)
- {:error, :invalid_option_value, %{key: key, value: value, allowed: opt["options"]}}
- end
- end
-
- # Validate that all required options have values
- defp validate_required_options(selected_specs, schema) do
- missing =
- Enum.find(schema, fn opt ->
- required = opt["required"] == true
- key = opt["key"]
-
- required and not Map.has_key?(selected_specs, key)
- end)
-
- if missing do
- {:error, :missing_required_option, missing["key"]}
- else
- :ok
- end
- end
-
- @doc """
- Updates item quantity in cart.
- """
- def update_cart_item(%CartItem{} = item, quantity) when quantity > 0 do
- result =
- repo().transaction(fn ->
- updated_item =
- item
- |> CartItem.changeset(%{quantity: quantity})
- |> repo().update!()
-
- cart = repo().get_by!(Cart, uuid: item.cart_uuid)
-
- updated_cart = recalculate_cart_totals!(cart)
- {updated_cart, updated_item}
- end)
-
- case result do
- {:ok, {updated_cart, updated_item}} ->
- Events.broadcast_quantity_updated(updated_cart, updated_item)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- def update_cart_item(%CartItem{} = item, 0), do: remove_from_cart(item)
-
- @doc """
- Removes item from cart.
- """
- def remove_from_cart(%CartItem{} = item) do
- item_uuid = item.uuid
-
- result =
- repo().transaction(fn ->
- cart_uuid = item.cart_uuid
- repo().delete!(item)
-
- cart = repo().get_by!(Cart, uuid: cart_uuid)
-
- recalculate_cart_totals!(cart)
- end)
-
- case result do
- {:ok, updated_cart} ->
- Events.broadcast_item_removed(updated_cart, item_uuid)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- @doc """
- Clears all items from cart.
- """
- def clear_cart(%Cart{} = cart) do
- result =
- repo().transaction(fn ->
- CartItem
- |> where([i], i.cart_uuid == ^cart.uuid)
- |> repo().delete_all()
-
- recalculate_cart_totals!(cart)
- end)
-
- case result do
- {:ok, updated_cart} ->
- Events.broadcast_cart_cleared(updated_cart)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- @doc """
- Sets the shipping country for the cart.
- """
- def set_cart_shipping_country(%Cart{} = cart, country) do
- cart
- |> Cart.shipping_changeset(%{shipping_country: country})
- |> repo().update()
- end
-
- @doc """
- Sets shipping method for cart.
- """
- def set_cart_shipping(%Cart{} = cart, %ShippingMethod{} = method, country) do
- shipping_cost = ShippingMethod.calculate_cost(method, cart.subtotal || Decimal.new("0"))
-
- result =
- repo().transaction(fn ->
- updated_cart =
- cart
- |> Cart.shipping_changeset(%{
- shipping_method_uuid: method.uuid,
- shipping_country: country,
- shipping_amount: shipping_cost
- })
- |> repo().update!()
-
- recalculate_cart_totals!(updated_cart)
- end)
-
- case result do
- {:ok, updated_cart} ->
- Events.broadcast_shipping_selected(updated_cart)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- @doc """
- Sets payment option for cart.
- """
- def set_cart_payment_option(%Cart{} = cart, %PaymentOption{} = option) do
- result =
- cart
- |> Cart.payment_changeset(%{
- payment_option_uuid: option.uuid
- })
- |> repo().update()
-
- case result do
- {:ok, updated_cart} ->
- Events.broadcast_payment_selected(updated_cart)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- def set_cart_payment_option(%Cart{} = cart, payment_option_uuid)
- when is_binary(payment_option_uuid) do
- case Billing.get_payment_option(payment_option_uuid) do
- nil ->
- {:error, :payment_option_not_found}
-
- option ->
- set_cart_payment_option(cart, option)
- end
- end
-
- def set_cart_payment_option(%Cart{} = cart, nil) do
- result =
- cart
- |> Cart.payment_changeset(%{payment_option_uuid: nil})
- |> repo().update()
-
- case result do
- {:ok, updated_cart} ->
- Events.broadcast_payment_selected(updated_cart)
- {:ok, updated_cart}
-
- error ->
- error
- end
- end
-
- @doc """
- Auto-selects payment option if only one is available.
-
- If cart already has a payment option selected, does nothing.
- If only one option is available, selects it.
- """
- def auto_select_payment_option(%Cart{} = cart, payment_options) do
- cond do
- # Already has payment option selected
- not is_nil(cart.payment_option_uuid) ->
- {:ok, cart}
-
- # No options available
- payment_options == [] ->
- {:ok, cart}
-
- # Only one option available - auto-select it
- length(payment_options) == 1 ->
- option = hd(payment_options)
- set_cart_payment_option(cart, option)
-
- # Multiple options - user must choose
- true ->
- {:ok, cart}
- end
- end
-
- @doc """
- Auto-selects the cheapest available shipping method for a cart.
-
- If cart already has a shipping method selected, does nothing.
- If only one method is available, selects it.
- If multiple methods are available, selects the cheapest one.
- """
- def auto_select_shipping_method(%Cart{} = cart, shipping_methods) do
- cond do
- # Already has shipping method selected
- not is_nil(cart.shipping_method_uuid) ->
- {:ok, cart}
-
- # No items in cart
- cart.items == [] or is_nil(cart.items) ->
- {:ok, cart}
-
- # No shipping methods available
- shipping_methods == [] ->
- {:ok, cart}
-
- # One or more methods available - select cheapest
- true ->
- cheapest = find_cheapest_shipping_method(shipping_methods, cart.subtotal)
- set_cart_shipping(cart, cheapest, nil)
- end
- end
-
- defp find_cheapest_shipping_method(methods, subtotal) do
- subtotal = subtotal || Decimal.new("0")
-
- methods
- |> Enum.min_by(fn method ->
- if ShippingMethod.free_for?(method, subtotal) do
- Decimal.new("0")
- else
- method.price || Decimal.new("999999")
- end
- end)
- end
-
- @doc """
- Merges guest cart into user cart after login.
- Accepts a user struct or user_uuid (string).
- """
- def merge_guest_cart(session_id, %{uuid: user_uuid}) do
- do_merge_guest_cart(session_id, user_uuid)
- end
-
- def merge_guest_cart(session_id, user_uuid) when is_binary(user_uuid) do
- do_merge_guest_cart(session_id, user_uuid)
- end
-
- defp do_merge_guest_cart(session_id, user_uuid) do
- guest_cart = find_active_cart(session_id: session_id)
- user_cart = find_active_cart(user_uuid: user_uuid)
-
- case {guest_cart, user_cart} do
- {nil, _} ->
- {:ok, user_cart}
-
- {guest, nil} ->
- # Convert guest cart to user cart
- guest
- |> Cart.changeset(%{
- user_uuid: user_uuid,
- session_id: nil,
- expires_at: nil
- })
- |> repo().update()
-
- {guest, user} ->
- # Merge items into user cart
- do_merge_guest_cart_items(guest, user)
- end
- end
-
- defp do_merge_guest_cart_items(guest, user) do
- repo().transaction(fn ->
- # Move items from guest to user cart
- Enum.each(guest.items, fn item ->
- merge_cart_item(user, item)
- end)
-
- # Mark guest cart as merged
- guest
- |> Cart.status_changeset("merged", %{
- merged_into_cart_uuid: user.uuid
- })
- |> repo().update!()
-
- # Recalculate user cart
- recalculate_cart_totals!(user)
-
- repo().get_by!(Cart, uuid: user.uuid)
- |> repo().preload([:items, :shipping_method, :payment_option])
- end)
- end
-
- defp merge_cart_item(user_cart, item) do
- existing =
- find_cart_item_by_specs(user_cart.uuid, item.product_uuid, item.selected_specs || %{})
-
- case existing do
- nil ->
- attrs =
- Map.from_struct(item)
- |> Map.drop([:__meta__, :id, :uuid, :cart, :product, :inserted_at, :updated_at])
- |> Map.put(:cart_uuid, user_cart.uuid)
-
- %CartItem{}
- |> CartItem.changeset(attrs)
- |> repo().insert!()
-
- existing_item ->
- new_qty = existing_item.quantity + item.quantity
- existing_item |> CartItem.changeset(%{quantity: new_qty}) |> repo().update!()
- end
- end
-
- @doc """
- Lists carts with filters for admin.
- """
- def list_carts_with_count(opts \\ []) do
- page = Keyword.get(opts, :page, 1)
- per_page = Keyword.get(opts, :per_page, 25)
- offset = (page - 1) * per_page
- status = Keyword.get(opts, :status)
- search = Keyword.get(opts, :search)
-
- base_query = Cart
-
- base_query =
- if status && status != "" do
- where(base_query, [c], c.status == ^status)
- else
- base_query
- end
-
- base_query =
- if search && search != "" do
- search_term = "%#{search}%"
-
- base_query
- |> join(:left, [c], u in assoc(c, :user))
- |> where([c, u], ilike(u.email, ^search_term) or c.session_id == ^search)
- else
- base_query
- end
-
- total = repo().aggregate(base_query, :count)
-
- carts =
- base_query
- |> order_by([c], desc: c.updated_at)
- |> limit(^per_page)
- |> offset(^offset)
- |> preload([:user, :items])
- |> repo().all()
-
- {carts, total}
- end
-
- @doc """
- Marks abandoned carts (no activity for X days).
- """
- def mark_abandoned_carts(days \\ 7) do
- threshold = UtilsDate.utc_now() |> DateTime.add(-days, :day)
-
- {count, _} =
- Cart
- |> where([c], c.status == "active")
- |> where([c], c.updated_at < ^threshold)
- |> repo().update_all(set: [status: "abandoned"])
-
- {:ok, count}
- end
-
- @doc """
- Expires old guest carts.
- """
- def expire_old_carts do
- now = UtilsDate.utc_now()
-
- {count, _} =
- Cart
- |> where([c], c.status == "active")
- |> where([c], not is_nil(c.expires_at))
- |> where([c], c.expires_at < ^now)
- |> repo().update_all(set: [status: "expired"])
-
- {:ok, count}
- end
-
- @doc """
- Counts active carts.
- """
- def count_active_carts do
- Cart
- |> where([c], c.status == "active")
- |> repo().aggregate(:count)
- rescue
- _ -> 0
- end
-
- # ============================================
- # CHECKOUT / ORDER CONVERSION
- # ============================================
-
- @doc """
- Converts a cart to a Billing.Order.
-
- Takes an active cart with items and creates an Order with:
- - All cart items as line_items
- - Shipping as additional line item (if selected)
- - Billing profile snapshot (from profile_uuid or direct billing_data)
- - Cart marked as "converted"
-
- For guest checkout (no user_uuid on cart):
- - Creates a guest user via `Auth.create_guest_user/1`
- - Guest user has `confirmed_at = nil` until email verification
- - Sends confirmation email automatically
- - Order remains in "pending" status
-
- ## Options
-
- - `billing_profile_uuid: uuid` - Use existing billing profile (for logged-in users)
- - `billing_data: map` - Use direct billing data (for guest checkout)
-
- ## Returns
-
- - `{:ok, order}` - Order created successfully
- - `{:error, :cart_not_active}` - Cart is not active
- - `{:error, :cart_empty}` - Cart has no items
- - `{:error, :no_shipping_method}` - No shipping method selected
- - `{:error, :email_already_registered}` - Guest email belongs to confirmed user
- - `{:error, changeset}` - Validation errors
- """
- def convert_cart_to_order(%Cart{} = cart, opts) when is_list(opts) do
- cart = get_cart!(cart.uuid)
-
- # Wrap entire conversion in a transaction to ensure atomicity
- # If any step fails after order creation, the order is rolled back
- repo().transaction(fn ->
- # Use atomic status transition to prevent double-conversion on double-click
- # This atomically changes status from "active" to "converting" and fails
- # if another request already started conversion
- with :ok <- validate_cart_convertible(cart),
- {:ok, cart} <- try_lock_cart_for_conversion(cart),
- {:ok, user_uuid, cart} <- resolve_checkout_user(cart, opts),
- line_items <- build_order_line_items(cart),
- order_attrs <- build_order_attrs(cart, line_items, opts),
- {:ok, order} <- do_create_order(user_uuid, order_attrs),
- {:ok, _cart} <- mark_cart_converted(cart, order.uuid),
- :ok <- maybe_send_guest_confirmation(user_uuid) do
- {:ok, order}
- else
- {:error, reason} ->
- # Rollback transaction on any error, unwrapping the {:error, _} tuple
- # so the transaction returns {:error, reason} (not {:error, {:error, reason}})
- repo().rollback(reason)
-
- other ->
- repo().rollback(other)
- end
- end)
- # unwrap the transaction result
- |> case do
- {:ok, {:ok, order}} -> {:ok, order}
- {:error, reason} -> {:error, reason}
- end
- end
-
- defp validate_cart_convertible(%Cart{} = cart) do
- cond do
- cart.status != "active" ->
- {:error, :cart_not_active}
-
- Enum.empty?(cart.items) ->
- {:error, :cart_empty}
-
- is_nil(cart.shipping_method_uuid) ->
- {:error, :no_shipping_method}
-
- true ->
- :ok
- end
- end
-
- defp build_order_line_items(%Cart{} = cart) do
- product_items =
- Enum.map(cart.items, fn item ->
- %{
- "name" => item.product_title,
- "description" => format_item_description(item),
- "selected_specs" => item.selected_specs || %{},
- "quantity" => item.quantity,
- "unit_price" => Decimal.to_string(item.unit_price),
- "total" => Decimal.to_string(item.line_total),
- "sku" => item.product_sku,
- "type" => "product"
- }
- end)
-
- shipping_item =
- if cart.shipping_method do
- [
- %{
- "name" => "Shipping: #{cart.shipping_method.name}",
- "description" => cart.shipping_method.description || "",
- "quantity" => 1,
- "unit_price" => Decimal.to_string(cart.shipping_amount || Decimal.new(0)),
- "total" => Decimal.to_string(cart.shipping_amount || Decimal.new(0)),
- "type" => "shipping"
- }
- ]
- else
- []
- end
-
- product_items ++ shipping_item
- end
-
- defp build_order_attrs(%Cart{} = cart, line_items, opts) do
- billing_profile_uuid = Keyword.get(opts, :billing_profile_uuid)
- billing_data = Keyword.get(opts, :billing_data)
-
- # Get shipping country from billing data or cart
- shipping_country = get_shipping_country(billing_profile_uuid, billing_data, cart)
-
- # Use string keys to match Billing.maybe_set_order_number behavior
- base_attrs = %{
- "currency" => cart.currency,
- "line_items" => line_items,
- "subtotal" => cart.subtotal,
- "tax_amount" => cart.tax_amount || Decimal.new(0),
- "tax_rate" => Decimal.new(0),
- "discount_amount" => cart.discount_amount || Decimal.new(0),
- "discount_code" => cart.discount_code,
- "total" => cart.total,
- "status" => "pending",
- "metadata" => %{
- "source" => "shop_checkout",
- "cart_uuid" => cart.uuid,
- "shipping_country" => shipping_country,
- "shipping_method_uuid" => cart.shipping_method_uuid
- }
- }
-
- cond do
- # Logged-in user with billing profile
- not is_nil(billing_profile_uuid) ->
- Map.put(base_attrs, "billing_profile_uuid", billing_profile_uuid)
-
- # Guest checkout with billing data - clean up _unused_ keys from LiveView
- is_map(billing_data) ->
- cleaned_billing_data = clean_billing_data(billing_data)
- Map.put(base_attrs, "billing_snapshot", cleaned_billing_data)
-
- true ->
- base_attrs
- end
- end
-
- # Get shipping country from billing profile, billing data, or cart
- defp get_shipping_country(billing_profile_uuid, _billing_data, cart)
- when not is_nil(billing_profile_uuid) do
- case Billing.get_billing_profile(billing_profile_uuid) do
- %{country: country} when is_binary(country) -> country
- _ -> cart.shipping_country
- end
- end
-
- defp get_shipping_country(_billing_profile_uuid, billing_data, cart)
- when is_map(billing_data) do
- billing_data["country"] || cart.shipping_country
- end
-
- defp get_shipping_country(_billing_profile_uuid, _billing_data, cart) do
- cart.shipping_country
- end
-
- # Remove _unused_ prefixed keys that Phoenix LiveView adds
- defp clean_billing_data(data) when is_map(data) do
- data
- |> Enum.reject(fn {key, _value} ->
- key_str = if is_atom(key), do: Atom.to_string(key), else: key
- String.starts_with?(key_str, "_unused_")
- end)
- |> Map.new()
- end
-
- # Resolve user for checkout: logged-in user or create guest user
- defp resolve_checkout_user(%Cart{user_uuid: user_uuid} = cart, _opts)
- when not is_nil(user_uuid) do
- # Cart already has a user (logged-in checkout)
- {:ok, user_uuid, cart}
- end
-
- defp resolve_checkout_user(%Cart{user_uuid: nil} = cart, opts) do
- # Check if logged-in user_uuid was passed in opts (user is logged in but has guest cart)
- case Keyword.get(opts, :user_uuid) do
- user_uuid when not is_nil(user_uuid) ->
- resolve_logged_in_user_with_guest_cart(cart, user_uuid)
-
- nil ->
- resolve_guest_checkout(cart, opts)
- end
- end
-
- defp resolve_logged_in_user_with_guest_cart(cart, user_uuid) do
- user = Auth.get_user(user_uuid)
-
- case user && assign_cart_to_user(cart, user) do
- {:ok, updated_cart} -> {:ok, user_uuid, updated_cart}
- _ -> {:ok, user_uuid, cart}
- end
- end
-
- defp resolve_guest_checkout(cart, opts) do
- billing_data = Keyword.get(opts, :billing_data)
-
- if valid_billing_data?(billing_data) do
- create_guest_user_and_assign_cart(cart, billing_data)
- else
- {:ok, nil, cart}
- end
- end
-
- defp valid_billing_data?(data), do: is_map(data) and Map.has_key?(data, "email")
-
- defp create_guest_user_and_assign_cart(cart, billing_data) do
- case Auth.create_guest_user(%{
- email: billing_data["email"],
- first_name: billing_data["first_name"],
- last_name: billing_data["last_name"]
- }) do
- {:ok, user} ->
- assign_cart_and_return(cart, user)
-
- {:error, :email_exists_unconfirmed, user} ->
- assign_cart_and_return(cart, user)
-
- {:error, :email_exists_confirmed} ->
- {:error, :email_already_registered}
-
- {:error, changeset} ->
- {:error, changeset}
- end
- end
-
- defp assign_cart_and_return(cart, %{uuid: user_uuid} = user) do
- case assign_cart_to_user(cart, user) do
- {:ok, updated_cart} -> {:ok, user_uuid, updated_cart}
- {:error, _} -> {:ok, user_uuid, cart}
- end
- end
-
- # Assign cart to user (for guest -> user conversion)
- defp assign_cart_to_user(%Cart{} = cart, %{uuid: user_uuid}) do
- cart
- |> Cart.changeset(%{user_uuid: user_uuid, session_id: nil})
- |> repo().update()
- end
-
- # Create order with or without user
- defp do_create_order(nil, order_attrs) do
- Billing.create_order(order_attrs)
- end
-
- defp do_create_order(user_uuid, order_attrs) do
- Billing.create_order(user_uuid, order_attrs)
- end
-
- # Send confirmation email to guest users
- defp maybe_send_guest_confirmation(nil), do: :ok
-
- defp maybe_send_guest_confirmation(user_uuid) do
- case Auth.get_user(user_uuid) do
- %{confirmed_at: nil} = user ->
- # Guest user - send confirmation email
- Auth.deliver_user_confirmation_instructions(
- user,
- &Routes.url("/users/confirm/#{&1}")
- )
-
- :ok
-
- _ ->
- # Already confirmed user - no action needed
- :ok
- end
- end
-
- # Atomically transition cart from "active" to "converting" status.
- # This prevents double-conversion when user double-clicks checkout button.
- # If another request already started conversion, this returns error.
- defp try_lock_cart_for_conversion(%Cart{uuid: cart_uuid}) do
- # Use atomic UPDATE with WHERE clause to ensure only one request wins
- {count, _} =
- Cart
- |> where([c], c.uuid == ^cart_uuid and c.status == "active")
- |> repo().update_all(set: [status: "converting", updated_at: UtilsDate.utc_now()])
-
- if count == 1 do
- # Successfully locked - reload cart with new status
- {:ok, get_cart!(cart_uuid)}
- else
- # Another request already started conversion
- {:error, :cart_already_converting}
- end
- end
-
- defp mark_cart_converted(%Cart{} = cart, order_uuid) do
- cart
- |> Cart.status_changeset("converted", %{
- converted_at: UtilsDate.utc_now(),
- metadata: Map.put(cart.metadata || %{}, "order_uuid", order_uuid)
- })
- |> repo().update()
- end
-
- # ============================================
- # PRIVATE HELPERS
- # ============================================
-
- # Format cart item description including selected_specs
- defp format_item_description(%CartItem{product_slug: slug, selected_specs: specs})
- when specs == %{} or is_nil(specs) do
- slug
- end
-
- defp format_item_description(%CartItem{product_slug: slug, selected_specs: specs}) do
- specs_text =
- Enum.map_join(specs, ", ", fn {key, value} -> "#{humanize_key(key)}: #{value}" end)
-
- "#{slug} (#{specs_text})"
- end
-
- # Convert key to human-readable format: "material_type" -> "Material Type"
- defp humanize_key(key) when is_binary(key) do
- key
- |> String.replace("_", " ")
- |> String.split(" ")
- |> Enum.map_join(" ", &String.capitalize/1)
- end
-
- defp humanize_key(key), do: to_string(key)
-
- defp count_products do
- Product |> repo().aggregate(:count)
- rescue
- _ -> 0
- end
-
- defp count_products_by_status(status) do
- Product
- |> where([p], p.status == ^status)
- |> repo().aggregate(:count)
- rescue
- _ -> 0
- end
-
- defp count_products_by_type(product_type) do
- Product
- |> where([p], p.product_type == ^product_type)
- |> repo().aggregate(:count)
- rescue
- _ -> 0
- end
-
- defp count_categories do
- Category |> repo().aggregate(:count)
- rescue
- _ -> 0
- end
-
- defp apply_product_filters(query, opts) do
- query
- |> filter_by_status(Keyword.get(opts, :status))
- |> filter_by_product_type(Keyword.get(opts, :product_type))
- |> filter_by_category(Keyword.get(opts, :category_uuid))
- |> filter_by_product_search(Keyword.get(opts, :search))
- |> filter_by_visible_categories(Keyword.get(opts, :exclude_hidden_categories, false))
- |> filter_by_price_range(Keyword.get(opts, :price_min), Keyword.get(opts, :price_max))
- |> filter_by_vendors(Keyword.get(opts, :vendors))
- |> filter_by_metadata_options(Keyword.get(opts, :metadata_filters))
- end
-
- defp filter_by_status(query, nil), do: query
- defp filter_by_status(query, status), do: where(query, [p], p.status == ^status)
-
- defp filter_by_product_type(query, nil), do: query
- defp filter_by_product_type(query, type), do: where(query, [p], p.product_type == ^type)
-
- defp filter_by_category(query, nil), do: query
-
- defp filter_by_category(query, uuid) when is_binary(uuid) do
- if UUIDUtils.valid?(uuid) do
- where(query, [p], p.category_uuid == ^uuid)
- else
- query
- end
- end
-
- defp filter_by_visible_categories(query, false), do: query
-
- defp filter_by_visible_categories(query, true) do
- # Exclude products from categories with status "hidden"
- # Products from "active" and "unlisted" categories are visible
- # Use distinct to avoid duplicates from the left_join
- from(p in query,
- left_join: c in Category,
- on: c.uuid == p.category_uuid,
- where: is_nil(c.uuid) or c.status != "hidden",
- distinct: p.uuid
- )
- end
-
- defp filter_by_price_range(query, nil, nil), do: query
- defp filter_by_price_range(query, min, nil), do: where(query, [p], p.price >= ^min)
- defp filter_by_price_range(query, nil, max), do: where(query, [p], p.price <= ^max)
-
- defp filter_by_price_range(query, min, max),
- do: where(query, [p], p.price >= ^min and p.price <= ^max)
-
- defp filter_by_vendors(query, nil), do: query
- defp filter_by_vendors(query, []), do: query
-
- defp filter_by_vendors(query, vendors) when is_list(vendors),
- do: where(query, [p], p.vendor in ^vendors)
-
- defp filter_by_metadata_options(query, nil), do: query
- defp filter_by_metadata_options(query, []), do: query
-
- defp filter_by_metadata_options(query, filters) when is_list(filters) do
- Enum.reduce(filters, query, fn %{key: key, values: values}, q ->
- where(
- q,
- [p],
- fragment(
- "EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(?->'_option_values'->?, '[]'::jsonb)) elem WHERE elem = ANY(?))",
- p.metadata,
- ^key,
- ^values
- )
- )
- end)
- end
-
- defp filter_by_product_search(query, nil), do: query
- defp filter_by_product_search(query, ""), do: query
-
- defp filter_by_product_search(query, search) do
- search_term = "%#{search}%"
- default_lang = Translations.default_language()
-
- # Search in JSONB localized fields using PostgreSQL operators
- # Searches in default language and falls back to any language match
- where(
- query,
- [p],
- fragment(
- "(COALESCE(title->>?, '') ILIKE ? OR COALESCE(description->>?, '') ILIKE ? OR EXISTS (SELECT 1 FROM jsonb_each_text(title) WHERE value ILIKE ?) OR EXISTS (SELECT 1 FROM jsonb_each_text(description) WHERE value ILIKE ?))",
- ^default_lang,
- ^search_term,
- ^default_lang,
- ^search_term,
- ^search_term,
- ^search_term
- )
- )
- end
-
- defp apply_category_filters(query, opts) do
- query
- |> filter_by_parent_uuid(Keyword.get(opts, :parent_uuid, :skip))
- |> filter_by_category_status(Keyword.get(opts, :status, :skip))
- |> filter_by_category_search(Keyword.get(opts, :search))
- end
-
- defp filter_by_parent_uuid(query, :skip), do: query
- defp filter_by_parent_uuid(query, nil), do: where(query, [c], is_nil(c.parent_uuid))
- defp filter_by_parent_uuid(query, uuid), do: where(query, [c], c.parent_uuid == ^uuid)
-
- defp filter_by_category_status(query, :skip), do: query
- defp filter_by_category_status(query, nil), do: query
-
- defp filter_by_category_status(query, status) when is_binary(status) do
- where(query, [c], c.status == ^status)
- end
-
- defp filter_by_category_status(query, statuses) when is_list(statuses) do
- where(query, [c], c.status in ^statuses)
- end
-
- defp filter_by_category_search(query, nil), do: query
- defp filter_by_category_search(query, ""), do: query
-
- defp filter_by_category_search(query, search) do
- search_term = "%#{search}%"
- default_lang = Translations.default_language()
-
- # Search in JSONB localized name field using PostgreSQL operators
- where(
- query,
- [c],
- fragment(
- "(COALESCE(name->>?, '') ILIKE ? OR EXISTS (SELECT 1 FROM jsonb_each_text(name) WHERE value ILIKE ?))",
- ^default_lang,
- ^search_term,
- ^search_term
- )
- )
- end
-
- defp maybe_preload(query, nil), do: query
- defp maybe_preload(query, preloads), do: preload(query, ^preloads)
-
- # Shipping filters
- defp filter_shipping_by_active(query, nil), do: query
- defp filter_shipping_by_active(query, active), do: where(query, [s], s.active == ^active)
-
- # Cart helpers
-
- # Find cart item by product and selected_specs
- defp find_cart_item_by_specs(cart_uuid, product_uuid, specs) when map_size(specs) == 0 do
- # No specs - find item without specs
- CartItem
- |> where([i], i.cart_uuid == ^cart_uuid and i.product_uuid == ^product_uuid)
- |> where([i], i.selected_specs == ^%{})
- |> repo().one()
- end
-
- defp find_cart_item_by_specs(cart_uuid, product_uuid, specs) when is_map(specs) do
- # With specs - find item with matching specs
- CartItem
- |> where([i], i.cart_uuid == ^cart_uuid and i.product_uuid == ^product_uuid)
- |> where([i], i.selected_specs == ^specs)
- |> repo().one()
- end
-
- defp recalculate_cart_totals!(%Cart{} = cart) do
- items = CartItem |> where([i], i.cart_uuid == ^cart.uuid) |> repo().all()
-
- subtotal =
- Enum.reduce(items, Decimal.new("0"), fn i, acc ->
- Decimal.add(acc, i.line_total || Decimal.new("0"))
- end)
-
- total_weight =
- Enum.reduce(items, 0, fn i, acc ->
- acc + (i.weight_grams || 0) * i.quantity
- end)
-
- items_count =
- Enum.reduce(items, 0, fn i, acc ->
- acc + i.quantity
- end)
-
- shipping_amount = calculate_shipping(cart, subtotal, total_weight)
-
- # Calculate tax
- tax_rate = get_tax_rate(cart)
- taxable_amount = Decimal.sub(subtotal, cart.discount_amount || Decimal.new("0"))
- tax_amount = Decimal.mult(taxable_amount, tax_rate) |> Decimal.round(2)
-
- # Calculate total
- total =
- subtotal
- |> Decimal.add(shipping_amount)
- |> Decimal.add(tax_amount)
- |> Decimal.sub(cart.discount_amount || Decimal.new("0"))
-
- cart
- |> Cart.totals_changeset(%{
- subtotal: subtotal,
- shipping_amount: shipping_amount,
- tax_amount: tax_amount,
- total: total,
- total_weight_grams: total_weight,
- items_count: items_count
- })
- |> repo().update!()
- |> repo().preload([:items, :shipping_method], force: true)
- end
-
- defp calculate_shipping(cart, subtotal, total_weight) do
- if cart.shipping_method_uuid do
- shipping_method = repo().get_by(ShippingMethod, uuid: cart.shipping_method_uuid)
-
- case shipping_method do
- nil ->
- Decimal.new("0")
-
- method ->
- if ShippingMethod.available_for?(method, %{
- weight_grams: total_weight,
- subtotal: subtotal,
- country: cart.shipping_country
- }) do
- ShippingMethod.calculate_cost(method, subtotal)
- else
- Decimal.new("0")
- end
- end
- else
- cart.shipping_amount || Decimal.new("0")
- end
- end
-
- defp get_tax_rate(%Cart{shipping_country: nil}), do: Decimal.new("0")
-
- defp get_tax_rate(%Cart{shipping_country: _country}) do
- if Settings.get_setting_cached("shop_tax_enabled", "true") == "true" do
- rate = Settings.get_setting_cached("shop_tax_rate", "20")
- Decimal.div(Decimal.new(rate), Decimal.new("100"))
- else
- Decimal.new("0")
- end
- end
-
- defp repo, do: PhoenixKit.RepoHelper.repo()
-
- # ============================================
- # IMPORT LOGS
- # ============================================
-
- alias PhoenixKit.Modules.Shop.ImportLog
-
- @doc """
- Creates a new import log entry.
- """
- def create_import_log(attrs) do
- %ImportLog{}
- |> ImportLog.create_changeset(attrs)
- |> repo().insert()
- end
-
- @doc """
- Gets an import log by ID.
- """
- def get_import_log(id, opts \\ [])
-
- def get_import_log(uuid, opts) when is_binary(uuid) do
- ImportLog
- |> maybe_preload(Keyword.get(opts, :preload))
- |> repo().get_by(uuid: uuid)
- end
-
- @doc """
- Gets an import log by ID, raises if not found.
- """
- def get_import_log!(id) when is_binary(id) do
- case get_import_log(id) do
- nil -> raise Ecto.NoResultsError, queryable: ImportLog
- log -> log
- end
- end
-
- @doc """
- Lists recent import logs.
- """
- def list_import_logs(opts \\ []) do
- limit = Keyword.get(opts, :limit, 20)
-
- ImportLog
- |> order_by([l], desc: l.inserted_at)
- |> limit(^limit)
- |> repo().all()
- |> repo().preload(:user)
- end
-
- @doc """
- Updates an import log.
- """
- def update_import_log(%ImportLog{} = import_log, attrs) do
- import_log
- |> ImportLog.update_changeset(attrs)
- |> repo().update()
- end
-
- @doc """
- Marks import as started.
- """
- def start_import(%ImportLog{} = import_log, total_rows) do
- import_log
- |> ImportLog.start_changeset(total_rows)
- |> repo().update()
- end
-
- @doc """
- Updates import progress.
- """
- def update_import_progress(%ImportLog{} = import_log, attrs) do
- import_log
- |> ImportLog.progress_changeset(attrs)
- |> repo().update()
- end
-
- @doc """
- Marks import as completed.
- """
- def complete_import(%ImportLog{} = import_log, stats) do
- import_log
- |> ImportLog.complete_changeset(stats)
- |> repo().update()
- end
-
- @doc """
- Marks import as failed.
- """
- def fail_import(%ImportLog{} = import_log, error) do
- import_log
- |> ImportLog.fail_changeset(error)
- |> repo().update()
- end
-
- @doc """
- Deletes an import log.
- """
- def delete_import_log(%ImportLog{} = import_log) do
- # Also delete the temp file if it exists
- if import_log.file_path && File.exists?(import_log.file_path) do
- File.rm(import_log.file_path)
- end
-
- repo().delete(import_log)
- end
-
- # ============================================
- # IMPORT CONFIG CRUD
- # ============================================
-
- @doc """
- Lists all active import configs.
- """
- def list_import_configs(opts \\ []) do
- query =
- ImportConfig
- |> order_by([c], desc: c.is_default, asc: c.name)
-
- query =
- if Keyword.get(opts, :active_only, true) do
- where(query, [c], c.active == true)
- else
- query
- end
-
- repo().all(query)
- end
-
- @doc """
- Gets an import config by ID.
- """
- def get_import_config(uuid) when is_binary(uuid) do
- repo().get_by(ImportConfig, uuid: uuid)
- end
-
- @doc """
- Gets an import config by ID, raises if not found.
- """
- def get_import_config!(id) when is_binary(id) do
- case get_import_config(id) do
- nil -> raise Ecto.NoResultsError, queryable: ImportConfig
- config -> config
- end
- end
-
- @doc """
- Gets the default import config, if one exists.
- """
- def get_default_import_config do
- ImportConfig
- |> where([c], c.is_default == true and c.active == true)
- |> limit(1)
- |> repo().one()
- end
-
- @doc """
- Gets an import config by name.
- """
- def get_import_config_by_name(name) when is_binary(name) do
- repo().get_by(ImportConfig, name: name)
- end
-
- @doc """
- Creates an import config.
- """
- def create_import_config(attrs \\ %{}) do
- result =
- %ImportConfig{}
- |> ImportConfig.changeset(attrs)
- |> repo().insert()
-
- # If this is the new default, clear other defaults
- case result do
- {:ok, %ImportConfig{is_default: true} = config} ->
- clear_other_defaults(config.uuid)
- {:ok, config}
-
- other ->
- other
- end
- end
-
- @doc """
- Updates an import config.
- """
- def update_import_config(%ImportConfig{} = config, attrs) do
- result =
- config
- |> ImportConfig.changeset(attrs)
- |> repo().update()
-
- # If this is the new default, clear other defaults
- case result do
- {:ok, %ImportConfig{is_default: true} = updated_config} ->
- clear_other_defaults(updated_config.uuid)
- {:ok, updated_config}
-
- other ->
- other
- end
- end
-
- @doc """
- Deletes an import config.
- """
- def delete_import_config(%ImportConfig{} = config) do
- repo().delete(config)
- end
-
- defp clear_other_defaults(except_uuid) do
- ImportConfig
- |> where([c], c.is_default == true and c.uuid != ^except_uuid)
- |> repo().update_all(set: [is_default: false])
- end
-
- @doc """
- Returns a changeset for tracking import config changes.
- """
- def change_import_config(%ImportConfig{} = config, attrs \\ %{}) do
- ImportConfig.changeset(config, attrs)
- end
-
- @doc """
- Creates the legacy default import config if no configs exist.
-
- Returns `{:created, config}` if a new config was created,
- or `:exists` if configs already exist.
- """
- def ensure_default_import_config do
- if repo().aggregate(ImportConfig, :count) == 0 do
- attrs = Map.from_struct(ImportConfig.from_legacy_defaults())
- {:ok, config} = create_import_config(attrs)
- {:created, config}
- else
- :exists
- end
- end
-
- @doc """
- Ensures a default Prom.ua import config exists.
- Creates one if no config with name "prom_ua_default" is found.
- """
- def ensure_prom_ua_import_config do
- case repo().get_by(ImportConfig, name: "prom_ua_default") do
- nil ->
- attrs =
- ImportConfig.from_prom_ua_defaults()
- |> Map.from_struct()
- |> Map.drop([:__meta__, :id, :uuid, :inserted_at, :updated_at])
-
- {:ok, config} = create_import_config(attrs)
- {:created, config}
-
- config ->
- {:exists, config}
- end
- end
-
- # ============================================
- # PRODUCT UPSERT
- # ============================================
-
- @doc """
- Creates or updates a product by slug.
-
- Uses explicit find-or-create pattern with proper localized field merging.
- After V47 migration, slug is a JSONB map (e.g., %{"en-US" => "my-slug"}),
- so ON CONFLICT doesn't work correctly - this function handles the lookup manually.
-
- Returns {:ok, product, action} where action is :inserted or :updated.
-
- ## Parameters
-
- - `attrs` - Product attributes including localized fields as maps
-
- ## Examples
-
- # Create new product
- iex> upsert_product(%{title: %{"en-US" => "Planter"}, slug: %{"en-US" => "planter"}, price: 10})
- {:ok, %Product{}, :inserted}
-
- # Update existing product (found by slug)
- iex> upsert_product(%{title: %{"en-US" => "Planter V2"}, slug: %{"en-US" => "planter"}, price: 15})
- {:ok, %Product{}, :updated}
-
- # Add translation to existing product
- iex> upsert_product(%{title: %{"es-ES" => "Maceta"}, slug: %{"es-ES" => "maceta", "en-US" => "planter"}, price: 10})
- {:ok, %Product{title: %{"en-US" => "Planter", "es-ES" => "Maceta"}}, :updated}
-
- """
- def upsert_product(attrs) do
- slug_map = get_attr(attrs, :slug) || %{}
-
- case find_product_by_slug_map(slug_map) do
- nil ->
- # New product - create it
- case create_product(attrs) do
- {:ok, product} -> {:ok, product, :inserted}
- error -> error
- end
-
- existing ->
- # Existing product - merge localized fields and update
- merged_attrs = merge_localized_attrs(existing, attrs)
-
- case update_product(existing, merged_attrs) do
- {:ok, product} -> {:ok, product, :updated}
- error -> error
- end
- end
- end
-
- @doc """
- Finds an existing product by any slug in the provided slug map.
-
- Searches through each slug value in the map to find a matching product.
- Returns the first product found, or nil if no match.
-
- ## Examples
-
- iex> find_product_by_slug_map(%{"en-US" => "planter"})
- %Product{} | nil
-
- iex> find_product_by_slug_map(%{"en-US" => "planter", "es-ES" => "maceta"})
- %Product{} | nil # Finds by first matching slug
- """
- def find_product_by_slug_map(slug_map) when map_size(slug_map) == 0, do: nil
-
- def find_product_by_slug_map(slug_map) when is_map(slug_map) do
- # Try to find by any slug in the map
- Enum.find_value(slug_map, fn {lang, slug} ->
- case get_product_by_slug_localized(slug, lang) do
- {:ok, product} -> product
- _ -> nil
- end
- end)
- end
-
- @doc """
- Merges localized fields from new attributes into existing product.
-
- Preserves existing translations while adding new ones from attrs.
- Non-localized fields are replaced entirely.
-
- ## Examples
-
- iex> merge_localized_attrs(%Product{title: %{"en-US" => "Old"}}, %{title: %{"es-ES" => "Nuevo"}})
- %{title: %{"en-US" => "Old", "es-ES" => "Nuevo"}}
- """
- def merge_localized_attrs(existing, new_attrs) do
- localized_fields = [:title, :slug, :description, :body_html, :seo_title, :seo_description]
-
- # Start with all new attrs
- Enum.reduce(localized_fields, new_attrs, fn field, acc ->
- existing_map = Map.get(existing, field) || %{}
- new_map = get_attr(acc, field) || %{}
-
- # Only merge if there's something to merge
- if map_size(new_map) > 0 do
- # Merge: new values take precedence for same language
- merged = Map.merge(existing_map, new_map)
- put_attr(acc, field, merged)
- else
- acc
- end
- end)
- end
-
- # Helper to get attribute from either atom or string keyed map
- defp get_attr(attrs, key) when is_atom(key) do
- Map.get(attrs, key) || Map.get(attrs, to_string(key))
- end
-
- # Helper to put attribute preserving the map's key type
- defp put_attr(attrs, key, value) when is_atom(key) do
- cond do
- Map.has_key?(attrs, key) -> Map.put(attrs, key, value)
- Map.has_key?(attrs, to_string(key)) -> Map.put(attrs, to_string(key), value)
- true -> Map.put(attrs, key, value)
- end
- end
-
- # ============================================
- # LOCALIZED API (Multi-Language Support)
- # ============================================
-
- alias PhoenixKit.Modules.Shop.SlugResolver
- alias PhoenixKit.Modules.Shop.Translations
-
- @doc """
- Gets a product by slug with language awareness.
-
- Searches both translated slugs and canonical slug for the specified language.
-
- ## Parameters
-
- - `slug` - The URL slug to search for
- - `language` - Language code (e.g., "es-ES" or base code "en")
- - `opts` - Options: `:preload`, `:status`
-
- ## Examples
-
- iex> Shop.get_product_by_slug_localized("maceta-geometrica", "es-ES")
- {:ok, %Product{}}
-
- iex> Shop.get_product_by_slug_localized("geometric-planter", "en")
- {:ok, %Product{}}
- """
- def get_product_by_slug_localized(slug, language, opts \\ []) do
- SlugResolver.find_product_by_slug(slug, language, opts)
- end
-
- @doc """
- Gets a category by slug with language awareness.
-
- Searches both translated slugs and canonical slug for the specified language.
-
- ## Parameters
-
- - `slug` - The URL slug to search for
- - `language` - Language code (e.g., "es-ES" or base code "en")
- - `opts` - Options: `:preload`, `:status`
-
- ## Examples
-
- iex> Shop.get_category_by_slug_localized("jarrones-macetas", "es-ES")
- {:ok, %Category{}}
- """
- def get_category_by_slug_localized(slug, language, opts \\ []) do
- SlugResolver.find_category_by_slug(slug, language, opts)
- end
-
- @doc """
- Updates translation for a specific language on a product.
-
- ## Parameters
-
- - `product` - The product struct
- - `language` - Language code (e.g., "es-ES")
- - `attrs` - Translation attributes: title, slug, description, body_html, seo_title, seo_description
-
- ## Examples
-
- iex> Shop.update_product_translation(product, "es-ES", %{
- ...> "title" => "Maceta Geométrica",
- ...> "slug" => "maceta-geometrica"
- ...> })
- {:ok, %Product{}}
- """
- def update_product_translation(%Product{} = product, language, attrs)
- when is_binary(language) do
- # Convert attrs to atom-keyed map for changeset_attrs_multi
- field_values =
- attrs
- |> Enum.map(fn {k, v} -> {to_atom(k), v} end)
- |> Map.new()
-
- translation_attrs = Translations.changeset_attrs_multi(product, language, field_values)
- update_product(product, translation_attrs)
- end
-
- defp to_atom(key) when is_atom(key), do: key
- defp to_atom(key) when is_binary(key), do: String.to_existing_atom(key)
-
- @doc """
- Updates translation for a specific language on a category.
-
- ## Parameters
-
- - `category` - The category struct
- - `language` - Language code (e.g., "es-ES")
- - `attrs` - Translation attributes: name, slug, description
-
- ## Examples
-
- iex> Shop.update_category_translation(category, "es-ES", %{
- ...> "name" => "Jarrones y Macetas",
- ...> "slug" => "jarrones-macetas"
- ...> })
- {:ok, %Category{}}
- """
- def update_category_translation(%Category{} = category, language, attrs)
- when is_binary(language) do
- # Convert attrs to atom-keyed map for changeset_attrs_multi
- field_values =
- attrs
- |> Enum.map(fn {k, v} -> {to_atom(k), v} end)
- |> Map.new()
-
- translation_attrs = Translations.changeset_attrs_multi(category, language, field_values)
- update_category(category, translation_attrs)
- end
-
- @doc """
- Lists products with translated fields for a specific language.
-
- Returns products with an additional `:localized` virtual map containing
- translated fields with fallback to defaults.
-
- ## Parameters
-
- - `language` - Language code for translations
- - `opts` - Standard list options: `:page`, `:per_page`, `:status`, `:category_uuid`, etc.
-
- ## Examples
-
- iex> Shop.list_products_localized("es-ES", status: "active")
- [%Product{localized: %{title: "Maceta...", ...}}, ...]
- """
- def list_products_localized(language, opts \\ []) do
- products = list_products(opts)
-
- Enum.map(products, fn product ->
- Map.put(product, :localized, build_localized_product(product, language))
- end)
- end
-
- @doc """
- Lists categories with translated fields for a specific language.
-
- ## Parameters
-
- - `language` - Language code for translations
- - `opts` - Standard list options
-
- ## Examples
-
- iex> Shop.list_categories_localized("es-ES", status: "active")
- [%Category{localized: %{name: "Jarrones...", ...}}, ...]
- """
- def list_categories_localized(language, opts \\ []) do
- categories = list_categories(opts)
-
- Enum.map(categories, fn category ->
- Map.put(category, :localized, build_localized_category(category, language))
- end)
- end
-
- @doc """
- Gets the localized slug for a product.
-
- Returns translated slug if available, otherwise canonical slug.
-
- ## Examples
-
- iex> Shop.get_product_slug(product, "es-ES")
- "maceta-geometrica"
- """
- def get_product_slug(%Product{} = product, language) do
- SlugResolver.product_slug(product, language)
- end
-
- @doc """
- Gets the localized slug for a category.
-
- ## Examples
-
- iex> Shop.get_category_slug(category, "es-ES")
- "jarrones-macetas"
- """
- def get_category_slug(%Category{} = category, language) do
- SlugResolver.category_slug(category, language)
- end
-
- @doc """
- Finds a product by slug in any language.
-
- Searches across all translated slugs to find the product.
- Useful for cross-language redirect when user visits with a slug
- from a different language.
-
- ## Examples
-
- iex> Shop.get_product_by_any_slug("maceta-geometrica")
- {:ok, %Product{}, "es"}
-
- iex> Shop.get_product_by_any_slug("nonexistent")
- {:error, :not_found}
- """
- def get_product_by_any_slug(slug, opts \\ []) do
- SlugResolver.find_product_by_any_slug(slug, opts)
- end
-
- @doc """
- Finds a category by slug in any language.
-
- ## Examples
-
- iex> Shop.get_category_by_any_slug("jarrones-macetas")
- {:ok, %Category{}, "es"}
- """
- def get_category_by_any_slug(slug, opts \\ []) do
- SlugResolver.find_category_by_any_slug(slug, opts)
- end
-
- # ============================================
- # URL GENERATION
- # ============================================
-
- @doc """
- Generates a localized URL for a product.
-
- Returns the correct locale-prefixed URL with translated slug.
- The URL respects the PhoenixKit URL prefix configuration.
-
- ## Parameters
-
- - `product` - The Product struct
- - `language` - Language code (e.g., "en-US", "ru", "es-ES")
-
- ## Examples
-
- iex> Shop.product_url(product, "es-ES")
- "/es/shop/product/maceta-geometrica"
-
- iex> Shop.product_url(product, "ru")
- "/ru/shop/product/geometricheskoe-kashpo"
-
- iex> Shop.product_url(product, "en")
- "/shop/product/geometric-planter" # Default language - no prefix
- """
- @spec product_url(Product.t(), String.t()) :: String.t()
- def product_url(%Product{} = product, language) do
- slug = SlugResolver.product_slug(product, language)
- base = DialectMapper.extract_base(language)
- # Let Routes.path handle locale prefix - it adds prefix for non-default locales
- Routes.path("/shop/product/#{slug}", locale: base)
- end
-
- @doc """
- Generates a localized URL for a category.
-
- Returns the correct locale-prefixed URL with translated slug.
-
- ## Parameters
-
- - `category` - The Category struct
- - `language` - Language code (e.g., "en-US", "ru", "es-ES")
-
- ## Examples
-
- iex> Shop.category_url(category, "es-ES")
- "/es/shop/category/jarrones-macetas"
-
- iex> Shop.category_url(category, "en")
- "/shop/category/vases-planters" # Default language - no prefix
- """
- @spec category_url(Category.t(), String.t()) :: String.t()
- def category_url(%Category{} = category, language) do
- slug = SlugResolver.category_slug(category, language)
- base = DialectMapper.extract_base(language)
- # Let Routes.path handle locale prefix - it adds prefix for non-default locales
- Routes.path("/shop/category/#{slug}", locale: base)
- end
-
- @doc """
- Generates a localized URL for the shop catalog.
-
- ## Examples
-
- iex> Shop.catalog_url("es-ES")
- "/es/shop"
-
- iex> Shop.catalog_url("en")
- "/shop"
- """
- @spec catalog_url(String.t()) :: String.t()
- def catalog_url(language) do
- base = DialectMapper.extract_base(language)
- # Let Routes.path handle locale prefix - it adds prefix for non-default locales
- Routes.path("/shop", locale: base)
- end
-
- @doc """
- Generates a localized URL for the cart page.
-
- ## Examples
-
- iex> Shop.cart_url("ru")
- "/ru/cart"
-
- iex> Shop.cart_url("en")
- "/cart"
- """
- @spec cart_url(String.t()) :: String.t()
- def cart_url(language) do
- base = DialectMapper.extract_base(language)
- # Let Routes.path handle locale prefix - it adds prefix for non-default locales
- Routes.path("/cart", locale: base)
- end
-
- @doc """
- Generates a localized URL for the checkout page.
-
- ## Examples
-
- iex> Shop.checkout_url("ru")
- "/ru/checkout"
-
- iex> Shop.checkout_url("en")
- "/checkout"
- """
- @spec checkout_url(String.t()) :: String.t()
- def checkout_url(language) do
- base = DialectMapper.extract_base(language)
- # Let Routes.path handle locale prefix - it adds prefix for non-default locales
- Routes.path("/checkout", locale: base)
- end
-
- @doc """
- Gets the default language code (base code, e.g., "en").
-
- Reads from Languages module configuration or falls back to "en".
- """
- @spec get_default_language() :: String.t()
- def get_default_language do
- case Languages.get_default_language() do
- nil -> "en"
- lang -> DialectMapper.extract_base(lang.code)
- end
- end
-
- @doc """
- Checks if a product slug exists for a language.
-
- Useful for validation during translation editing.
-
- ## Examples
-
- iex> Shop.product_slug_exists?("maceta-geometrica", "es-ES")
- true
-
- iex> Shop.product_slug_exists?("maceta-geometrica", "es-ES", exclude_uuid: "some-uuid")
- false
- """
- def product_slug_exists?(slug, language, opts \\ []) do
- SlugResolver.product_slug_exists?(slug, language, opts)
- end
-
- @doc """
- Checks if a category slug exists for a language.
-
- ## Examples
-
- iex> Shop.category_slug_exists?("jarrones-macetas", "es-ES")
- true
- """
- def category_slug_exists?(slug, language, opts \\ []) do
- SlugResolver.category_slug_exists?(slug, language, opts)
- end
-
- @doc """
- Returns translation helpers module for direct access.
-
- ## Examples
-
- iex> Shop.translations()
- PhoenixKit.Modules.Shop.Translations
- """
- def translations, do: Translations
-
- # Build localized map for a product
- defp build_localized_product(product, language) do
- %{
- title: Translations.get_field(product, :title, language),
- slug: Translations.get_field(product, :slug, language) || product.slug,
- description: Translations.get_field(product, :description, language),
- body_html: Translations.get_field(product, :body_html, language),
- seo_title: Translations.get_field(product, :seo_title, language),
- seo_description: Translations.get_field(product, :seo_description, language)
- }
- end
-
- # Build localized map for a category
- defp build_localized_category(category, language) do
- %{
- name: Translations.get_field(category, :name, language),
- slug: Translations.get_field(category, :slug, language) || category.slug,
- description: Translations.get_field(category, :description, language)
- }
- end
-end
diff --git a/lib/modules/shop/slug_resolver.ex b/lib/modules/shop/slug_resolver.ex
deleted file mode 100644
index 45ad23da3..000000000
--- a/lib/modules/shop/slug_resolver.ex
+++ /dev/null
@@ -1,666 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.SlugResolver do
- @moduledoc """
- Resolves URL slugs to Products and Categories with language awareness.
-
- This module provides language-aware slug resolution for the Shop module,
- supporting per-language URL slugs for SEO optimization.
-
- ## Features
-
- - Per-language SEO-friendly URL slugs
- - Fallback to canonical slug when translation not found
- - Base code matching (e.g., "en" matches "en-US")
- - Efficient queries using JSONB operators
-
- ## URL Architecture
-
- ```
- /shop/products/geometric-planter # Default language
- /es/shop/products/maceta-geometrica # Spanish (SEO slug)
- /ru/shop/products/geometricheskoe-kashpo # Russian (SEO slug)
- ```
-
- ## Usage Examples
-
- # Find product by slug in specific language
- SlugResolver.find_product_by_slug("maceta-geometrica", "es-ES")
- # => {:ok, %Product{}}
-
- # Find product with base code (resolves to full dialect)
- SlugResolver.find_product_by_slug("geometric-planter", "en")
- # => {:ok, %Product{}} (matches en-US via base code)
-
- # Find category by slug
- SlugResolver.find_category_by_slug("jarrones-macetas", "es-ES")
- # => {:ok, %Category{}}
-
- ## Query Behavior
-
- The resolver checks both translated slugs and canonical slugs:
-
- 1. First tries `translations->'language'->>'slug' = ?`
- 2. Falls back to canonical `slug = ?`
-
- This ensures URLs work even for products without translations.
- """
-
- import Ecto.Query
-
- alias PhoenixKit.Modules.Languages.DialectMapper
- alias PhoenixKit.Modules.Shop.Category
- alias PhoenixKit.Modules.Shop.Product
- alias PhoenixKit.Modules.Shop.Translations
-
- # ============================================================================
- # Product Slug Resolution
- # ============================================================================
-
- @doc """
- Finds a product by URL slug for a specific language.
-
- ## Parameters
-
- - `url_slug` - The URL slug to search for
- - `language` - Language code (supports both "es-ES" and base codes like "en")
- - `opts` - Optional keyword list:
- - `:preload` - Associations to preload (default: [])
- - `:status` - Filter by status (e.g., "active")
-
- ## Examples
-
- iex> SlugResolver.find_product_by_slug("maceta-geometrica", "es-ES")
- {:ok, %Product{title: "Maceta Geométrica", ...}}
-
- iex> SlugResolver.find_product_by_slug("geometric-planter", "en")
- {:ok, %Product{}} # Matches en-US via base code resolution
-
- iex> SlugResolver.find_product_by_slug("nonexistent", "en-US")
- {:error, :not_found}
-
- ## Query Details
-
- The query checks both:
- 1. Translated slug: `translations->'lang'->>'slug'`
- 2. Canonical slug: `slug` column
-
- This ensures backward compatibility with products that have no translations.
- """
- @spec find_product_by_slug(String.t(), String.t(), keyword()) ::
- {:ok, Product.t()} | {:error, :not_found}
- def find_product_by_slug(url_slug, language, opts \\ []) do
- lang = normalize_language(language)
- preload = Keyword.get(opts, :preload, [])
- status = Keyword.get(opts, :status)
-
- # Localized fields: slug is a JSONB map like %{"en" => "planter", "ru" => "kashpo"}
- # Search for exact language match or fallback to default language
- query =
- from(p in Product,
- where:
- fragment(
- "slug->>? = ?",
- ^lang,
- ^url_slug
- ),
- limit: 1
- )
-
- query =
- if status do
- from(p in query, where: p.status == ^status)
- else
- query
- end
-
- query =
- if preload != [] do
- from(p in query, preload: ^preload)
- else
- query
- end
-
- case repo().one(query) do
- nil -> {:error, :not_found}
- product -> {:ok, product}
- end
- end
-
- @doc """
- Finds a product by slug, requiring exact language match.
-
- Unlike `find_product_by_slug/3`, this does not fall back to canonical slug.
- Useful when you need to ensure the translation exists.
-
- ## Examples
-
- iex> SlugResolver.find_product_by_translated_slug("maceta-geometrica", "es-ES")
- {:ok, %Product{}}
-
- iex> SlugResolver.find_product_by_translated_slug("maceta-geometrica", "en-US")
- {:error, :not_found} # No fallback to canonical
- """
- @spec find_product_by_translated_slug(String.t(), String.t(), keyword()) ::
- {:ok, Product.t()} | {:error, :not_found}
- def find_product_by_translated_slug(url_slug, language, opts \\ []) do
- lang = normalize_language(language)
- preload = Keyword.get(opts, :preload, [])
-
- # Localized fields: slug is a JSONB map
- query =
- from(p in Product,
- where:
- fragment(
- "slug->>? = ?",
- ^lang,
- ^url_slug
- ),
- limit: 1
- )
-
- query =
- if preload != [] do
- from(p in query, preload: ^preload)
- else
- query
- end
-
- case repo().one(query) do
- nil -> {:error, :not_found}
- product -> {:ok, product}
- end
- end
-
- # ============================================================================
- # Category Slug Resolution
- # ============================================================================
-
- @doc """
- Finds a category by URL slug for a specific language.
-
- ## Parameters
-
- - `url_slug` - The URL slug to search for
- - `language` - Language code (supports both full and base codes)
- - `opts` - Optional keyword list:
- - `:preload` - Associations to preload (default: [])
- - `:status` - Filter by status (e.g., "active")
-
- ## Examples
-
- iex> SlugResolver.find_category_by_slug("jarrones-macetas", "es-ES")
- {:ok, %Category{name: "Jarrones y Macetas", ...}}
-
- iex> SlugResolver.find_category_by_slug("vases-planters", "en")
- {:ok, %Category{}}
-
- iex> SlugResolver.find_category_by_slug("nonexistent", "en-US")
- {:error, :not_found}
- """
- @spec find_category_by_slug(String.t(), String.t(), keyword()) ::
- {:ok, Category.t()} | {:error, :not_found}
- def find_category_by_slug(url_slug, language, opts \\ []) do
- lang = normalize_language(language)
- preload = Keyword.get(opts, :preload, [])
- status = Keyword.get(opts, :status)
-
- # Localized fields: slug is a JSONB map
- query =
- from(c in Category,
- where:
- fragment(
- "slug->>? = ?",
- ^lang,
- ^url_slug
- ),
- limit: 1
- )
-
- query =
- if status do
- from(c in query, where: c.status == ^status)
- else
- query
- end
-
- query =
- if preload != [] do
- from(c in query, preload: ^preload)
- else
- query
- end
-
- case repo().one(query) do
- nil -> {:error, :not_found}
- category -> {:ok, category}
- end
- end
-
- @doc """
- Finds a category by slug, requiring exact language match.
-
- Does not fall back to canonical slug.
-
- ## Examples
-
- iex> SlugResolver.find_category_by_translated_slug("jarrones-macetas", "es-ES")
- {:ok, %Category{}}
- """
- @spec find_category_by_translated_slug(String.t(), String.t(), keyword()) ::
- {:ok, Category.t()} | {:error, :not_found}
- def find_category_by_translated_slug(url_slug, language, opts \\ []) do
- lang = normalize_language(language)
- preload = Keyword.get(opts, :preload, [])
-
- # Localized fields: slug is a JSONB map
- query =
- from(c in Category,
- where:
- fragment(
- "slug->>? = ?",
- ^lang,
- ^url_slug
- ),
- limit: 1
- )
-
- query =
- if preload != [] do
- from(c in query, preload: ^preload)
- else
- query
- end
-
- case repo().one(query) do
- nil -> {:error, :not_found}
- category -> {:ok, category}
- end
- end
-
- # ============================================================================
- # Batch Resolution
- # ============================================================================
-
- @doc """
- Finds multiple products by their slugs for a specific language.
-
- Useful for preloading products in listing pages.
-
- ## Examples
-
- iex> SlugResolver.find_products_by_slugs(["planter-1", "planter-2"], "en-US")
- [%Product{}, %Product{}]
- """
- @spec find_products_by_slugs([String.t()], String.t(), keyword()) :: [Product.t()]
- def find_products_by_slugs(url_slugs, language, opts \\ []) when is_list(url_slugs) do
- lang = normalize_language(language)
- preload = Keyword.get(opts, :preload, [])
- status = Keyword.get(opts, :status)
-
- # Localized fields: slug is a JSONB map
- query =
- from(p in Product,
- where:
- fragment(
- "slug->>? = ANY(?)",
- ^lang,
- ^url_slugs
- )
- )
-
- query =
- if status do
- from(p in query, where: p.status == ^status)
- else
- query
- end
-
- query =
- if preload != [] do
- from(p in query, preload: ^preload)
- else
- query
- end
-
- repo().all(query)
- end
-
- @doc """
- Finds multiple categories by their slugs for a specific language.
-
- ## Examples
-
- iex> SlugResolver.find_categories_by_slugs(["cat-1", "cat-2"], "en-US")
- [%Category{}, %Category{}]
- """
- @spec find_categories_by_slugs([String.t()], String.t(), keyword()) :: [Category.t()]
- def find_categories_by_slugs(url_slugs, language, opts \\ []) when is_list(url_slugs) do
- lang = normalize_language(language)
- preload = Keyword.get(opts, :preload, [])
- status = Keyword.get(opts, :status)
-
- # Localized fields: slug is a JSONB map
- query =
- from(c in Category,
- where:
- fragment(
- "slug->>? = ANY(?)",
- ^lang,
- ^url_slugs
- )
- )
-
- query =
- if status do
- from(c in query, where: c.status == ^status)
- else
- query
- end
-
- query =
- if preload != [] do
- from(c in query, preload: ^preload)
- else
- query
- end
-
- repo().all(query)
- end
-
- # ============================================================================
- # Slug Existence Checks
- # ============================================================================
-
- @doc """
- Checks if a product slug exists for a specific language.
-
- Useful for slug validation during product creation/editing.
-
- ## Parameters
-
- - `slug` - The slug to check
- - `language` - Language code
- - `exclude_uuid` - Product UUID to exclude from check (for edits)
-
- ## Examples
-
- iex> SlugResolver.product_slug_exists?("geometric-planter", "en-US")
- true
-
- iex> SlugResolver.product_slug_exists?("geometric-planter", "en-US", exclude_uuid: "some-uuid")
- false # Excludes product with given UUID from check
- """
- @spec product_slug_exists?(String.t(), String.t(), keyword()) :: boolean()
- def product_slug_exists?(slug, language, opts \\ []) do
- lang = normalize_language(language)
- exclude_uuid = Keyword.get(opts, :exclude_uuid)
-
- # Localized fields: slug is a JSONB map
- query =
- from(p in Product,
- where:
- fragment(
- "slug->>? = ?",
- ^lang,
- ^slug
- ),
- select: count(p.uuid)
- )
-
- query =
- if is_binary(exclude_uuid) && match?({:ok, _}, Ecto.UUID.cast(exclude_uuid)) do
- from(p in query, where: p.uuid != ^exclude_uuid)
- else
- query
- end
-
- repo().one(query) > 0
- end
-
- @doc """
- Checks if a category slug exists for a specific language.
-
- ## Examples
-
- iex> SlugResolver.category_slug_exists?("vases-planters", "en-US")
- true
- """
- @spec category_slug_exists?(String.t(), String.t(), keyword()) :: boolean()
- def category_slug_exists?(slug, language, opts \\ []) do
- lang = normalize_language(language)
- exclude_uuid = Keyword.get(opts, :exclude_uuid)
-
- # Localized fields: slug is a JSONB map
- query =
- from(c in Category,
- where:
- fragment(
- "slug->>? = ?",
- ^lang,
- ^slug
- ),
- select: count(c.uuid)
- )
-
- query =
- if is_binary(exclude_uuid) && match?({:ok, _}, Ecto.UUID.cast(exclude_uuid)) do
- from(c in query, where: c.uuid != ^exclude_uuid)
- else
- query
- end
-
- repo().one(query) > 0
- end
-
- # ============================================================================
- # URL Generation
- # ============================================================================
-
- @doc """
- Gets the best slug for a product in a specific language.
-
- Returns translated slug if available, otherwise canonical slug.
-
- ## Examples
-
- iex> SlugResolver.product_slug(product, "es-ES")
- "maceta-geometrica"
-
- iex> SlugResolver.product_slug(product, "fr-FR")
- "geometric-planter" # Falls back to canonical
- """
- @spec product_slug(Product.t(), String.t()) :: String.t() | nil
- def product_slug(%Product{} = product, language) do
- lang = normalize_language(language)
- slug_map = product.slug || %{}
-
- # Localized fields approach: slug is directly a map
- slug_map[lang] || slug_map[default_language()] || first_slug(slug_map)
- end
-
- @doc """
- Gets the best slug for a category in a specific language.
-
- Returns translated slug if available, otherwise canonical slug.
-
- ## Examples
-
- iex> SlugResolver.category_slug(category, "es-ES")
- "jarrones-macetas"
- """
- @spec category_slug(Category.t(), String.t()) :: String.t() | nil
- def category_slug(%Category{} = category, language) do
- lang = normalize_language(language)
- slug_map = category.slug || %{}
-
- # Localized fields approach: slug is directly a map
- slug_map[lang] || slug_map[default_language()] || first_slug(slug_map)
- end
-
- # ============================================================================
- # Cross-Language Slug Resolution
- # ============================================================================
-
- @doc """
- Finds a product by slug in any language.
-
- Searches across all translated slugs to find the product.
- Useful for cross-language redirect when user visits with a slug
- from a different language.
-
- ## Parameters
-
- - `url_slug` - The URL slug to search for
- - `opts` - Optional keyword list:
- - `:preload` - Associations to preload (default: [])
- - `:status` - Filter by status (e.g., "active")
-
- ## Examples
-
- iex> SlugResolver.find_product_by_any_slug("maceta-geometrica")
- {:ok, %Product{}, "es"} # Returns product with language that matched
-
- iex> SlugResolver.find_product_by_any_slug("geometric-planter")
- {:ok, %Product{}, "en"}
-
- iex> SlugResolver.find_product_by_any_slug("nonexistent")
- {:error, :not_found}
- """
- @spec find_product_by_any_slug(String.t(), keyword()) ::
- {:ok, Product.t(), String.t()} | {:error, :not_found}
- def find_product_by_any_slug(url_slug, opts \\ []) do
- preload = Keyword.get(opts, :preload, [])
- status = Keyword.get(opts, :status)
-
- # Search across all language slugs using JSONB query
- # slug is a JSONB map like %{"en" => "planter", "ru" => "kashpo", "es" => "maceta"}
- query =
- from(p in Product,
- where:
- fragment(
- "EXISTS (SELECT 1 FROM jsonb_each_text(slug) WHERE value = ?)",
- ^url_slug
- ),
- limit: 1
- )
-
- query =
- if status do
- from(p in query, where: p.status == ^status)
- else
- query
- end
-
- query =
- if preload != [] do
- from(p in query, preload: ^preload)
- else
- query
- end
-
- case repo().one(query) do
- nil ->
- {:error, :not_found}
-
- product ->
- # Find which language matched
- matched_lang = find_matching_language(product.slug || %{}, url_slug)
- {:ok, product, matched_lang}
- end
- end
-
- @doc """
- Finds a category by slug in any language.
-
- ## Examples
-
- iex> SlugResolver.find_category_by_any_slug("jarrones-macetas")
- {:ok, %Category{}, "es"}
- """
- @spec find_category_by_any_slug(String.t(), keyword()) ::
- {:ok, Category.t(), String.t()} | {:error, :not_found}
- def find_category_by_any_slug(url_slug, opts \\ []) do
- preload = Keyword.get(opts, :preload, [])
- status = Keyword.get(opts, :status)
-
- query =
- from(c in Category,
- where:
- fragment(
- "EXISTS (SELECT 1 FROM jsonb_each_text(slug) WHERE value = ?)",
- ^url_slug
- ),
- limit: 1
- )
-
- query =
- if status do
- from(c in query, where: c.status == ^status)
- else
- query
- end
-
- query =
- if preload != [] do
- from(c in query, preload: ^preload)
- else
- query
- end
-
- case repo().one(query) do
- nil ->
- {:error, :not_found}
-
- category ->
- matched_lang = find_matching_language(category.slug || %{}, url_slug)
- {:ok, category, matched_lang}
- end
- end
-
- # Find which language key contains the matching slug
- defp find_matching_language(slug_map, slug) do
- Enum.find_value(slug_map, default_language(), fn {lang, lang_slug} ->
- if lang_slug == slug, do: lang, else: nil
- end)
- end
-
- # ============================================================================
- # Private Helpers
- # ============================================================================
-
- @doc """
- Normalizes a language code to dialect format.
-
- Converts base codes to full dialect (e.g., "en" -> "en-US").
- Used by import system to ensure consistent language keys in JSONB fields.
- """
- def normalize_language_public(lang) when is_binary(lang), do: normalize_language(lang)
-
- # Normalize language code (convert base code to full dialect)
- defp normalize_language(lang) when is_binary(lang) do
- cond do
- # Already a full dialect code (contains hyphen)
- String.contains?(lang, "-") ->
- lang
-
- # Base code only - convert to dialect
- String.length(lang) == 2 ->
- DialectMapper.base_to_dialect(lang)
-
- # Unknown format - use as-is
- true ->
- lang
- end
- end
-
- defp default_language do
- Translations.default_language()
- end
-
- defp first_slug(map) when map == %{}, do: nil
-
- defp first_slug(map) do
- map |> Map.values() |> List.first()
- end
-
- defp repo, do: PhoenixKit.RepoHelper.repo()
-end
diff --git a/lib/modules/shop/translations.ex b/lib/modules/shop/translations.ex
deleted file mode 100644
index 9e6dc80bb..000000000
--- a/lib/modules/shop/translations.ex
+++ /dev/null
@@ -1,387 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Translations do
- @moduledoc """
- Localized fields helper for Shop module.
-
- All translatable fields are stored as JSONB maps directly in the field:
-
- %Product{
- title: %{"en" => "Planter", "ru" => "Кашпо"},
- slug: %{"en" => "planter", "ru" => "kashpo"},
- description: %{"en" => "Modern pot", "ru" => "Современное кашпо"}
- }
-
- ## Fallback Chain
-
- When retrieving a translated field, the fallback chain is:
- 1. Exact language match (e.g., "ru")
- 2. Default language from Languages module
- 3. First available value in the map
-
- ## Usage Examples
-
- # Get translated field with automatic fallback
- Translations.get(product, :title, "ru")
- #=> "Кашпо"
-
- Translations.get(product, :title, "fr")
- #=> "Planter" (fallback to default or first available)
-
- # Set a single translated field
- product = Translations.put(product, :title, "es", "Maceta")
-
- # Build changeset attrs for localized field update
- attrs = Translations.changeset_attrs(product, :title, "ru", "Новое кашпо")
- #=> %{title: %{"en" => "Planter", "ru" => "Новое кашпо"}}
- """
-
- alias PhoenixKit.Modules.Languages
- alias PhoenixKit.Settings
-
- @product_fields [:title, :slug, :description, :body_html, :seo_title, :seo_description]
- @category_fields [:name, :slug, :description]
-
- # ============================================================================
- # Language Configuration
- # ============================================================================
-
- @doc """
- Returns the default/master language code.
-
- Checks Languages module first, falls back to Settings content language,
- then defaults to "en".
-
- ## Examples
-
- iex> Translations.default_language()
- "en"
- """
- @spec default_language() :: String.t()
- def default_language do
- if languages_enabled?() do
- case Languages.get_default_language() do
- %{code: code} -> code
- _ -> "en"
- end
- else
- Settings.get_content_language() || "en"
- end
- end
-
- @doc """
- Returns list of enabled language codes.
-
- When Languages module is enabled, returns all enabled language codes.
- Otherwise returns only the default language.
-
- ## Examples
-
- iex> Translations.enabled_languages()
- ["en", "es", "ru"]
-
- # When Languages module disabled:
- iex> Translations.enabled_languages()
- ["en"]
- """
- @spec enabled_languages() :: [String.t()]
- def enabled_languages do
- if languages_enabled?() do
- Languages.get_enabled_language_codes()
- else
- [default_language()]
- end
- end
-
- @doc """
- Checks if Languages module is enabled.
- """
- @spec languages_enabled?() :: boolean()
- def languages_enabled? do
- Code.ensure_loaded?(Languages) and function_exported?(Languages, :enabled?, 0) and
- Languages.enabled?()
- end
-
- # ============================================================================
- # Reading Translations (New Localized Fields Approach)
- # ============================================================================
-
- @doc """
- Gets a localized value with automatic fallback chain.
-
- Fallback order:
- 1. Exact language match
- 2. Default language
- 3. First available value
-
- ## Parameters
-
- - `entity` - Product or Category struct
- - `field` - Field atom (e.g., :title, :name, :slug)
- - `language` - Language code (e.g., "ru", "en")
-
- ## Examples
-
- iex> product = %Product{title: %{"en" => "Planter", "ru" => "Кашпо"}}
- iex> Translations.get(product, :title, "ru")
- "Кашпо"
-
- iex> Translations.get(product, :title, "fr")
- "Planter" # Falls back to default or first available
- """
- @spec get(struct(), atom(), String.t()) :: any()
- def get(entity, field, language) do
- field_map = Map.get(entity, field) || %{}
-
- field_map[language] ||
- field_map[default_language()] ||
- first_available(field_map)
- end
-
- @doc """
- Gets the localized slug with fallback.
-
- Convenience function for URL slug retrieval.
-
- ## Examples
-
- iex> Translations.get_slug(product, "es")
- "maceta-geometrica"
- """
- @spec get_slug(struct(), String.t()) :: String.t() | nil
- def get_slug(entity, language) do
- get(entity, :slug, language)
- end
-
- @doc """
- Gets all values for a specific language from the entity's localized fields.
-
- Returns a map of field => value for the given language.
-
- ## Examples
-
- iex> Translations.get_all_for_language(product, "ru", [:title, :slug, :description])
- %{title: "Кашпо", slug: "kashpo", description: "Описание"}
- """
- @spec get_all_for_language(struct(), String.t(), [atom()]) :: map()
- def get_all_for_language(entity, language, fields) do
- Enum.reduce(fields, %{}, fn field, acc ->
- value = get(entity, field, language)
- Map.put(acc, field, value)
- end)
- end
-
- # ============================================================================
- # Writing Translations
- # ============================================================================
-
- @doc """
- Sets a localized value for a language.
-
- Returns the updated entity struct (not persisted to database).
-
- ## Examples
-
- iex> product = Translations.put(product, :title, "ru", "Новое кашпо")
- %Product{title: %{"en" => "Planter", "ru" => "Новое кашпо"}}
- """
- @spec put(struct(), atom(), String.t(), any()) :: struct()
- def put(entity, field, language, value) do
- current = Map.get(entity, field) || %{}
- updated = Map.put(current, language, value)
- Map.put(entity, field, updated)
- end
-
- @doc """
- Builds changeset attrs for localized field update.
-
- Merges the new value into the existing field map for the given language.
-
- ## Examples
-
- iex> Translations.changeset_attrs(product, :title, "ru", "Новое кашпо")
- %{title: %{"en" => "Planter", "ru" => "Новое кашпо"}}
- """
- @spec changeset_attrs(struct(), atom(), String.t(), any()) :: map()
- def changeset_attrs(entity, field, language, value) do
- current = Map.get(entity, field) || %{}
- updated = Map.put(current, language, value)
- %{field => updated}
- end
-
- @doc """
- Builds changeset attrs for multiple localized fields at once.
-
- ## Examples
-
- iex> Translations.changeset_attrs_multi(product, "ru", %{title: "Кашпо", slug: "kashpo"})
- %{title: %{"en" => "Planter", "ru" => "Кашпо"}, slug: %{"en" => "planter", "ru" => "kashpo"}}
- """
- @spec changeset_attrs_multi(struct(), String.t(), map()) :: map()
- def changeset_attrs_multi(entity, language, field_values) do
- Enum.reduce(field_values, %{}, fn {field, value}, acc ->
- Map.merge(acc, changeset_attrs(entity, field, language, value))
- end)
- end
-
- @doc """
- Sets multiple translated fields for a language.
-
- Returns the updated entity struct (not persisted to database).
-
- ## Examples
-
- iex> product = Translations.put_all(product, "es", %{title: "Maceta", slug: "maceta"})
- %Product{title: %{"en" => "Planter", "es" => "Maceta"}, ...}
- """
- @spec put_all(struct(), String.t(), map()) :: struct()
- def put_all(entity, language, field_values) do
- Enum.reduce(field_values, entity, fn {field, value}, acc ->
- put(acc, field, language, value)
- end)
- end
-
- # ============================================================================
- # Inspection Helpers
- # ============================================================================
-
- @doc """
- Gets all languages that have a value for a field.
-
- ## Examples
-
- iex> Translations.available_languages(product, :title)
- ["en", "ru"]
- """
- @spec available_languages(struct(), atom()) :: [String.t()]
- def available_languages(entity, field) do
- field_map = Map.get(entity, field) || %{}
-
- field_map
- |> Map.keys()
- |> Enum.filter(fn lang ->
- value = Map.get(field_map, lang)
- value != nil and value != ""
- end)
- end
-
- @doc """
- Checks if translation exists for language in a specific field.
-
- ## Examples
-
- iex> Translations.has_translation?(product, :title, "ru")
- true
-
- iex> Translations.has_translation?(product, :title, "zh")
- false
- """
- @spec has_translation?(struct(), atom(), String.t()) :: boolean()
- def has_translation?(entity, field, language) do
- field_map = Map.get(entity, field) || %{}
- value = Map.get(field_map, language)
- value != nil and value != ""
- end
-
- @doc """
- Gets translation completeness for a language across all translatable fields.
-
- ## Examples
-
- iex> Translations.translation_status(product, "ru")
- %{complete: 4, total: 6, percentage: 67, missing: [:body_html, :seo_description]}
- """
- @spec translation_status(struct(), String.t(), [atom()] | nil) :: map()
- def translation_status(entity, language, required_fields \\ nil) do
- fields = required_fields || translatable_fields(entity)
-
- present =
- Enum.filter(fields, fn field ->
- has_translation?(entity, field, language)
- end)
-
- missing = fields -- present
- present_count = Enum.count(present)
- total_count = Enum.count(fields)
-
- %{
- complete: present_count,
- total: total_count,
- percentage: if(total_count > 0, do: round(present_count / total_count * 100), else: 0),
- missing: missing
- }
- end
-
- # ============================================================================
- # Field Definitions
- # ============================================================================
-
- @doc """
- Returns the list of translatable fields for products.
- """
- @spec product_fields() :: [atom()]
- def product_fields, do: @product_fields
-
- @doc """
- Returns the list of translatable fields for categories.
- """
- @spec category_fields() :: [atom()]
- def category_fields, do: @category_fields
-
- @doc """
- Returns translatable fields based on entity type.
- """
- @spec translatable_fields(struct()) :: [atom()]
- def translatable_fields(%{__struct__: PhoenixKit.Modules.Shop.Product}), do: @product_fields
- def translatable_fields(%{__struct__: PhoenixKit.Modules.Shop.Category}), do: @category_fields
- def translatable_fields(_), do: []
-
- # ============================================================================
- # Legacy Compatibility (Deprecated)
- # ============================================================================
-
- @doc """
- DEPRECATED: Use `get/3` instead.
-
- This function exists for backward compatibility during migration.
- """
- @spec get_field(struct(), atom(), String.t()) :: any()
- def get_field(entity, field, language) do
- get(entity, field, language)
- end
-
- @doc """
- DEPRECATED: Use `put/4` instead.
-
- This function exists for backward compatibility during migration.
- """
- @spec put_field(struct(), atom(), String.t(), any()) :: struct()
- def put_field(entity, field, language, value) do
- put(entity, field, language, value)
- end
-
- @doc """
- DEPRECATED: Use `changeset_attrs_multi/3` instead.
-
- Builds changeset attrs for updating translations.
- This function adapts the old API to the new localized fields approach.
- """
- @spec translation_changeset_attrs(map() | nil, String.t(), map()) :: map()
- def translation_changeset_attrs(_current_translations, _language, _params) do
- # This function is no longer applicable in the new approach
- # where each field is its own map.
- # Kept for compilation but should not be used.
- %{}
- end
-
- # ============================================================================
- # Private Helpers
- # ============================================================================
-
- defp first_available(map) when map == %{}, do: nil
-
- defp first_available(map) do
- case Enum.at(map, 0) do
- {_key, value} -> value
- nil -> nil
- end
- end
-end
diff --git a/lib/modules/shop/web/cart_page.ex b/lib/modules/shop/web/cart_page.ex
deleted file mode 100644
index 99bc7e2f6..000000000
--- a/lib/modules/shop/web/cart_page.ex
+++ /dev/null
@@ -1,521 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Web.CartPage do
- @moduledoc """
- Public cart page LiveView for E-Commerce module.
-
- Supports real-time cart synchronization across multiple browser tabs
- via PubSub subscription. When cart is updated in one tab, all other
- tabs receive the update automatically.
- """
-
- use PhoenixKitWeb, :live_view
-
- alias PhoenixKit.Modules.Languages.DialectMapper
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.Events
- alias PhoenixKit.Modules.Shop.ShippingMethod
- alias PhoenixKit.Modules.Shop.Translations
- alias PhoenixKit.Modules.Shop.Web.Components.ShopLayouts
-
- import PhoenixKit.Modules.Shop.Web.Helpers,
- only: [format_price: 2, humanize_key: 1, get_current_user: 1]
-
- @impl true
- def mount(_params, session, socket) do
- # Get session_id from session (for guest users)
- session_id = session["shop_session_id"] || generate_session_id()
-
- # Get current language for localized URLs
- current_language = socket.assigns[:current_locale] || Translations.default_language()
-
- # Get current user if logged in
- user = get_current_user(socket)
- user_uuid = if user, do: user.uuid, else: nil
-
- # Get or create cart
- {:ok, cart} =
- Shop.get_or_create_cart(user_uuid: user_uuid, session_id: session_id)
-
- # Subscribe to cart events for real-time sync across tabs
- if connected?(socket) do
- Events.subscribe_to_cart(cart)
- end
-
- # Get available shipping methods
- shipping_methods = Shop.get_available_shipping_methods(cart)
-
- # Auto-select cheapest shipping method if none selected
- {:ok, cart} = Shop.auto_select_shipping_method(cart, shipping_methods)
-
- # Get default currency from Billing
- currency = Shop.get_default_currency()
-
- # Check if user is authenticated
- authenticated = not is_nil(socket.assigns[:phoenix_kit_current_user])
-
- socket =
- socket
- |> assign(:page_title, "Shopping Cart")
- |> assign(:cart, cart)
- |> assign(:session_id, session_id)
- |> assign(:shipping_methods, shipping_methods)
- |> assign(:currency, currency)
- |> assign(:authenticated, authenticated)
- |> assign(:current_language, current_language)
-
- {:ok, socket}
- end
-
- @impl true
- def handle_event("update_quantity", %{"item_uuid" => item_uuid, "quantity" => quantity}, socket) do
- quantity = max(1, String.to_integer(quantity))
-
- update_item_quantity(socket, item_uuid, quantity)
- end
-
- @impl true
- def handle_event("remove_item", %{"item_uuid" => item_uuid}, socket) do
- item = Enum.find(socket.assigns.cart.items, &(&1.uuid == item_uuid))
-
- if item do
- case Shop.remove_from_cart(item) do
- {:ok, updated_cart} ->
- shipping_methods = Shop.get_available_shipping_methods(updated_cart)
-
- {:noreply,
- socket
- |> assign(:cart, updated_cart)
- |> assign(:shipping_methods, shipping_methods)
- |> put_flash(:info, "Item removed from cart")}
-
- {:error, _} ->
- {:noreply, put_flash(socket, :error, "Failed to remove item")}
- end
- else
- {:noreply, socket}
- end
- end
-
- @impl true
- def handle_event("select_shipping", %{"method_uuid" => method_uuid}, socket) do
- method = Enum.find(socket.assigns.shipping_methods, &(&1.uuid == method_uuid))
- cart = socket.assigns.cart
-
- if method do
- # Country will be set at checkout based on billing info
- case Shop.set_cart_shipping(cart, method, nil) do
- {:ok, updated_cart} ->
- {:noreply, assign(socket, :cart, updated_cart)}
-
- {:error, _} ->
- {:noreply, put_flash(socket, :error, "Failed to set shipping method")}
- end
- else
- {:noreply, socket}
- end
- end
-
- @impl true
- def handle_event("proceed_to_checkout", _params, socket) do
- cart = socket.assigns.cart
-
- cond do
- cart.items == [] ->
- {:noreply, put_flash(socket, :error, "Your cart is empty")}
-
- is_nil(cart.shipping_method_uuid) ->
- {:noreply, put_flash(socket, :error, "Please select a shipping method")}
-
- true ->
- {:noreply, push_navigate(socket, to: Shop.checkout_url(socket.assigns.current_language))}
- end
- end
-
- defp update_item_quantity(socket, item_uuid, quantity) do
- item = Enum.find(socket.assigns.cart.items, &(&1.uuid == item_uuid))
-
- if item do
- case Shop.update_cart_item(item, quantity) do
- {:ok, updated_cart} ->
- shipping_methods = Shop.get_available_shipping_methods(updated_cart)
-
- {:noreply,
- socket
- |> assign(:cart, updated_cart)
- |> assign(:shipping_methods, shipping_methods)}
-
- {:error, _} ->
- {:noreply, put_flash(socket, :error, "Failed to update quantity")}
- end
- else
- {:noreply, socket}
- end
- end
-
- # ============================================
- # PUBSUB EVENT HANDLERS
- # ============================================
-
- @impl true
- def handle_info({:cart_updated, cart}, socket) do
- shipping_methods = Shop.get_available_shipping_methods(cart)
-
- {:noreply,
- socket
- |> assign(:cart, cart)
- |> assign(:shipping_methods, shipping_methods)}
- end
-
- @impl true
- def handle_info({:item_added, cart, _item}, socket) do
- shipping_methods = Shop.get_available_shipping_methods(cart)
-
- {:noreply,
- socket
- |> assign(:cart, cart)
- |> assign(:shipping_methods, shipping_methods)}
- end
-
- @impl true
- def handle_info({:item_removed, cart, _item_id}, socket) do
- shipping_methods = Shop.get_available_shipping_methods(cart)
-
- {:noreply,
- socket
- |> assign(:cart, cart)
- |> assign(:shipping_methods, shipping_methods)}
- end
-
- @impl true
- def handle_info({:quantity_updated, cart, _item}, socket) do
- shipping_methods = Shop.get_available_shipping_methods(cart)
-
- {:noreply,
- socket
- |> assign(:cart, cart)
- |> assign(:shipping_methods, shipping_methods)}
- end
-
- @impl true
- def handle_info({:shipping_selected, cart}, socket) do
- {:noreply, assign(socket, :cart, cart)}
- end
-
- @impl true
- def handle_info({:payment_selected, cart}, socket) do
- {:noreply, assign(socket, :cart, cart)}
- end
-
- @impl true
- def handle_info({:cart_cleared, cart}, socket) do
- shipping_methods = Shop.get_available_shipping_methods(cart)
-
- {:noreply,
- socket
- |> assign(:cart, cart)
- |> assign(:shipping_methods, shipping_methods)}
- end
-
- @impl true
- def render(assigns) do
- ~H"""
-
-
-
- <%!-- Thumbnails from Storage --%>
- <% display_images = get_display_images(@product) %>
- <%= if display_images != [] do %>
-
- <%= for image_uuid <- display_images do %>
- <% thumb_url = get_storage_image_url(image_uuid, "thumbnail") %>
- <% large_url = get_storage_image_url(image_uuid, "large") %>
-
- <% end %>
-
- <% end %>
-
- <%!-- Legacy URL-based thumbnails (only show if no Storage images) --%>
- <%= if has_multiple_images?(@product) and get_display_images(@product) == [] do %>
-
- <%= for {image, _idx} <- Enum.with_index(@product.images || []) do %>
- <% url = image_url(image) %>
- <%= if url do %>
-
- <% end %>
- <% end %>
-
- <% end %>
-
-
- <%!-- Product Info --%>
-
-
-
{@localized_title}
-
- <%= if @product.vendor do %>
-
by {@product.vendor}
- <% end %>
-
-
- <%!-- Price --%>
-
- <%= if @price_affecting_specs != [] do %>
- <%!-- Has price-affecting specs - show calculated price --%>
-
- {format_price(@calculated_price, @currency)}
-
- <%= if @product.compare_at_price && Decimal.compare(@product.compare_at_price, @calculated_price) == :gt do %>
-
- {format_price(@product.compare_at_price, @currency)}
-
- <% end %>
- <% else %>
- <%!-- Simple product - show base price --%>
-
- {format_price(@product.price, @currency)}
-
- <%= if @product.compare_at_price && Decimal.compare(@product.compare_at_price, @product.price) == :gt do %>
-
- {format_price(@product.compare_at_price, @currency)}
-
-
- {discount_percentage(@product)}% OFF
-
- <% end %>
- <% end %>
-
-
- <%!-- Description --%>
- <%= if @localized_description do %>
- <.markdown content={@localized_description} sanitize={false} compact />
- <% end %>
-
- <%!-- Product Details --%>
-
-
-
- <%= if @product.weight_grams && @product.weight_grams > 0 do %>
-
- Weight:
- {@product.weight_grams}g
-
- <% end %>
-
- <%= if @product.category do %>
- <% cat_name = Translations.get(@product.category, :name, @current_language) %>
-
-
- <%!-- Featured Product (fallback image source) --%>
- <%= if @live_action == :edit do %>
-
-
- <%= if @product_options != [] do %>
-
- <% else %>
-
- <.icon name="hero-information-circle" class="w-4 h-4 inline mr-1" />
- No products with images in this category. Add product images to enable this option.
-
- <% end %>
-
-
- <% end %>
-
-
-
-
- <%!-- Card: Translations (only show when Languages module enabled with 2+ languages) --%>
- <%= if @show_translation_tabs do %>
-
-
-
Translations
-
- Translate category content for different languages. The default language uses the main fields above.
-
-
- <%!-- Language Tabs --%>
- <.translation_tabs
- languages={@enabled_languages}
- current_language={@current_translation_language}
- translations={@category_translations}
- translatable_fields={Translations.category_fields()}
- on_click="switch_language"
- />
-
- <%!-- Translation Fields for Current Language --%>
-
- Products in this category will show these options:
-
-
- <%= for opt <- @merged_preview do %>
-
- {opt["label"]}
- <%= if opt["required"] do %>
- *
- <% end %>
-
- <% end %>
- <%= if @merged_preview == [] do %>
- No options defined
- <% end %>
-
- After placing your order, we'll send a confirmation email to verify your address.
- Check your inbox and click the link to activate your account and track your order.
-
-
- """
- end
-
- # Components
-
- defp payment_step(assigns) do
- ~H"""
-
-
-
Select Payment Method
-
-
- <%= for option <- @payment_options do %>
-
- <% end %>
-
-
-
-
-
-
-
- """
- end
-
- defp billing_step(assigns) do
- ~H"""
-
-
-
- <%= if @is_guest or @billing_profiles == [] do %>
- Billing Information
- <% else %>
- Select Billing Profile
- <% end %>
-
-
- <%= if @use_new_profile do %>
- <%!-- Guest checkout or no profiles - show billing form --%>
- <.billing_form
- billing_data={@billing_data}
- form_errors={@form_errors}
- countries={@countries}
- />
- <% else %>
- <%!-- Authenticated user with multiple profiles - show selector --%>
- <.profile_selector
- billing_profiles={@billing_profiles}
- selected_profile_uuid={@selected_profile_uuid}
- needs_profile_selection={@needs_profile_selection}
- />
- <% end %>
-
-
- <%= if length(@payment_options) > 1 do %>
-
- <% else %>
-
- <% end %>
-
-
-
-
- """
- end
-
- defp profile_selector(assigns) do
- ~H"""
-
- <%!-- Show info alert when multiple profiles exist without a default --%>
- <%= if @needs_profile_selection do %>
-
- <.icon name="hero-information-circle" class="w-5 h-5" />
-
- You have multiple billing profiles. Please select one or <.link
- navigate={Routes.path("/dashboard/billing-profiles")}
- class="link"
- >
- set a default in your account settings
- .
-
-
- <% end %>
-
- <%= for profile <- @billing_profiles do %>
-
- Each config defines keyword filters and category rules for CSV imports.
- The default config is used when no specific config is selected during import.
-
Add your first import configuration to get started
-
- <% else %>
-
- <%= for config <- @configs do %>
-
-
-
-
- {config.name}
- <%= if config.is_default do %>
- Default
- <% end %>
- <%= if config.active do %>
- Active
- <% else %>
- Inactive
- <% end %>
- <%= if config.skip_filter do %>
- Skip Filter
- <% end %>
- <%= if config.download_images do %>
- Download Images
- <% end %>
-
- Found {@csv_analysis.total_products} products with {@csv_analysis.total_variants} variants
-
- <%= if @csv_analysis.total_skipped > 0 do %>
-
- {@csv_analysis.total_skipped} products filtered out by import config
-
- <% end %>
-
-
-
- <%= if @option_mappings == [] do %>
-
- <.icon name="hero-exclamation-triangle" class="w-5 h-5" />
- No options found in CSV file. You can proceed with basic import.
-
- <% else %>
-
- <%= for {mapping, index} <- Enum.with_index(@option_mappings) do %>
- <.render_mapping_card mapping={mapping} index={index} global_options={@global_options} />
- <% end %>
-
- <% end %>
-
- <%!-- Action Buttons --%>
-
-
-
- <%= if @option_mappings != [] do %>
-
- <% end %>
-
-
- """
- end
-
- defp render_mapping_card(assigns) do
- ~H"""
-
-
-
- <%!-- CSV Option Info --%>
-
-
{@mapping.csv_name}
-
- Position {@mapping.csv_position} · {@mapping.csv_values |> length()} values
-
-
- <%= for value <- Enum.take(@mapping.csv_values, 5) do %>
- {value}
- <% end %>
- <%= if length(@mapping.csv_values) > 5 do %>
-
- +{length(@mapping.csv_values) - 5} more
-
- <% end %>
-
-
-
- <%!-- Mapping Config --%>
-
-
-
- <%= if @mapping.source_key do %>
-
- <% end %>
-
-
-
- <%!-- New Values Warning --%>
- <%= if @mapping.source_key && @mapping.new_values != [] do %>
-
-
-
-
- <.icon name="hero-exclamation-triangle" class="w-4 h-4 inline" />
- {length(@mapping.new_values)} new values not in global option
-
-
- <%= for value <- Enum.take(@mapping.new_values, 3) do %>
- {value}
- <% end %>
- <%= if length(@mapping.new_values) > 3 do %>
- +{length(@mapping.new_values) - 3}
- <% end %>
-
-
-
-
- <% end %>
-
-
- """
- end
-
- defp render_confirm_step(assigns) do
- ~H"""
-
- <% end %>
- """
- end
-
- defp get_global_option_label(%{"label" => label}) when is_binary(label), do: label
-
- defp get_global_option_label(%{"label" => label}) when is_map(label),
- do: Map.get(label, "en", "")
-
- defp get_global_option_label(_), do: ""
-
- defp status_badge(assigns) do
- ~H"""
- "badge-neutral"
- "processing" -> "badge-info"
- "completed" -> "badge-success"
- "failed" -> "badge-error"
- _ -> "badge-ghost"
- end
- ]}>
- {@status}
-
- """
- end
-
- defp format_datetime(nil), do: "-"
-
- defp format_datetime(datetime) do
- Calendar.strftime(datetime, "%b %d, %Y %H:%M")
- end
-
- defp error_to_string(:too_large), do: "File is too large (max 50MB)"
- defp error_to_string(:not_accepted), do: "Only CSV files are accepted"
- defp error_to_string(:too_many_files), do: "Only one file at a time"
- defp error_to_string(err), do: inspect(err)
-end
diff --git a/lib/modules/shop/web/option_state.ex b/lib/modules/shop/web/option_state.ex
deleted file mode 100644
index 96d81d846..000000000
--- a/lib/modules/shop/web/option_state.ex
+++ /dev/null
@@ -1,445 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Web.OptionState do
- @moduledoc """
- Encapsulates option-related state for product form.
-
- This module manages all option-related data in a single struct,
- replacing the multiple assigns previously used in product_form.ex:
- - `new_value_inputs` -> `state.new_inputs`
- - `selected_option_values` -> `state.selected`
- - `original_option_values` -> `state.available`
- - `metadata["_price_modifiers"]` -> `state.modifiers`
- - `option_schema` -> `state.schema`
-
- ## Usage
-
- # Initialize state from product and schema
- state = OptionState.new(product, option_schema)
-
- # Toggle a value selection
- state = OptionState.toggle_value(state, "size", "M", ["S", "M", "L"])
-
- # Add a new custom value
- state = OptionState.add_value(state, "size", "XL")
-
- # Remove a value
- state = OptionState.remove_value(state, "size", "XL")
-
- # Update a price modifier
- state = OptionState.update_modifier(state, "size", "M", "5.00")
-
- # Convert back to metadata for saving
- metadata = OptionState.to_metadata(state)
- """
-
- defstruct [
- # Merged global + category option schema
- schema: [],
- # All available values per option key (original + manually added)
- available: %{},
- # Currently selected values per option key
- selected: %{},
- # Price modifiers per option/value (string format)
- modifiers: %{},
- # Temporary input field values for "add value" inputs
- new_inputs: %{}
- ]
-
- @type t :: %__MODULE__{
- schema: list(map()),
- available: %{String.t() => list(String.t())},
- selected: %{String.t() => list(String.t())},
- modifiers: %{String.t() => %{String.t() => String.t()}},
- new_inputs: %{String.t() => String.t()}
- }
-
- @doc """
- Creates a new OptionState from a product and option schema.
-
- ## Examples
-
- product = %Product{metadata: %{"_option_values" => %{"size" => ["M", "L"]}}}
- schema = [%{"key" => "size", "type" => "select", "options" => ["S", "M", "L"]}]
-
- state = OptionState.new(product, schema)
- # => %OptionState{
- # schema: [...],
- # available: %{"size" => ["S", "M", "L"]},
- # selected: %{"size" => ["M", "L"]},
- # modifiers: %{},
- # new_inputs: %{}
- # }
- """
- def new(product, option_schema) when is_list(option_schema) do
- metadata = (product && product.metadata) || %{}
- option_values = Map.get(metadata, "_option_values", %{})
- price_modifiers = Map.get(metadata, "_price_modifiers", %{})
-
- # Build available values from option_values (imported/saved)
- available = option_values
-
- # Selected = saved option values (if present) or all available
- selected = option_values
-
- %__MODULE__{
- schema: option_schema,
- available: available,
- selected: selected,
- modifiers: normalize_modifiers(price_modifiers),
- new_inputs: %{}
- }
- end
-
- def new(nil, option_schema), do: new(%{metadata: %{}}, option_schema)
-
- @doc """
- Toggles a value selection on/off.
-
- If the value is selected, it will be deselected. If not selected, it will be selected.
- The `all_values` parameter is used to determine when all values are selected
- (in which case the key is removed from selected map).
-
- ## Examples
-
- state = OptionState.toggle_value(state, "size", "M", ["S", "M", "L"])
- """
- def toggle_value(%__MODULE__{} = state, option_key, value, all_values)
- when is_binary(option_key) and is_binary(value) and is_list(all_values) do
- current = Map.get(state.selected, option_key, all_values)
-
- updated =
- if value in current do
- Enum.reject(current, &(&1 == value))
- else
- current ++ [value]
- end
-
- # Normalize selection state
- new_selected =
- cond do
- # None selected - keep explicit empty list
- updated == [] ->
- Map.put(state.selected, option_key, [])
-
- # All selected - remove key to indicate "all"
- Enum.sort(updated) == Enum.sort(all_values) ->
- Map.delete(state.selected, option_key)
-
- # Partial selection
- true ->
- Map.put(state.selected, option_key, updated)
- end
-
- %{state | selected: new_selected}
- end
-
- @doc """
- Adds a new value to an option.
-
- The value is added to both `available` and `selected` maps.
- Returns `{:ok, state}` or `{:error, reason}`.
-
- ## Examples
-
- {:ok, state} = OptionState.add_value(state, "size", "XL")
- {:error, "already exists"} = OptionState.add_value(state, "size", "M")
- """
- def add_value(%__MODULE__{} = state, option_key, value)
- when is_binary(option_key) and is_binary(value) do
- value = String.trim(value)
-
- if value == "" do
- {:error, "value cannot be empty"}
- else
- # Get all existing values (schema + available)
- schema_values = get_schema_values(state.schema, option_key)
- available_values = Map.get(state.available, option_key, [])
- all_existing = Enum.uniq(schema_values ++ available_values)
-
- if value in all_existing do
- {:error, "value '#{value}' already exists"}
- else
- # Add to available
- new_available =
- Map.update(state.available, option_key, [value], fn existing ->
- existing ++ [value]
- end)
-
- # Add to selected (new value is selected by default)
- current_selected = Map.get(state.selected, option_key, all_existing)
- new_selected = Map.put(state.selected, option_key, current_selected ++ [value])
-
- # Clear input
- new_inputs = Map.put(state.new_inputs, option_key, "")
-
- {:ok, %{state | available: new_available, selected: new_selected, new_inputs: new_inputs}}
- end
- end
- end
-
- @doc """
- Removes a value from an option.
-
- Removes from `available`, `selected`, and any associated modifiers.
-
- ## Examples
-
- state = OptionState.remove_value(state, "size", "XL")
- """
- def remove_value(%__MODULE__{} = state, option_key, value)
- when is_binary(option_key) and is_binary(value) do
- # Remove from available
- new_available =
- case Map.get(state.available, option_key) do
- nil ->
- state.available
-
- values ->
- updated = Enum.reject(values, &(&1 == value))
-
- if updated == [] do
- Map.delete(state.available, option_key)
- else
- Map.put(state.available, option_key, updated)
- end
- end
-
- # Remove from selected
- new_selected =
- case Map.get(state.selected, option_key) do
- nil ->
- state.selected
-
- values ->
- updated = Enum.reject(values, &(&1 == value))
-
- if updated == [] do
- Map.delete(state.selected, option_key)
- else
- Map.put(state.selected, option_key, updated)
- end
- end
-
- # Remove modifier
- new_modifiers = remove_modifier(state.modifiers, option_key, value)
-
- %{state | available: new_available, selected: new_selected, modifiers: new_modifiers}
- end
-
- @doc """
- Updates a price modifier for a specific option value.
-
- ## Examples
-
- state = OptionState.update_modifier(state, "size", "M", "5.00")
- """
- def update_modifier(%__MODULE__{} = state, option_key, value, modifier_value)
- when is_binary(option_key) and is_binary(value) do
- new_modifiers =
- if modifier_value == nil or modifier_value == "" or modifier_value == "0" do
- remove_modifier(state.modifiers, option_key, value)
- else
- option_mods = Map.get(state.modifiers, option_key, %{})
- option_mods = Map.put(option_mods, value, modifier_value)
- Map.put(state.modifiers, option_key, option_mods)
- end
-
- %{state | modifiers: new_modifiers}
- end
-
- @doc """
- Updates the new value input for an option key.
-
- ## Examples
-
- state = OptionState.update_new_input(state, "size", "XL")
- """
- def update_new_input(%__MODULE__{} = state, option_key, value)
- when is_binary(option_key) do
- %{state | new_inputs: Map.put(state.new_inputs, option_key, value || "")}
- end
-
- @doc """
- Converts the state back to a metadata map for saving.
-
- Returns a map with `_option_values` and `_price_modifiers` keys.
- Empty maps are omitted.
-
- ## Examples
-
- state = %OptionState{
- selected: %{"size" => ["M", "L"]},
- modifiers: %{"size" => %{"M" => "5.00"}}
- }
-
- OptionState.to_metadata(state)
- # => %{
- # "_option_values" => %{"size" => ["M", "L"]},
- # "_price_modifiers" => %{"size" => %{"M" => "5.00"}}
- # }
- """
- def to_metadata(%__MODULE__{} = state) do
- metadata = %{}
-
- # Add _option_values if present
- metadata =
- if state.available != %{} do
- Map.put(metadata, "_option_values", state.available)
- else
- metadata
- end
-
- # Add _price_modifiers if present
- metadata =
- if state.modifiers != %{} do
- Map.put(metadata, "_price_modifiers", state.modifiers)
- else
- metadata
- end
-
- metadata
- end
-
- @doc """
- Checks if a value is currently selected for an option.
-
- ## Examples
-
- OptionState.value_selected?(state, "size", "M", ["S", "M", "L"])
- # => true
- """
- def value_selected?(%__MODULE__{} = state, option_key, value, all_values) do
- case Map.get(state.selected, option_key) do
- nil -> value in all_values
- selected -> value in selected
- end
- end
-
- @doc """
- Gets all values available for an option (schema + custom added).
-
- ## Examples
-
- OptionState.get_all_values(state, "size")
- # => ["S", "M", "L", "XL"]
- """
- def get_all_values(%__MODULE__{} = state, option_key) do
- schema_values = get_schema_values(state.schema, option_key)
- custom_values = Map.get(state.available, option_key, [])
- Enum.uniq(schema_values ++ custom_values)
- end
-
- @doc """
- Gets selected values for an option (or all if not explicitly set).
-
- ## Examples
-
- OptionState.get_selected_values(state, "size", ["S", "M", "L"])
- # => ["M", "L"]
- """
- def get_selected_values(%__MODULE__{} = state, option_key, all_values) do
- Map.get(state.selected, option_key, all_values)
- end
-
- @doc """
- Gets the modifier value for an option/value pair.
-
- ## Examples
-
- OptionState.get_modifier(state, "size", "M")
- # => "5.00"
- """
- def get_modifier(%__MODULE__{} = state, option_key, value) do
- get_in(state.modifiers, [option_key, value])
- end
-
- @doc """
- Checks if option has custom selection (not all values selected).
-
- ## Examples
-
- OptionState.has_custom_selection?(state, "size")
- # => true
- """
- def has_custom_selection?(%__MODULE__{} = state, option_key) do
- Map.has_key?(state.selected, option_key)
- end
-
- @doc """
- Adds a completely new option with an initial value.
-
- Returns `{:ok, state}` or `{:error, reason}`.
-
- ## Examples
-
- {:ok, state} = OptionState.add_new_option(state, "material", "Wood")
- """
- def add_new_option(%__MODULE__{} = state, option_key, value)
- when is_binary(option_key) and is_binary(value) do
- key = option_key |> String.trim() |> String.downcase() |> String.replace(~r/\s+/, "_")
- value = String.trim(value)
-
- cond do
- key == "" or value == "" ->
- {:error, "option key and value are required"}
-
- # Check if value already exists in this option
- value in get_all_values(state, key) ->
- {:error, "value '#{value}' already exists in '#{key}'"}
-
- # Check if this is adding to existing option
- Map.has_key?(state.available, key) or
- Enum.any?(state.schema, &(&1["key"] == key)) ->
- # Add value to existing option
- add_value(state, key, value)
-
- # New option entirely
- true ->
- new_available = Map.put(state.available, key, [value])
- new_selected = Map.put(state.selected, key, [value])
- {:ok, %{state | available: new_available, selected: new_selected}}
- end
- end
-
- # Private helpers
-
- defp get_schema_values(schema, option_key) do
- case Enum.find(schema, &(&1["key"] == option_key)) do
- nil -> []
- opt -> opt["options"] || []
- end
- end
-
- defp remove_modifier(modifiers, option_key, value) do
- case Map.get(modifiers, option_key) do
- nil ->
- modifiers
-
- option_mods ->
- updated = Map.delete(option_mods, value)
-
- if updated == %{} do
- Map.delete(modifiers, option_key)
- else
- Map.put(modifiers, option_key, updated)
- end
- end
- end
-
- # Normalize modifiers to ensure all values are strings
- defp normalize_modifiers(modifiers) when is_map(modifiers) do
- Enum.map(modifiers, fn {key, values} when is_map(values) ->
- normalized_values =
- Enum.map(values, fn
- {k, v} when is_binary(v) -> {k, v}
- {k, %{"value" => v}} when is_binary(v) -> {k, v}
- {k, _} -> {k, "0"}
- end)
- |> Map.new()
-
- {key, normalized_values}
- end)
- |> Map.new()
- end
-
- defp normalize_modifiers(_), do: %{}
-end
diff --git a/lib/modules/shop/web/options_settings.ex b/lib/modules/shop/web/options_settings.ex
deleted file mode 100644
index e4ff60d0a..000000000
--- a/lib/modules/shop/web/options_settings.ex
+++ /dev/null
@@ -1,885 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Web.OptionsSettings do
- @moduledoc """
- Global product options settings LiveView.
-
- Allows administrators to manage global options that apply to all products.
- Supports both fixed and percentage-based price modifiers.
- """
-
- use PhoenixKitWeb, :live_view
-
- alias PhoenixKit.Modules.Shop.Options
- alias PhoenixKit.Modules.Shop.OptionTypes
- alias PhoenixKit.Utils.Routes
-
- @impl true
- def mount(_params, _session, socket) do
- options = Options.get_global_options()
-
- socket =
- socket
- |> assign(:page_title, "Product Options")
- |> assign(:options, options)
- |> assign(:show_modal, false)
- |> assign(:editing_option, nil)
- |> assign(:form_data, initial_form_data())
- |> assign(:supported_types, OptionTypes.supported_types())
- |> assign(:modifier_types, OptionTypes.modifier_types())
-
- {:ok, socket}
- end
-
- @impl true
- def handle_event("show_add_modal", _params, socket) do
- {:noreply,
- socket
- |> assign(:show_modal, true)
- |> assign(:editing_option, nil)
- |> assign(:form_data, initial_form_data())}
- end
-
- @impl true
- def handle_event("show_edit_modal", %{"key" => key}, socket) do
- option = Enum.find(socket.assigns.options, &(&1["key"] == key))
-
- if option do
- form_data = %{
- key: option["key"],
- label: option["label"],
- type: option["type"],
- options: option["options"] || [],
- required: option["required"] || false,
- unit: option["unit"] || "",
- affects_price: option["affects_price"] || false,
- modifier_type: option["modifier_type"] || "fixed",
- price_modifiers: option["price_modifiers"] || %{},
- allow_override: option["allow_override"] || false,
- enabled: Map.get(option, "enabled", true)
- }
-
- {:noreply,
- socket
- |> assign(:show_modal, true)
- |> assign(:editing_option, option)
- |> assign(:form_data, form_data)}
- else
- {:noreply, socket}
- end
- end
-
- @impl true
- def handle_event("close_modal", _params, socket) do
- {:noreply,
- socket
- |> assign(:show_modal, false)
- |> assign(:editing_option, nil)
- |> assign(:form_data, initial_form_data())}
- end
-
- @impl true
- def handle_event("validate_form", %{"option" => params}, socket) do
- options = parse_options(params["options"])
-
- form_data = %{
- key: params["key"] || "",
- label: params["label"] || "",
- type: params["type"] || "text",
- options: options,
- required: params["required"] == "true",
- unit: params["unit"] || "",
- affects_price: params["affects_price"] == "true",
- modifier_type: params["modifier_type"] || "fixed",
- price_modifiers: parse_price_modifiers(params["price_modifiers"], options),
- allow_override: params["allow_override"] == "true"
- }
-
- # Auto-generate key from label if creating new
- form_data =
- if socket.assigns.editing_option == nil and form_data.key == "" do
- %{form_data | key: slugify_key(form_data.label)}
- else
- form_data
- end
-
- {:noreply, assign(socket, :form_data, form_data)}
- end
-
- @impl true
- def handle_event("toggle_affects_price", _params, socket) do
- form_data = socket.assigns.form_data
- updated = %{form_data | affects_price: !form_data.affects_price}
-
- # Initialize price modifiers with "0" for all options when enabling
- updated =
- if updated.affects_price and map_size(updated.price_modifiers) == 0 do
- modifiers = Map.new(updated.options, fn opt -> {opt, "0"} end)
- %{updated | price_modifiers: modifiers}
- else
- updated
- end
-
- {:noreply, assign(socket, :form_data, updated)}
- end
-
- @impl true
- def handle_event("set_modifier_type", %{"type" => type}, socket) do
- form_data = socket.assigns.form_data
- updated = %{form_data | modifier_type: type}
- {:noreply, assign(socket, :form_data, updated)}
- end
-
- @impl true
- def handle_event("toggle_allow_override", _params, socket) do
- form_data = socket.assigns.form_data
- updated = %{form_data | allow_override: !form_data.allow_override}
- {:noreply, assign(socket, :form_data, updated)}
- end
-
- @impl true
- def handle_event("save_option", %{"option" => params}, socket) do
- form_data = parse_form_params(params)
- opt = build_option(form_data)
-
- current = socket.assigns.options
- editing = socket.assigns.editing_option
-
- result =
- if editing do
- updated =
- Enum.map(current, fn o ->
- if o["key"] == editing["key"], do: Map.merge(o, opt), else: o
- end)
-
- Options.update_global_options(updated)
- else
- opt = Map.put(opt, "position", length(current))
- Options.add_global_option(opt)
- end
-
- case result do
- {:ok, _} ->
- {:noreply,
- socket
- |> assign(:options, Options.get_global_options())
- |> assign(:show_modal, false)
- |> assign(:editing_option, nil)
- |> assign(:form_data, initial_form_data())
- |> put_flash(:info, if(editing, do: "Option updated", else: "Option created"))}
-
- {:error, reason} ->
- {:noreply, put_flash(socket, :error, "Error: #{reason}")}
- end
- end
-
- @impl true
- def handle_event("delete_option", %{"key" => key}, socket) do
- case Options.remove_global_option(key) do
- {:ok, _} ->
- {:noreply,
- socket
- |> assign(:options, Options.get_global_options())
- |> put_flash(:info, "Option deleted")}
-
- {:error, reason} ->
- {:noreply, put_flash(socket, :error, "Error: #{reason}")}
- end
- end
-
- @impl true
- def handle_event("toggle_enabled", %{"key" => key}, socket) do
- current = socket.assigns.options
-
- updated =
- Enum.map(current, fn opt ->
- if opt["key"] == key do
- current_enabled = Map.get(opt, "enabled", true)
- Map.put(opt, "enabled", !current_enabled)
- else
- opt
- end
- end)
-
- case Options.update_global_options(updated) do
- {:ok, _} ->
- toggled = Enum.find(updated, &(&1["key"] == key))
- label = if Map.get(toggled, "enabled", true), do: "enabled", else: "disabled"
-
- {:noreply,
- socket
- |> assign(:options, Options.get_global_options())
- |> put_flash(:info, "Option #{key} #{label}")}
-
- {:error, reason} ->
- {:noreply, put_flash(socket, :error, "Error: #{reason}")}
- end
- end
-
- @impl true
- def handle_event("reorder_options", %{"ordered_ids" => ordered_keys}, socket) do
- current = socket.assigns.options
-
- # Reorder options based on new order
- reordered =
- ordered_keys
- |> Enum.with_index()
- |> Enum.map(fn {key, idx} ->
- opt = Enum.find(current, &(&1["key"] == key))
- if opt, do: Map.put(opt, "position", idx), else: nil
- end)
- |> Enum.reject(&is_nil/1)
-
- case Options.update_global_options(reordered) do
- {:ok, _} ->
- {:noreply, assign(socket, :options, Options.get_global_options())}
-
- {:error, reason} ->
- {:noreply, put_flash(socket, :error, "Reorder failed: #{reason}")}
- end
- end
-
- @impl true
- def handle_event("add_option", _params, socket) do
- form_data = socket.assigns.form_data
- updated = %{form_data | options: form_data.options ++ [""]}
- {:noreply, assign(socket, :form_data, updated)}
- end
-
- @impl true
- def handle_event("remove_option", %{"index" => idx}, socket) do
- form_data = socket.assigns.form_data
- index = String.to_integer(idx)
- updated = %{form_data | options: List.delete_at(form_data.options, index)}
- {:noreply, assign(socket, :form_data, updated)}
- end
-
- @impl true
- def render(assigns) do
- ~H"""
-
-
- <.admin_page_header
- back={Routes.path("/admin/shop/settings")}
- title="Product Options"
- subtitle="Define global options that apply to all products"
- />
-
- <%!-- Controls Bar --%>
-
-
-
- <.icon name="hero-information-circle" class="w-4 h-4" />
-
- Global options apply to all products. Categories can override or add their own.
-
-
-
-
-
-
- <%!-- Options List --%>
-
-
-
-
- <.icon name="hero-adjustments-horizontal" class="w-5 h-5" /> Global Options
-
- <%= for opt <- @options do %>
- <% enabled = Map.get(opt, "enabled", true) != false %>
-
- <%!-- Content --%>
-
-
-
- {opt["label"]}
-
- {opt["type"]}
- <%= if !enabled do %>
- Disabled
- <% end %>
- <%= if opt["required"] do %>
- Required
- <% end %>
- <%= if opt["unit"] do %>
- {opt["unit"]}
- <% end %>
- <%= if opt["affects_price"] do %>
-
- {opt["modifier_type"] || "fixed"}
-
- <%= if opt["allow_override"] do %>
- Override
- <% end %>
- <% end %>
-
-
-
- {opt["key"]}
-
- <%= if opt["options"] && opt["options"] != [] do %>
-
- {format_options_with_modifiers(opt)}
-
- <% end %>
-
-
- <%!-- Options (for select/multiselect) --%>
- <%= if @form_data.type in ["select", "multiselect"] do %>
-
-
-
- <%= for {opt, idx} <- Enum.with_index(@form_data.options) do %>
-
-
-
-
- <% end %>
- <%= if @form_data.options == [] do %>
-
Add at least one option
- <% end %>
-
-
-
- <%!-- Affects Price Toggle --%>
-
-
-
-
-
- <%!-- Modifier Type and Price Modifiers (when affects_price is true) --%>
- <%= if @form_data.affects_price and @form_data.options != [] do %>
- <%!-- Modifier Type Selector --%>
-
-
-
-
-
-
-
-
- <%!-- Price Modifiers --%>
-
-
-
-
- <%= if @form_data.modifier_type == "percent" do %>
- Set percentage adjustment for each option (use 0 for no change)
- <% else %>
- Set price adjustment for each option (use 0 for no change)
- <% end %>
-
- <%= for opt <- @form_data.options do %>
-
- {opt}
- +
-
-
- <%= if @form_data.modifier_type == "percent" do %>
- %
- <% end %>
-
-
- <% end %>
-
-
-
- <%!-- Allow Override Toggle --%>
-
-
-
- <% end %>
- <% end %>
-
- <%!-- Warning for non-select types with affects_price --%>
- <%= if @form_data.affects_price && @form_data.type not in ["select", "multiselect"] do %>
-
- <.icon name="hero-exclamation-triangle" class="w-5 h-5" />
- Price modifiers only work with Select or Multiselect types
-
- <% end %>
-
- <%!-- Unit --%>
-
-
-
-
-
- <%!-- Required --%>
-
-
-
-
- <%!-- Actions --%>
-
-
-
-
-
-
-
-
- <% end %>
-
- """
- end
-
- # Private helpers
-
- defp initial_form_data do
- %{
- key: "",
- label: "",
- type: "text",
- options: [],
- required: false,
- unit: "",
- affects_price: false,
- modifier_type: "fixed",
- price_modifiers: %{},
- allow_override: false,
- enabled: true
- }
- end
-
- defp slugify_key(""), do: ""
-
- defp slugify_key(text) do
- text
- |> String.downcase()
- |> String.replace(~r/[^a-z0-9\s]/, "")
- |> String.replace(~r/\s+/, "_")
- |> String.replace(~r/_+/, "_")
- |> String.trim("_")
- end
-
- defp parse_form_params(params) do
- options = parse_options(params["options"])
-
- %{
- key: params["key"] || "",
- label: params["label"] || "",
- type: params["type"] || "text",
- options: options,
- required: params["required"] == "true",
- unit: params["unit"] || "",
- affects_price: params["affects_price"] == "true",
- modifier_type: params["modifier_type"] || "fixed",
- price_modifiers: parse_price_modifiers(params["price_modifiers"], options),
- allow_override: params["allow_override"] == "true"
- }
- end
-
- defp build_option(form_data) do
- key = if form_data.key == "", do: slugify_key(form_data.label), else: form_data.key
-
- %{
- "key" => key,
- "label" => form_data.label,
- "type" => form_data.type,
- "required" => form_data.required
- }
- |> maybe_put_options(form_data)
- |> maybe_put_unit(form_data)
- |> maybe_put_price_modifiers(form_data)
- end
-
- defp maybe_put_options(opt, %{type: type, options: options})
- when type in ["select", "multiselect"],
- do: Map.put(opt, "options", options)
-
- defp maybe_put_options(opt, _), do: opt
-
- defp maybe_put_unit(opt, %{unit: ""}), do: opt
- defp maybe_put_unit(opt, %{unit: unit}), do: Map.put(opt, "unit", unit)
-
- defp maybe_put_price_modifiers(
- opt,
- %{
- type: type,
- affects_price: true,
- modifier_type: modifier_type,
- price_modifiers: mods,
- allow_override: allow_override
- }
- )
- when type in ["select", "multiselect"] do
- opt
- |> Map.put("affects_price", true)
- |> Map.put("modifier_type", modifier_type)
- |> Map.put("price_modifiers", mods)
- |> Map.put("allow_override", allow_override)
- end
-
- defp maybe_put_price_modifiers(opt, _), do: Map.put(opt, "affects_price", false)
-
- defp parse_options(nil), do: []
-
- defp parse_options(options) when is_map(options) do
- options
- # Filter out Phoenix LiveView's hidden _unused_ fields
- |> Enum.reject(fn {k, _v} -> String.starts_with?(k, "_unused") end)
- |> Enum.sort_by(fn {k, _v} ->
- case Integer.parse(k) do
- {num, ""} -> num
- _ -> 0
- end
- end)
- |> Enum.map(fn {_k, v} -> v end)
- |> Enum.reject(&(&1 == ""))
- end
-
- defp parse_options(options) when is_list(options), do: options
- defp parse_options(_), do: []
-
- defp parse_price_modifiers(nil, _options), do: %{}
-
- defp parse_price_modifiers(modifiers, options) when is_map(modifiers) do
- # Only keep modifiers for valid options, with valid decimal values
- Enum.reduce(options, %{}, fn opt, acc ->
- value = Map.get(modifiers, opt, "0")
- # Normalize the value to a valid decimal string
- normalized = normalize_price_modifier(value)
- Map.put(acc, opt, normalized)
- end)
- end
-
- defp parse_price_modifiers(_, _), do: %{}
-
- defp normalize_price_modifier(value) when is_binary(value) do
- case Decimal.parse(value) do
- {decimal, ""} -> Decimal.to_string(decimal)
- _ -> "0"
- end
- end
-
- defp normalize_price_modifier(_), do: "0"
-
- defp format_options_with_modifiers(%{
- "affects_price" => true,
- "options" => options,
- "modifier_type" => modifier_type,
- "price_modifiers" => modifiers
- })
- when is_list(options) and is_map(modifiers) do
- suffix = if modifier_type == "percent", do: "%", else: ""
-
- Enum.map_join(options, ", ", fn opt ->
- case Map.get(modifiers, opt) do
- nil -> opt
- "0" -> opt
- mod -> "#{opt} (+#{mod}#{suffix})"
- end
- end)
- end
-
- defp format_options_with_modifiers(%{
- "affects_price" => true,
- "options" => options,
- "price_modifiers" => modifiers
- })
- when is_list(options) and is_map(modifiers) do
- # Default to fixed for backward compatibility
- Enum.map_join(options, ", ", fn opt ->
- case Map.get(modifiers, opt) do
- nil -> opt
- "0" -> opt
- mod -> "#{opt} (+#{mod})"
- end
- end)
- end
-
- defp format_options_with_modifiers(%{"options" => options}) when is_list(options) do
- Enum.join(options, ", ")
- end
-
- defp format_options_with_modifiers(_), do: ""
-end
diff --git a/lib/modules/shop/web/plugs/shop_session.ex b/lib/modules/shop/web/plugs/shop_session.ex
deleted file mode 100644
index 8c67ca26f..000000000
--- a/lib/modules/shop/web/plugs/shop_session.ex
+++ /dev/null
@@ -1,59 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Web.Plugs.ShopSession do
- @moduledoc """
- Plug that ensures a persistent shop session ID exists.
-
- This plug generates a unique session ID for guest users and stores it
- both in a dedicated cookie AND in the Phoenix session. This ensures
- the same cart is used across different pages.
- """
-
- import Plug.Conn
-
- alias PhoenixKit.Modules.Shop
-
- @cookie_name "shop_session_id"
- # 30 days
- @cookie_max_age 60 * 60 * 24 * 30
-
- def init(opts), do: opts
-
- def call(conn, _opts) do
- if Shop.enabled?() do
- # First try to get from cookie (most reliable)
- # Then fall back to session
- session_id = get_shop_session_id(conn)
-
- case session_id do
- nil ->
- new_id = generate_session_id()
-
- conn
- |> put_resp_cookie(@cookie_name, new_id, max_age: @cookie_max_age, http_only: true)
- |> put_session("shop_session_id", new_id)
-
- existing_id ->
- put_session(conn, "shop_session_id", existing_id)
- end
- else
- conn
- end
- end
-
- defp get_shop_session_id(conn) do
- # Try cookie first
- conn = fetch_cookies(conn)
-
- case conn.cookies[@cookie_name] do
- nil ->
- # Fall back to session
- get_session(conn, "shop_session_id")
-
- cookie_value ->
- cookie_value
- end
- end
-
- defp generate_session_id do
- :crypto.strong_rand_bytes(32) |> Base.url_encode64(padding: false)
- end
-end
diff --git a/lib/modules/shop/web/product_detail.ex b/lib/modules/shop/web/product_detail.ex
deleted file mode 100644
index 53a4576bc..000000000
--- a/lib/modules/shop/web/product_detail.ex
+++ /dev/null
@@ -1,855 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Web.ProductDetail do
- @moduledoc """
- Product detail view LiveView for Shop module.
- """
-
- use PhoenixKitWeb, :live_view
-
- alias PhoenixKit.Modules.Billing.Currency
- alias PhoenixKit.Modules.Languages
- alias PhoenixKit.Modules.Languages.DialectMapper
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.Options
- alias PhoenixKit.Modules.Shop.Translations
- alias PhoenixKit.Modules.Storage
- alias PhoenixKit.Modules.Storage.URLSigner
- alias PhoenixKit.Utils.Routes
-
- @impl true
- def mount(%{"id" => id}, _session, socket) do
- product = Shop.get_product!(id, preload: [:category])
- currency = Shop.get_default_currency()
-
- # Get price-affecting specs for admin view
- price_affecting_specs = Options.get_price_affecting_specs_for_product(product)
-
- # Get all selectable specs for admin view (includes all schema options, not filtered)
- selectable_specs = Options.get_all_selectable_specs_for_admin(product)
-
- {min_price, max_price} =
- Options.get_price_range(price_affecting_specs, product.price, product.metadata)
-
- default_lang = Translations.default_language()
- product_title = Translations.get(product, :title, default_lang)
- product_slug = Translations.get(product, :slug, default_lang)
- product_description = Translations.get(product, :description, default_lang)
- product_body_html = Translations.get(product, :body_html, default_lang)
- product_seo_title = Translations.get(product, :seo_title, default_lang)
- product_seo_description = Translations.get(product, :seo_description, default_lang)
-
- # Get enabled languages for preview switcher
- available_languages = get_available_languages()
-
- # Get all images for the gallery
- all_images = get_all_product_images(product)
- first_image_uuid = get_first_image_uuid(product)
-
- # Auto-select first value of each option for immediate add-to-cart
- # Uses selectable_specs to include both metadata and schema-defined options
- selected_specs =
- selectable_specs
- |> Enum.map(fn spec ->
- key = spec["key"]
- values = get_option_values(product, spec)
- {key, List.first(values)}
- end)
- |> Enum.reject(fn {_key, value} -> is_nil(value) end)
- |> Enum.into(%{})
-
- socket =
- socket
- |> assign(:page_title, product_title)
- |> assign(:product, product)
- |> assign(:product_title, product_title)
- |> assign(:product_slug, product_slug)
- |> assign(:product_description, product_description)
- |> assign(:product_body_html, product_body_html)
- |> assign(:product_seo_title, product_seo_title)
- |> assign(:product_seo_description, product_seo_description)
- |> assign(:current_language, default_lang)
- |> assign(:available_languages, available_languages)
- |> assign(:currency, currency)
- |> assign(:price_affecting_specs, price_affecting_specs)
- |> assign(:min_price, min_price)
- |> assign(:max_price, max_price)
- |> assign(:all_images, all_images)
- |> assign(:selected_image_uuid, first_image_uuid)
- |> assign(:selectable_specs, selectable_specs)
- |> assign(:selected_specs, selected_specs)
- |> assign(:show_delete_modal, false)
- |> assign(:delete_media_checked, false)
-
- {:ok, socket}
- end
-
- @impl true
- def handle_event("confirm_delete", _params, socket) do
- {:noreply, socket |> assign(:show_delete_modal, true) |> assign(:delete_media_checked, false)}
- end
-
- @impl true
- def handle_event("cancel_delete", _params, socket) do
- {:noreply,
- socket |> assign(:show_delete_modal, false) |> assign(:delete_media_checked, false)}
- end
-
- @impl true
- def handle_event("toggle_delete_media", _params, socket) do
- {:noreply, assign(socket, :delete_media_checked, !socket.assigns.delete_media_checked)}
- end
-
- @impl true
- def handle_event("delete", _params, socket) do
- product = socket.assigns.product
-
- file_uuids =
- if socket.assigns.delete_media_checked,
- do: Shop.collect_product_file_uuids(product),
- else: []
-
- case Shop.delete_product(product) do
- {:ok, _} ->
- if file_uuids != [], do: Storage.queue_file_cleanup(file_uuids)
-
- {:noreply,
- socket
- |> put_flash(:info, "Product deleted")
- |> push_navigate(to: Routes.path("/admin/shop/products"))}
-
- {:error, _} ->
- {:noreply, put_flash(socket, :error, "Failed to delete product")}
- end
- end
-
- @impl true
- def handle_event("select_image", %{"uuid" => image_uuid}, socket) do
- {:noreply, assign(socket, :selected_image_uuid, image_uuid)}
- end
-
- @impl true
- def handle_event("select_option", %{"key" => key, "value" => value}, socket) do
- product = socket.assigns.product
- selected_specs = Map.put(socket.assigns.selected_specs, key, value)
-
- # Check for image mapping - update selected_image_uuid if mapping exists
- selected_image_uuid =
- get_mapped_image_uuid(product, key, value, socket.assigns.selected_image_uuid)
-
- {:noreply,
- socket
- |> assign(:selected_specs, selected_specs)
- |> assign(:selected_image_uuid, selected_image_uuid)}
- end
-
- @impl true
- def handle_event("switch_preview_language", %{"language" => language}, socket) do
- product = socket.assigns.product
-
- # Update localized content for the selected language
- product_title = Translations.get(product, :title, language)
- product_slug = Translations.get(product, :slug, language)
- product_description = Translations.get(product, :description, language)
- product_body_html = Translations.get(product, :body_html, language)
- product_seo_title = Translations.get(product, :seo_title, language)
- product_seo_description = Translations.get(product, :seo_description, language)
-
- socket =
- socket
- |> assign(:current_language, language)
- |> assign(:product_title, product_title)
- |> assign(:product_slug, product_slug)
- |> assign(:product_description, product_description)
- |> assign(:product_body_html, product_body_html)
- |> assign(:product_seo_title, product_seo_title)
- |> assign(:product_seo_description, product_seo_description)
-
- {:noreply, socket}
- end
-
- @impl true
- def render(assigns) do
- ~H"""
-
-
- <% end %>
-
- <%!-- Available Option Values Section --%>
- <% # Use original_option_values for showing all available values (persists across unchecks)
- # Use current metadata for determining which are currently selected
- original_values = assigns[:original_option_values] || %{}
- current_option_values = @metadata["_option_values"] || %{}
-
- # Merge original + current to get all known values
- all_known_values =
- Map.merge(original_values, current_option_values, fn _k, orig, curr ->
- Enum.uniq(orig ++ curr)
- end)
-
- # 1. ALL select/multiselect options from schema (even with empty options list)
- # This allows adding custom values to options defined in category schema
- schema_options =
- Enum.filter(@option_schema, fn opt ->
- opt["type"] in ["select", "multiselect"]
- end)
-
- # 2. Options from _option_values (imported) that are NOT already in schema
- schema_keys_with_values = Enum.map(schema_options, & &1["key"])
-
- option_slots = @metadata["_option_slots"] || []
-
- imported_options =
- all_known_values
- |> Enum.reject(fn {key, _} -> key in schema_keys_with_values end)
- |> Enum.map(fn {key, values} ->
- # Find option in schema (may exist but with empty options list)
- schema_opt = Enum.find(@option_schema, &(&1["key"] == key))
- # Find label from _option_slots (e.g. "Liquid Color" for slot "liquid_color")
- slot_label =
- Enum.find_value(option_slots, fn slot ->
- if slot["slot"] == key, do: slot["label"]
- end)
-
- %{
- "key" => key,
- "label" => (schema_opt && schema_opt["label"]) || slot_label || humanize_key(key),
- "type" => (schema_opt && schema_opt["type"]) || "select",
- "options" => values,
- "imported" => true
- }
- end)
-
- # Combine: schema options first, then imported-only options
- all_select_options = schema_options ++ imported_options %>
- <%= if @live_action == :edit do %>
-
-
-
- <.icon name="hero-adjustments-horizontal" class="w-5 h-5" /> Available Options
-
-
- <%= if all_select_options != [] do %>
- Select which option values are available for this product.
- <% else %>
- Add custom options for this product.
- <% end %>
-
-
-
- <%= for option <- all_select_options do %>
- <% option_key = option["key"] %>
- <% # Determine all available values
- schema_values = option["options"] || []
- original_imported = Map.get(original_values, option_key, [])
- current_imported = Map.get(current_option_values, option_key, [])
- # Also include manually added values from socket assigns
- manually_added = Map.get(@original_option_values, option_key, [])
-
- # All values = schema values + manually added OR merged original+current imported
- all_values =
- if schema_values != [] do
- Enum.uniq(schema_values ++ manually_added)
- else
- Enum.uniq(original_imported ++ current_imported ++ manually_added)
- end
-
- # Apply stored order if exists
- stored_order = get_in(@metadata, ["_option_value_order", option_key])
-
- ordered_values =
- if stored_order do
- # Filter to only include values that still exist
- ordered_existing = Enum.filter(stored_order, &(&1 in all_values))
- # Add any new values not in stored order at the end
- new_values = Enum.reject(all_values, &(&1 in stored_order))
- ordered_existing ++ new_values
- else
- all_values
- end
-
- # Active values = from socket assigns (managed via phx-click, not form)
- # If selected_option_values has this key, use it; otherwise all are active
- active_values = Map.get(@selected_option_values, option_key, ordered_values)
-
- is_imported = option["imported"] == true
-
- is_editable =
- is_imported or schema_values == [] or option["allow_override"] == true
-
- has_custom_selection = Map.has_key?(@selected_option_values, option_key) %>
-
-
-
-
- {option["label"]}
- <%= if is_imported do %>
- Imported
- <% end %>
-
- <%= if has_custom_selection do %>
- Custom selection
- <% else %>
- All values
- <% end %>
-
-
- <%!-- Option values as draggable badges --%>
- <.draggable_list
- id={"option-values-#{option_key}"}
- items={ordered_values}
- item_id={fn value -> value end}
- on_reorder={"reorder_option_values:#{option_key}"}
- layout={:list}
- item_class="flex items-center gap-2 p-2 bg-base-100 rounded-lg border border-base-200 hover:bg-base-200"
- >
- <:item :let={value}>
- <% is_selected = value in active_values %>
-
-
- <%= if is_editable do %>
-
- <% end %>
-
-
-
-
- <%!-- Add new value input --%>
- <%= if is_editable do %>
- <% input_value = Map.get(assigns[:new_value_inputs] || %{}, option_key, "") %>
-
-
-
-
- <% end %>
-
- <% end %>
-
-
- <%!-- Add Option/Value Section --%>
-
Add Option or Value
-
- Enter an existing option key to add a new value, or a new key to create a new option.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- <% end %>
-
- <%!-- Option Price Modifiers Section --%>
- <% # Filter to only options that have actual values to display
- price_options_with_values =
- Enum.filter(@price_affecting_options, fn opt ->
- (opt["options"] || []) != []
- end)
-
- # Editable options: has allow_override flag AND has options
- editable_options =
- Enum.filter(price_options_with_values, fn opt ->
- opt["allow_override"] == true
- end)
-
- # Read-only options: without allow_override AND has price_modifiers
- readonly_options =
- price_options_with_values
- |> Enum.reject(fn opt -> opt["allow_override"] == true end)
- |> Enum.filter(fn opt -> (opt["price_modifiers"] || %{}) != %{} end)
-
- # Only show section if there's something to display
- has_schema_price_content = editable_options != [] or readonly_options != [] %>
- <%= if has_schema_price_content do %>
-
- Currency and tax configuration is managed in the
- <.link navigate={Routes.path("/admin/settings/billing")} class="link font-medium">
- Billing module settings
-
-
- Configure product filters shown on the storefront sidebar.
- Customers can filter by price, vendor, and product options.
-
-
- <%!-- Current Filters Table --%>
-
-
-
-
-
Filter
-
Type
-
Label
-
Enabled
-
-
-
-
- <%= for filter <- @storefront_filters do %>
-
-
{filter["key"]}
-
- {filter["type"]}
-
-
-
-
-
-
-
-
- <%= if filter["type"] == "metadata_option" do %>
-
- <% end %>
-
-
- <% end %>
-
-
-
-
- <%!-- Auto-discovered option keys --%>
- <%= if @discovered_options != [] do %>
-
Available Product Options
-
- These option keys were found in product metadata. Click to add as a filter.
-
-
- <% existing_keys = Enum.map(@storefront_filters, & &1["key"]) %>
- <%= for opt <- @discovered_options do %>
- <%= if opt.key not in existing_keys do %>
-
- <% end %>
- <% end %>
-
- <%= if method.max_weight_grams do %>
-
- Max {format_weight(method.max_weight_grams)}
-
- <% end %>
- <%= if method.countries != [] do %>
-
- {length(method.countries)} countries
-
- <% end %>
- <%= if method.countries == [] && is_nil(method.max_weight_grams) do %>
- No limits
- <% end %>
-
-
-
- <%= if estimate = PhoenixKit.Modules.Shop.ShippingMethod.delivery_estimate(method) do %>
- {estimate}
- <% else %>
- -
- <% end %>
-
- <%= if FilterHelpers.has_active_filters?(@active_filters) do %>
- No products match your filters.
-
- <% else %>
- Check back soon for new arrivals
- <% end %>
-
-
-
- <% else %>
-
- <%= for product <- @products do %>
-
- <% end %>
-
-
-
- <% end %>
-
-
-
-
- """
- end
-
- defp shop_sidebar(assigns) do
- ~H"""
-
- """
- end
-
- defp category_image(category) do
- Shop.Category.get_image_url(category, size: "small")
- end
-
- # Build catalog path with filter params and optional page
- defp build_filter_path(assigns, active_filters, opts \\ []) do
- base_path = Shop.catalog_url(assigns.current_language)
- page = Keyword.get(opts, :page)
-
- FilterHelpers.build_filter_url(base_path, active_filters, assigns.enabled_filters, page: page)
- end
-end
diff --git a/lib/modules/shop/web/test_shop.ex b/lib/modules/shop/web/test_shop.ex
deleted file mode 100644
index 8dc5428ab..000000000
--- a/lib/modules/shop/web/test_shop.ex
+++ /dev/null
@@ -1,372 +0,0 @@
-defmodule PhoenixKit.Modules.Shop.Web.TestShop do
- @moduledoc """
- Test module for verifying Shop functionality:
- - Specification price modifiers (fixed and percent)
- - Storage image integration
- - Price calculation
- """
-
- use PhoenixKitWeb, :live_view
-
- alias PhoenixKit.Modules.Shop
- alias PhoenixKit.Modules.Shop.CartItem
- alias PhoenixKit.Modules.Shop.Options
- alias PhoenixKit.Modules.Shop.OptionTypes
- alias PhoenixKit.Modules.Shop.Translations
- alias PhoenixKit.Modules.Storage
- alias PhoenixKit.Utils.Routes
-
- @impl true
- def mount(_params, _session, socket) do
- socket =
- socket
- |> assign(:page_title, "Shop Test Module")
- |> assign(:test_results, [])
- |> assign(:products, [])
- |> assign(:show_products, false)
-
- {:ok, socket}
- end
-
- @impl true
- def handle_event("run_tests", _params, socket) do
- results = [
- test_option_types(),
- test_option_schema(),
- test_price_calculation(),
- test_storage_integration(),
- test_cart_with_specs()
- ]
-
- {:noreply, assign(socket, :test_results, results)}
- end
-
- @impl true
- def handle_event("load_products", _params, socket) do
- products = Shop.list_products(limit: 10, preload: [:category])
- {:noreply, assign(socket, products: products, show_products: true)}
- end
-
- @impl true
- def handle_event("test_product_price", %{"id" => id}, socket) do
- product = Shop.get_product(id, preload: [:category])
-
- if product do
- price_specs = Shop.get_price_affecting_specs(product)
-
- # Build test selections from first options
- test_selections =
- Enum.reduce(price_specs, %{}, fn opt, acc ->
- case opt["options"] do
- [first | _] -> Map.put(acc, opt["key"], first)
- _ -> acc
- end
- end)
-
- calculated_price = Shop.calculate_product_price(product, test_selections)
- {min_price, max_price} = Shop.get_price_range(product)
-
- product_title = Translations.get(product, :title, Translations.default_language())
-
- result = %{
- name: "Price Test: #{product_title}",
- status: :ok,
- details:
- "Base: $#{product.price}, Calculated: $#{calculated_price}, Range: $#{min_price} - $#{max_price}"
- }
-
- {:noreply, assign(socket, :test_results, socket.assigns.test_results ++ [result])}
- else
- {:noreply, put_flash(socket, :error, "Product not found")}
- end
- end
-
- @impl true
- def render(assigns) do
- ~H"""
-
-
-
- {gettext("Placed on %{date}", date: format_date(@order.inserted_at))}
-
-
-
-
-
- {@order.status}
-
-
-
-
-
-
- <%!-- Order Items --%>
-
{gettext("Order Items")}
-
- <%= for item <- @order.line_items || [] do %>
-
-
- {item["name"]}
- <%= if item["type"] != "shipping" do %>
- x {item["quantity"]}
- <% end %>
- <%= if item["description"] && item["description"] != "" do %>
-
- <%= if @status_filter do %>
- {gettext("No orders with this status. Try a different filter.")}
- <% else %>
- {gettext("Start shopping to see your orders here.")}
- <% end %>
-