@salifbiaye/create-boutique 0.5.0 → 0.7.0

package/templates/backend/src/admin/routes/boutique-campaigns/page.tsx

@@ -1,7 +1,7 @@
 import { defineRouteConfig } from "@medusajs/admin-sdk"
 import { PencilSquare, Sparkles, Spinner } from "@medusajs/icons"
-import { Badge, Button, Container, Heading, Table, Text } from "@medusajs/ui"
-import { useQuery } from "@tanstack/react-query"
+import { Badge, Button, Container, Heading, Table, Text, toast, usePrompt } from "@medusajs/ui"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
 import { useState } from "react"
 import { useTranslation } from "react-i18next"
 import { sdk } from "../../lib/client"
@@ -23,11 +23,11 @@ const COLORS = { upcoming: "blue", live: "green", ended: "grey" } as const
  * Ouvre le panneau avec la campagne relue sur le serveur (jamais la copie du tableau) : sinon, rouvrir juste après
  * un enregistrement pouvait repartir d'anciennes valeurs et réenregistrer l'ancienne image.
  */
-function FreshCampaignDrawer(props: Omit<Parameters<typeof CampaignDrawer>[0], "boutique"> & { boutique: Boutique }) {
+function FreshCampaignDrawer(props: Omit<Parameters<typeof CampaignDrawer>[0], "boutique" | "defaults"> & { boutique: Boutique }) {
   const { boutique, ...rest } = props
   const { data, isFetching } = useQuery({
     queryKey: [...QUERY_KEY, "one", boutique.sales_channel_id],
-    queryFn: () => sdk.client.fetch<{ campaign: Boutique["campaign"] }>(`/admin/boutique-campaigns/${boutique.sales_channel_id}`),
+    queryFn: () => sdk.client.fetch<{ campaign: Boutique["campaign"]; defaults?: Parameters<typeof CampaignDrawer>[0]["defaults"] }>(`/admin/boutique-campaigns/${boutique.sales_channel_id}`),
     staleTime: 0,
     gcTime: 0,
   })
@@ -38,18 +38,65 @@ function FreshCampaignDrawer(props: Omit<Parameters<typeof CampaignDrawer>[0], "
       </div>
     )
   }
-  return <CampaignDrawer {...rest} boutique={{ ...boutique, campaign: data.campaign ?? null }} />
+  return <CampaignDrawer {...rest} boutique={{ ...boutique, campaign: data.campaign ?? null }} defaults={data.defaults ?? null} />
 }
 
 /** Page « Campagnes » : une ligne par boutique du projet, édition dans un panneau latéral. */
 const CampaignsPage = () => {
   const { t, i18n } = useTranslation()
   const [editing, setEditing] = useState<Boutique | null>(null)
+  const queryClient = useQueryClient()
+  const prompt = usePrompt()
 
   const { data, isLoading } = useQuery({
     queryKey: QUERY_KEY,
-    queryFn: () => sdk.client.fetch<{ boutiques: Boutique[] }>("/admin/boutique-campaigns"),
+    queryFn: () =>
+      sdk.client.fetch<{ mode?: "multi" | "single"; active?: string | null; boutiques: Boutique[] }>("/admin/boutique-campaigns"),
   })
+  const single = data?.mode === "single"
+  const multi = !!data && !single
+
+  // Mode multi : ouvrir / fermer le site d'une boutique (manuel, indépendant des dates de campagne)
+  const setOnline = useMutation({
+    mutationFn: ({ id, online }: { id: string; online: boolean }) =>
+      sdk.client.fetch(`/admin/boutique-online/${id}`, { method: "POST", body: { online } }),
+    onSuccess: (_d, v) => {
+      queryClient.invalidateQueries({ queryKey: QUERY_KEY })
+      toast.success(t(v.online ? "campaigns.site.opened" : "campaigns.site.closed"))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+  const toggleSite = async (b: Boutique) => {
+    const online = b.online === false
+    const ok = await prompt({
+      title: t(online ? "campaigns.site.openTitle" : "campaigns.site.closeTitle", { slug: b.slug }),
+      description: t(online ? "campaigns.site.openText" : "campaigns.site.closeText"),
+      confirmText: t(online ? "campaigns.site.open" : "campaigns.site.close"),
+      cancelText: t("campaigns.cancel"),
+      variant: online ? "confirmation" : "danger",
+    })
+    if (ok) setOnline.mutate({ id: b.sales_channel_id, online })
+  }
+
+  // Mode single : met une boutique en ligne (la précédente est retirée ; il y en a toujours exactement une)
+  const activate = useMutation({
+    mutationFn: (slug: string) => sdk.client.fetch("/admin/active-boutique", { method: "POST", body: { slug } }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: QUERY_KEY })
+      toast.success(t("campaigns.online.done"))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+  const goLive = async (slug: string) => {
+    const ok = await prompt({
+      title: t("campaigns.online.confirmTitle"),
+      description: t("campaigns.online.confirmText", { from: data?.active ?? "", to: slug }),
+      confirmText: t("campaigns.online.confirm"),
+      cancelText: t("campaigns.cancel"),
+      variant: "confirmation",
+    })
+    if (ok) activate.mutate(slug)
+  }
 
   const date = (iso: string) => new Date(iso).toLocaleDateString(i18n.language, { dateStyle: "medium" })
 
@@ -60,6 +107,11 @@ const CampaignsPage = () => {
         <Text size="small" className="text-ui-fg-subtle mt-1">
           {t("campaigns.description")}
         </Text>
+        {single && (
+          <Text size="small" className="text-ui-fg-subtle mt-1">
+            {t("campaigns.online.hint")}
+          </Text>
+        )}
       </div>
 
       {isLoading ? (
@@ -73,6 +125,7 @@ const CampaignsPage = () => {
               <Table.HeaderCell>{t("campaigns.store")}</Table.HeaderCell>
               <Table.HeaderCell>{t("campaigns.dates")}</Table.HeaderCell>
               <Table.HeaderCell>{t("campaigns.status")}</Table.HeaderCell>
+              {(single || multi) && <Table.HeaderCell>{t("campaigns.online.column")}</Table.HeaderCell>}
               <Table.HeaderCell />
             </Table.Row>
           </Table.Header>
@@ -101,6 +154,31 @@ const CampaignsPage = () => {
                       </Badge>
                     )}
                   </Table.Cell>
+                  {single && (
+                    <Table.Cell>
+                      {data?.active === b.slug ? (
+                        <Badge size="2xsmall" color="green">
+                          {t("campaigns.online.live")}
+                        </Badge>
+                      ) : (
+                        <Button size="small" variant="secondary" onClick={() => goLive(b.slug)} disabled={activate.isPending}>
+                          {t("campaigns.online.action")}
+                        </Button>
+                      )}
+                    </Table.Cell>
+                  )}
+                  {multi && (
+                    <Table.Cell>
+                      <div className="flex items-center gap-x-2">
+                        <Badge size="2xsmall" color={b.online === false ? "grey" : "green"}>
+                          {t(b.online === false ? "campaigns.site.offline" : "campaigns.online.live")}
+                        </Badge>
+                        <Button size="small" variant="transparent" onClick={() => toggleSite(b)} disabled={setOnline.isPending}>
+                          {t(b.online === false ? "campaigns.site.open" : "campaigns.site.close")}
+                        </Button>
+                      </div>
+                    </Table.Cell>
+                  )}
                   <Table.Cell className="text-right">
                     <Button size="small" variant="secondary" onClick={() => setEditing(b)}>
                       <PencilSquare />

package/templates/backend/src/admin/routes/reviews/page.tsx

@@ -0,0 +1,259 @@
+import { defineRouteConfig } from "@medusajs/admin-sdk"
+import { Check, ChatBubbleLeftRight, StarSolid, Trash, XMark } from "@medusajs/icons"
+import { Badge, Button, Container, Heading, Select, Table, Text, toast, usePrompt } from "@medusajs/ui"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { useState } from "react"
+import { useTranslation } from "react-i18next"
+import { sdk } from "../../lib/client"
+
+type Status = "pending" | "approved" | "rejected"
+type Review = {
+  id: string
+  rating: number
+  title: string | null
+  comment: string
+  author_name: string
+  customer_email: string
+  status: Status
+  created_at: string
+  product: { id: string; title: string; thumbnail: string | null } | null
+  boutique: string | null
+  sales_channel_id: string
+}
+type ListResponse = { reviews: Review[]; count: number; pending: number; limit: number; offset: number }
+type Boutiques = { boutiques: { slug: string; sales_channel_id: string }[] }
+
+const QUERY_KEY = ["product-reviews"]
+const PAGE = 20
+const COLORS: Record<Status, "orange" | "green" | "grey"> = { pending: "orange", approved: "green", rejected: "grey" }
+
+function Stars({ value }: { value: number }) {
+  return (
+    <span className="inline-flex" aria-label={`${value}/5`}>
+      {[1, 2, 3, 4, 5].map((i) => (
+        <StarSolid key={i} className={i <= value ? "text-ui-tag-orange-icon" : "text-ui-fg-disabled"} />
+      ))}
+    </span>
+  )
+}
+
+/**
+ * Page « Avis » : avis des acheteurs (lien de l'e-mail « commande livrée »). Un avis n'apparaît sur les boutiques
+ * qu'une fois validé. Filtre par statut et par boutique (la boutique de la commande).
+ */
+const ReviewsPage = () => {
+  const { t, i18n } = useTranslation()
+  const queryClient = useQueryClient()
+  const prompt = usePrompt()
+  const [status, setStatus] = useState<Status | "all">("pending")
+  const [channel, setChannel] = useState<string>("all")
+  const [offset, setOffset] = useState(0)
+
+  const params = new URLSearchParams({ limit: String(PAGE), offset: String(offset) })
+  if (status !== "all") params.set("status", status)
+  if (channel !== "all") params.set("sales_channel_id", channel)
+
+  const { data, isLoading } = useQuery({
+    queryKey: [...QUERY_KEY, status, channel, offset],
+    queryFn: () => sdk.client.fetch<ListResponse>(`/admin/reviews?${params.toString()}`),
+  })
+  const { data: shops } = useQuery({
+    queryKey: ["boutique-campaigns"],
+    queryFn: () => sdk.client.fetch<Boutiques>("/admin/boutique-campaigns"),
+  })
+
+  const done = () => queryClient.invalidateQueries({ queryKey: QUERY_KEY })
+  const setReviewStatus = useMutation({
+    mutationFn: ({ id, status }: { id: string; status: Status }) => sdk.client.fetch(`/admin/reviews/${id}`, { method: "POST", body: { status } }),
+    onSuccess: (_d, v) => {
+      done()
+      toast.success(t(`reviews.toast.${v.status}`))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+  const remove = useMutation({
+    mutationFn: (id: string) => sdk.client.fetch(`/admin/reviews/${id}`, { method: "DELETE" }),
+    onSuccess: () => {
+      done()
+      toast.success(t("reviews.toast.deleted"))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+  const askDelete = async (r: Review) => {
+    const ok = await prompt({
+      title: t("reviews.deleteTitle"),
+      description: t("reviews.deleteText", { name: r.author_name }),
+      confirmText: t("reviews.delete"),
+      cancelText: t("reviews.cancel"),
+      variant: "danger",
+    })
+    if (ok) remove.mutate(r.id)
+  }
+
+  const date = (s: string) => new Date(s).toLocaleDateString(i18n.language, { day: "numeric", month: "short", year: "numeric" })
+  const count = data?.count ?? 0
+
+  return (
+    <Container className="divide-y p-0">
+      <div className="flex flex-wrap items-center justify-between gap-4 px-6 py-4">
+        <div>
+          <Heading level="h1">{t("reviews.title")}</Heading>
+          <Text size="small" className="text-ui-fg-subtle">
+            {t("reviews.description")}
+          </Text>
+        </div>
+        <div className="flex flex-wrap items-center gap-2">
+          <Select
+            value={status}
+            onValueChange={(v) => {
+              setStatus(v as Status | "all")
+              setOffset(0)
+            }}
+          >
+            <Select.Trigger className="w-44">
+              <Select.Value />
+            </Select.Trigger>
+            <Select.Content>
+              <Select.Item value="pending">
+                {t("reviews.status.pending")}
+                {data?.pending ? ` (${data.pending})` : ""}
+              </Select.Item>
+              <Select.Item value="approved">{t("reviews.status.approved")}</Select.Item>
+              <Select.Item value="rejected">{t("reviews.status.rejected")}</Select.Item>
+              <Select.Item value="all">{t("reviews.status.all")}</Select.Item>
+            </Select.Content>
+          </Select>
+          <Select
+            value={channel}
+            onValueChange={(v) => {
+              setChannel(v)
+              setOffset(0)
+            }}
+          >
+            <Select.Trigger className="w-52">
+              <Select.Value />
+            </Select.Trigger>
+            <Select.Content>
+              <Select.Item value="all">{t("reviews.allBoutiques")}</Select.Item>
+              {(shops?.boutiques ?? []).map((b) => (
+                <Select.Item key={b.sales_channel_id} value={b.sales_channel_id}>
+                  {b.slug}
+                </Select.Item>
+              ))}
+            </Select.Content>
+          </Select>
+        </div>
+      </div>
+
+      {isLoading ? (
+        <div className="px-6 py-8">
+          <Text className="text-ui-fg-subtle">…</Text>
+        </div>
+      ) : !data?.reviews.length ? (
+        <div className="flex flex-col items-center gap-2 px-6 py-12 text-center">
+          <ChatBubbleLeftRight className="text-ui-fg-muted" />
+          <Text className="text-ui-fg-subtle">{t(status === "pending" ? "reviews.emptyPending" : "reviews.empty")}</Text>
+        </div>
+      ) : (
+        <Table>
+          <Table.Header>
+            <Table.Row>
+              <Table.HeaderCell>{t("reviews.col.product")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("reviews.col.review")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("reviews.col.author")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("reviews.col.status")}</Table.HeaderCell>
+              <Table.HeaderCell className="text-right">{t("reviews.col.actions")}</Table.HeaderCell>
+            </Table.Row>
+          </Table.Header>
+          <Table.Body>
+            {data.reviews.map((r) => (
+              <Table.Row key={r.id} className="align-top">
+                <Table.Cell className="py-3">
+                  <div className="flex items-center gap-3">
+                    {r.product?.thumbnail && <img src={r.product.thumbnail} alt="" className="h-10 w-10 rounded object-cover" />}
+                    <div className="min-w-0">
+                      <Text size="small" weight="plus" className="truncate">
+                        {r.product?.title ?? t("reviews.deletedProduct")}
+                      </Text>
+                      <Text size="xsmall" className="text-ui-fg-subtle">
+                        {r.boutique ?? "—"}
+                      </Text>
+                    </div>
+                  </div>
+                </Table.Cell>
+                <Table.Cell className="max-w-[420px] whitespace-normal py-3">
+                  <Stars value={r.rating} />
+                  {r.title && (
+                    <Text size="small" weight="plus" className="mt-1">
+                      {r.title}
+                    </Text>
+                  )}
+                  <Text size="small" className="text-ui-fg-subtle">
+                    {r.comment}
+                  </Text>
+                </Table.Cell>
+                <Table.Cell className="py-3">
+                  <Text size="small">{r.author_name}</Text>
+                  <Text size="xsmall" className="text-ui-fg-subtle">
+                    {r.customer_email}
+                  </Text>
+                  <Text size="xsmall" className="text-ui-fg-subtle">
+                    {date(r.created_at)}
+                  </Text>
+                </Table.Cell>
+                <Table.Cell className="py-3">
+                  <Badge size="2xsmall" color={COLORS[r.status]}>
+                    {t(`reviews.status.${r.status}`)}
+                  </Badge>
+                </Table.Cell>
+                <Table.Cell className="py-3">
+                  <div className="flex justify-end gap-2">
+                    {r.status !== "approved" && (
+                      <Button size="small" variant="secondary" onClick={() => setReviewStatus.mutate({ id: r.id, status: "approved" })}>
+                        <Check />
+                        {t("reviews.approve")}
+                      </Button>
+                    )}
+                    {r.status !== "rejected" && (
+                      <Button size="small" variant="secondary" onClick={() => setReviewStatus.mutate({ id: r.id, status: "rejected" })}>
+                        <XMark />
+                        {t("reviews.reject")}
+                      </Button>
+                    )}
+                    <Button size="small" variant="transparent" onClick={() => askDelete(r)} aria-label={t("reviews.delete")}>
+                      <Trash />
+                    </Button>
+                  </div>
+                </Table.Cell>
+              </Table.Row>
+            ))}
+          </Table.Body>
+        </Table>
+      )}
+
+      {count > PAGE && (
+        <div className="flex items-center justify-between px-6 py-3">
+          <Text size="small" className="text-ui-fg-subtle">
+            {t("reviews.range", { from: offset + 1, to: Math.min(offset + PAGE, count), count })}
+          </Text>
+          <div className="flex gap-2">
+            <Button size="small" variant="secondary" disabled={offset === 0} onClick={() => setOffset(Math.max(0, offset - PAGE))}>
+              {t("reviews.prev")}
+            </Button>
+            <Button size="small" variant="secondary" disabled={offset + PAGE >= count} onClick={() => setOffset(offset + PAGE)}>
+              {t("reviews.next")}
+            </Button>
+          </div>
+        </div>
+      )}
+    </Container>
+  )
+}
+
+export const config = defineRouteConfig({
+  label: "reviews.nav",
+  translationNs: "translation",
+  icon: StarSolid,
+})
+
+export default ReviewsPage

package/templates/backend/src/api/admin/active-boutique/route.ts

@@ -0,0 +1,25 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { z } from "@medusajs/framework/zod"
+import { MedusaError } from "@medusajs/framework/utils"
+import { getActive, setActive } from "../../../lib/active"
+import { readProject } from "../../../lib/project"
+
+export const ActiveBoutique = z.object({ slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/) })
+
+/** GET /admin/active-boutique : mode du projet et boutique en ligne (mode single). */
+export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  const { mode } = readProject()
+  res.json({ mode, active: mode === "single" ? await getActive(req.scope) : null })
+}
+
+/** POST /admin/active-boutique { slug } : met cette boutique en ligne (la précédente est retirée). */
+export async function POST(req: AuthenticatedMedusaRequest<z.infer<typeof ActiveBoutique>>, res: MedusaResponse) {
+  const project = readProject()
+  if (project.mode !== "single") {
+    throw new MedusaError(MedusaError.Types.NOT_ALLOWED, "Mode multi : toutes les boutiques sont déjà en ligne")
+  }
+  if (!project.boutiques.some((b) => b.slug === req.validatedBody.slug)) {
+    throw new MedusaError(MedusaError.Types.NOT_FOUND, "Unknown store")
+  }
+  res.json({ mode: project.mode, active: await setActive(req.scope, req.validatedBody.slug) })
+}

package/templates/backend/src/api/admin/boutique-campaigns/[salesChannelId]/route.ts

@@ -1,6 +1,7 @@
 import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
 import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
 import { toCampaignJson, type CampaignInput } from "../../../../modules/campaign/validators"
+import { themeTexts } from "../../../../lib/project"
 import { upsertCampaignWorkflow } from "../../../../workflows/upsert-campaign"
 
 async function channelOrThrow(req: AuthenticatedMedusaRequest<unknown>) {
@@ -17,7 +18,12 @@ async function channelOrThrow(req: AuthenticatedMedusaRequest<unknown>) {
 /** GET /admin/boutique-campaigns/:salesChannelId */
 export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
   const channel = await channelOrThrow(req)
-  res.json({ slug: channel.name, campaign: channel.boutique_campaign ? toCampaignJson(channel.boutique_campaign) : null })
+  res.json({
+    slug: channel.name,
+    campaign: channel.boutique_campaign ? toCampaignJson(channel.boutique_campaign) : null,
+    // Textes du thème : pré-remplissent les champs de l'admin
+    defaults: themeTexts(channel.name) ?? null,
+  })
 }
 
 /** POST /admin/boutique-campaigns/:salesChannelId : enregistre la campagne (corps validé par zod, cf. middlewares). */

package/templates/backend/src/api/admin/boutique-campaigns/route.ts

@@ -1,5 +1,7 @@
 import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
 import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { getActive } from "../../../lib/active"
+import { readProject } from "../../../lib/project"
 import { toCampaignJson } from "../../../modules/campaign/validators"
 
 /** GET /admin/boutique-campaigns : les boutiques du projet (sales channels) et leur campagne. */
@@ -8,16 +10,22 @@ export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse)
 
   const { data: channels } = await query.graph({
     entity: "sales_channel",
-    fields: ["id", "name", "description", "boutique_campaign.*"],
+    fields: ["id", "name", "description", "metadata", "boutique_campaign.*"],
   })
 
+  const { mode } = readProject()
   res.json({
+    // Mode single : une seule boutique en ligne, choisie ici (POST /admin/active-boutique)
+    mode,
+    active: mode === "single" ? await getActive(req.scope) : null,
     boutiques: channels
       .filter((c) => c.name !== "Default Sales Channel")
       .map((c) => ({
         sales_channel_id: c.id,
         slug: c.name,
         description: c.description,
+        // Mode multi : site ouvert (défaut) ou fermé, choisi ici
+        online: c.metadata?.ub_online !== false,
         campaign: c.boutique_campaign ? toCampaignJson(c.boutique_campaign) : null,
       })),
   })

package/templates/backend/src/api/admin/boutique-online/[salesChannelId]/route.ts

@@ -0,0 +1,22 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { z } from "@medusajs/framework/zod"
+import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
+import { updateSalesChannelsWorkflow } from "@medusajs/medusa/core-flows"
+
+export const BoutiqueOnline = z.object({ online: z.boolean() })
+
+/**
+ * POST /admin/boutique-online/:salesChannelId { online } : ouvre ou ferme le site d'une boutique.
+ * Fermé : le site affiche « Boutique fermée » ; compte, suivi de commande et paniers en cours restent accessibles.
+ * Rien d'automatique : seul ce réglage ouvre ou ferme un site (les dates de campagne ne pilotent que la promo).
+ */
+export async function POST(req: AuthenticatedMedusaRequest<z.infer<typeof BoutiqueOnline>>, res: MedusaResponse) {
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const { data } = await query.graph({ entity: "sales_channel", fields: ["id", "name", "metadata"], filters: { id: req.params.salesChannelId } })
+  if (!data.length) throw new MedusaError(MedusaError.Types.NOT_FOUND, "Unknown store")
+  const channel = data[0]
+  await updateSalesChannelsWorkflow(req.scope).run({
+    input: { selector: { id: channel.id }, update: { metadata: { ...(channel.metadata ?? {}), ub_online: req.validatedBody.online } } },
+  })
+  res.json({ slug: channel.name, online: req.validatedBody.online })
+}

package/templates/backend/src/api/admin/reviews/[id]/route.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type { ReviewStatusInput } from "../../../../modules/product-review/validators"
+import { deleteReviewWorkflow, updateReviewStatusWorkflow } from "../../../../workflows/reviews"
+
+/** POST /admin/reviews/:id { status } : valider, refuser, remettre en attente. */
+export async function POST(req: AuthenticatedMedusaRequest<ReviewStatusInput>, res: MedusaResponse) {
+  const { result } = await updateReviewStatusWorkflow(req.scope).run({ input: { id: req.params.id, status: req.validatedBody.status } })
+  res.json({ review: result })
+}
+
+/** DELETE /admin/reviews/:id : supprimer un avis. */
+export async function DELETE(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  await deleteReviewWorkflow(req.scope).run({ input: { id: req.params.id } })
+  res.json({ id: req.params.id, deleted: true })
+}

package/templates/backend/src/api/admin/reviews/route.ts

@@ -0,0 +1,47 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { PRODUCT_REVIEW_MODULE } from "../../../modules/product-review"
+import ProductReviewModuleService from "../../../modules/product-review/service"
+
+/**
+ * GET /admin/reviews?status=pending&sales_channel_id=…&limit=20&offset=0 : avis pour la page Avis de l'admin,
+ * avec le produit et la boutique (sales channel) de chacun. Compte des avis en attente (badge).
+ */
+export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  const status = ["pending", "approved", "rejected"].includes(String(req.query.status)) ? String(req.query.status) : undefined
+  const channel = typeof req.query.sales_channel_id === "string" && req.query.sales_channel_id ? req.query.sales_channel_id : undefined
+  const limit = Math.min(Math.max(Number(req.query.limit) || 20, 1), 100)
+  const offset = Math.max(Number(req.query.offset) || 0, 0)
+
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const filters = { ...(status ? { status: status as "pending" | "approved" | "rejected" } : {}), ...(channel ? { sales_channel_id: channel } : {}) }
+  const [reviews, count] = await service.listAndCountReviews(filters, { take: limit, skip: offset, order: { created_at: "DESC" } })
+  const [, pending] = await service.listAndCountReviews({ status: "pending" }, { take: 1 })
+
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const productIds = [...new Set(reviews.map((r) => r.product_id))]
+  const channelIds = [...new Set(reviews.map((r) => r.sales_channel_id))]
+  // Types explicites : query.graph n'est typé finement qu'avec les types générés par Medusa (absents en CI)
+  type P = { id: string; title: string; thumbnail: string | null }
+  type C = { id: string; name: string }
+  const products: P[] = productIds.length
+    ? ((await query.graph({ entity: "product", fields: ["id", "title", "thumbnail"], filters: { id: productIds } })).data as P[])
+    : []
+  const channels: C[] = channelIds.length
+    ? ((await query.graph({ entity: "sales_channel", fields: ["id", "name"], filters: { id: channelIds } })).data as C[])
+    : []
+  const productOf = new Map<string, P>(products.map((p) => [p.id, p]))
+  const channelOf = new Map<string, string>(channels.map((c) => [c.id, c.name]))
+
+  res.json({
+    reviews: reviews.map((r) => ({
+      ...r,
+      product: productOf.get(r.product_id) ?? null,
+      boutique: channelOf.get(r.sales_channel_id) ?? null,
+    })),
+    count,
+    pending,
+    limit,
+    offset,
+  })
+}

package/templates/backend/src/api/middlewares.ts

@@ -1,12 +1,16 @@
 import { defineMiddlewares, validateAndTransformBody } from "@medusajs/framework/http"
 import { CampaignInput } from "../modules/campaign/validators"
 import { rateLimit } from "./rate-limit"
+import { ActiveBoutique } from "./admin/active-boutique/route"
+import { BoutiqueOnline } from "./admin/boutique-online/[salesChannelId]/route"
 import { OrderLookup } from "./store/order-lookup/route"
+import { ReviewInput, ReviewStatusInput } from "../modules/product-review/validators"
 
 // Anti force brute (par IP) : connexion admin, mot de passe oublié, suivi de commande.
 const loginLimit = rateLimit({ name: "connexion", max: 10, windowMs: 15 * 60 * 1000 })
 const resetLimit = rateLimit({ name: "mot de passe oublié", max: 5, windowMs: 60 * 60 * 1000 })
 const lookupLimit = rateLimit({ name: "suivi de commande", max: 20, windowMs: 10 * 60 * 1000 })
+const reviewLimit = rateLimit({ name: "avis", max: 20, windowMs: 60 * 60 * 1000 })
 
 export default defineMiddlewares({
   routes: [
@@ -16,9 +20,14 @@ export default defineMiddlewares({
       method: "POST",
       middlewares: [validateAndTransformBody(CampaignInput)],
     },
+    { matcher: "/admin/active-boutique", method: "POST", middlewares: [validateAndTransformBody(ActiveBoutique)] },
+    { matcher: "/admin/boutique-online/:salesChannelId", method: "POST", middlewares: [validateAndTransformBody(BoutiqueOnline)] },
     { matcher: "/auth/user/emailpass", method: "POST", middlewares: [loginLimit] },
     { matcher: "/auth/user/emailpass/reset-password", method: "POST", middlewares: [resetLimit] },
     { matcher: "/auth/customer/emailpass", method: "POST", middlewares: [loginLimit] },
+    { matcher: "/admin/reviews/:id", method: "POST", middlewares: [validateAndTransformBody(ReviewStatusInput)] },
+    { matcher: "/store/reviews", method: "POST", middlewares: [reviewLimit, validateAndTransformBody(ReviewInput)] },
+    { matcher: "/store/reviews/order", method: "GET", middlewares: [lookupLimit] },
     {
       matcher: "/store/order-lookup",
       method: "POST",

package/templates/backend/src/api/store/campaign/route.ts

@@ -20,6 +20,10 @@ export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
     throw new MedusaError(MedusaError.Types.NOT_FOUND, "No campaign for this store")
   }
 
+  // Site ouvert / fermé : choisi dans admin → Campagnes (metadata du sales channel), indépendant des dates
+  const { data: channels } = await query.graph({ entity: "sales_channel", fields: ["metadata"], filters: { id: salesChannelIds } })
+  const online = channels[0]?.metadata?.ub_online !== false
+
   res.setHeader("Cache-Control", "public, max-age=60")
-  res.json({ campaign: toCampaignJson(data[0]) })
+  res.json({ campaign: { ...toCampaignJson(data[0]), online } })
 }

package/templates/backend/src/api/store/reviews/latest/route.ts

@@ -0,0 +1,39 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { PRODUCT_REVIEW_MODULE } from "../../../../modules/product-review"
+import ProductReviewModuleService from "../../../../modules/product-review/service"
+import { PUBLIC_FIELDS, reviewChannels } from "../../../../lib/reviews"
+
+/**
+ * GET /store/reviews/latest?limit=6 : derniers avis validés (section « avis » de l'accueil), 4 étoiles et plus,
+ * seulement sur des produits vendus dans la boutique qui interroge ; avec titre, lien et image du produit.
+ */
+export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
+  const limit = Math.min(Math.max(Number(req.query.limit) || 6, 1), 12)
+  const channels = reviewChannels(req)
+  const ownChannels = req.publishable_key_context?.sales_channel_ids ?? []
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const reviews = await service.listReviews(
+    { status: "approved", rating: { $gte: 4 }, ...(channels ? { sales_channel_id: channels } : {}) },
+    { select: [...PUBLIC_FIELDS], take: 60, order: { created_at: "DESC" } }
+  )
+  if (!reviews.length) return res.json({ reviews: [] })
+
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const { data: products } = await query.graph({
+    entity: "product",
+    fields: ["id", "title", "handle", "thumbnail", "status", "sales_channels.id"],
+    filters: { id: [...new Set(reviews.map((r) => r.product_id))] },
+  })
+  const sold = new Map(
+    products
+      .filter((p) => p.status === "published" && (p.sales_channels ?? []).some((c) => c && ownChannels.includes(c.id)))
+      .map((p) => [p.id, { title: p.title, handle: p.handle, thumbnail: p.thumbnail }])
+  )
+  res.json({
+    reviews: reviews
+      .filter((r) => sold.has(r.product_id))
+      .slice(0, limit)
+      .map((r) => ({ ...r, product: sold.get(r.product_id) })),
+  })
+}