@shopbite-de/storefront 1.1.1 → 1.2.1

package/app/components/Cart/Item.vue

@@ -60,7 +60,9 @@ const handleRemoveItem = () => {
             </h3>
 
             <p
-              v-for="option in cartItem?.payload?.options"
+              v-for="option in cartItem?.type === 'container'
+                ? cartItem?.children?.[0]?.payload?.options
+                : cartItem?.payload?.options"
               :key="option.group + option.option"
               class="text-sm text-pretty text-toned mt-1"
             >

package/app/components/Category/Listing.vue

@@ -7,63 +7,6 @@ const props = defineProps<{
 
 const { id: categoryId } = toRefs(props);
 
-const {
-  resetFilters,
-  loading,
-  search,
-  getElements,
-  getCurrentSortingOrder,
-  getSortingOrders,
-  changeCurrentSortingOrder,
-  getAvailableFilters,
-  getCurrentFilters,
-  setCurrentFilters,
-} = useListing({
-  listingType: "categoryListing",
-  categoryId: props.id,
-});
-
-const { search: categorySearch } = useCategorySearch();
-
-const { data: category } = await useAsyncData(
-  `category${categoryId.value}`,
-  async () => {
-    return await categorySearch(categoryId.value);
-  },
-);
-
-const pageTitle = computed(
-  () =>
-    `${category.value?.translated.name ?? category.value?.name} | Speisekarte`,
-);
-
-useSeoMeta({
-  title: pageTitle,
-  robots: "index,follow",
-});
-
-const currentSorting = ref(getCurrentSortingOrder.value ?? "Sortieren");
-
-const propertyFilters = computed<Schemas["PropertyGroup"][]>(() =>
-  getAvailableFilters.value?.filter(
-    (availableFilter) => availableFilter.code === "properties",
-  ),
-);
-
-const selectedPropertyFilters = ref(getCurrentFilters.value?.properties ?? []);
-const selectedPropertyFiltersString = computed(() =>
-  selectedPropertyFilters.value?.join("|"),
-);
-
-const selectedListingFilters = computed<ShortcutFilterParam[]>(() => {
-  return [
-    {
-      code: "properties",
-      value: selectedPropertyFiltersString.value,
-    },
-  ];
-});
-
 const query = {
   includes: {
     product: [
@@ -139,6 +82,64 @@ const query = {
   },
 } as operations["searchPage post /search"]["body"];
 
+const {
+  resetFilters,
+  loading,
+  search,
+  getElements,
+  getCurrentSortingOrder,
+  getSortingOrders,
+  changeCurrentSortingOrder,
+  getAvailableFilters,
+  getCurrentFilters,
+  setCurrentFilters,
+} = useListing({
+  listingType: "categoryListing",
+  categoryId: props.id,
+  defaultSearchCriteria: query,
+});
+
+const { search: categorySearch } = useCategorySearch();
+
+const { data: category } = await useAsyncData(
+  `category${categoryId.value}`,
+  async () => {
+    return await categorySearch(categoryId.value);
+  },
+);
+
+const pageTitle = computed(
+  () =>
+    `${category.value?.translated.name ?? category.value?.name} | Speisekarte`,
+);
+
+useSeoMeta({
+  title: pageTitle,
+  robots: "index,follow",
+});
+
+const currentSorting = ref(getCurrentSortingOrder.value ?? "Sortieren");
+
+const propertyFilters = computed<Schemas["PropertyGroup"][]>(() =>
+  getAvailableFilters.value?.filter(
+    (availableFilter) => availableFilter.code === "properties",
+  ),
+);
+
+const selectedPropertyFilters = ref(getCurrentFilters.value?.properties ?? []);
+const selectedPropertyFiltersString = computed(() =>
+  selectedPropertyFilters.value?.join("|"),
+);
+
+const selectedListingFilters = computed<ShortcutFilterParam[]>(() => {
+  return [
+    {
+      code: "properties",
+      value: selectedPropertyFiltersString.value,
+    },
+  ];
+});
+
 await useAsyncData(`listing${categoryId.value}`, async () => {
   await search(query);
 });

package/app/components/Cta.vue

@@ -1,32 +1,26 @@
 <script setup lang="ts">
 import type { ButtonProps } from "#ui/components/Button.vue";
 
-const links = ref<ButtonProps[]>([
-  {
-    label: "Zur Speisekarte",
-    color: "primary",
-    to: "/speisekarte",
-  },
-  {
-    label: "Tisch reservieren",
-    variant: "outline",
-    trailingIcon: "i-lucide-phone",
-    to: "tel:+490610471427",
-  },
-]);
+defineProps<{
+  title: string;
+  description?: string | undefined;
+  backgroundImage?: string | undefined;
+  links?: ButtonProps[] | undefined;
+}>();
 </script>
 
 <template>
   <div class="relative overflow-hidden">
     <NuxtImg
-      src="https://shopware.shopbite.de/media/f5/19/4a/1762546880/category-pizza-header.webp"
+      v-if="backgroundImage"
+      :src="backgroundImage"
       class="absolute inset-0 z-0 w-full h-full object-cover opacity-40"
       alt="CTA Background"
     />
     <UPageCTA
       variant="soft"
-      title="Jetzt bestellen!"
-      description="Genieße die italienische Küche, frisch zubereitet und direkt zu dir geliefert oder vor Ort genießen."
+      :title="title"
+      :description="description"
       :links="links"
       class="relative z-10"
     />

package/app/components/Product/Card.vue

@@ -123,7 +123,7 @@ const mainIngredients = computed<Schemas["PropertyGroupOption"][]>(() => {
         </div>
         <UCollapsible v-model:open="openDetails" class="flex flex-col gap-2">
           <template #content>
-            <ProductDetail :product="product" @product-added="toggleDetails" />
+            <ProductDetail2 :product="product" @product-added="toggleDetails" />
           </template>
         </UCollapsible>
       </template>

package/app/components/Product/Configurator2.vue

@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import type { Schemas } from "#shopware";
+import { useProductConfigurator } from "~/composables/useProductConfigurator";
+
+const props = defineProps<{
+  p: Schemas["Product"];
+  c: Schemas["PropertyGroup"][];
+}>();
+
+const { p, c } = toRefs(props);
+const { product, changeVariant, configurator } = useProduct(p, c);
+const { findVariantForSelectedOptions } = useProductConfigurator();
+const { variants: selectableOptions } = useProductVariantsZwei(configurator);
+
+const selectedOptions = ref<Record<string, string>>({});
+
+function initialOptions(variant: Ref<Schemas["Product"]>) {
+  const options = variant.value.options as Schemas["PropertyGroupOption"][];
+  for (const option of options) {
+    if (option.group && option.id) {
+      selectedOptions.value[option.group.id] = option.id;
+    }
+  }
+}
+onMounted(() => {
+  initialOptions(product);
+});
+
+watch(
+  selectedOptions.value,
+  async () => {
+    const foundVariant = await findVariantForSelectedOptions(
+      selectedOptions.value,
+    );
+
+    if (foundVariant) {
+      changeVariant(foundVariant);
+      emit("variant-switched", foundVariant);
+    }
+  },
+  { deep: true },
+);
+
+const emit = defineEmits<{
+  "variant-switched": [variant: Schemas["Product"]];
+}>();
+</script>
+<template>
+  <div
+    v-for="(variantGroup, propertyGroupId) in selectableOptions"
+    :key="propertyGroupId"
+    class="my-6"
+  >
+    <div class="flex flex-row gap-2 items-center">
+      <div class="basis-1/3">{{ variantGroup.name }}:</div>
+      <USelect
+        v-model="selectedOptions[propertyGroupId]"
+        value-key="productId"
+        :items="variantGroup.options"
+        class="w-full"
+        icon="i-lucide-square-stack"
+      />
+    </div>
+  </div>
+</template>

package/app/components/Product/CrossSelling.vue

@@ -1,31 +1,22 @@
 <script setup lang="ts">
-import { onMounted, watch, computed, ref, toRefs } from "vue";
 import type { Schemas } from "#shopware";
 import type {
   AssociationItemProduct,
   AssociationItem,
 } from "~/types/Association";
+import { useShopwareContext } from "#imports";
 
 const DEFAULT_CURRENCY = "EUR";
 const DEFAULT_LOCALE = "de-DE";
-const ASSOCIATION_CONTEXT = "cross-selling";
 const LOADING_ICON = "i-lucide-loader";
 const DEFAULT_ICON = "i-lucide-plus";
-const LOAD_ASSOCIATIONS_METHOD = "post";
 
 const props = defineProps<{
   product: Schemas["Product"];
 }>();
-const { product } = toRefs(props);
-const selectedExtras = ref<AssociationItemProduct[]>([]);
 
-const {
-  loadAssociations,
-  isLoading: isAssociationsLoading,
-  productAssociations,
-} = useProductAssociations(product, {
-  associationContext: ASSOCIATION_CONTEXT,
-});
+const product = computed(() => props.product);
+const selectedExtras = ref<AssociationItemProduct[]>([]);
 
 const { getFormattedPrice } = usePrice({
   currencyCode: DEFAULT_CURRENCY,
@@ -48,14 +39,24 @@ function mapAssociationToItems(
   }));
 }
 
+const { apiClient } = useShopwareContext();
+
+const { data: productAssociations, pending: isAssociationsLoading } =
+  useAsyncData(`cross-selling-${product.value.id}`, async () => {
+    const response = await apiClient.invoke(
+      "readProductCrossSellings post /product/{productId}/cross-selling",
+      {
+        pathParams: { productId: product.value.id },
+      },
+    );
+
+    return response.data;
+  });
+
 const associationItems = computed(() =>
-  mapAssociationToItems(productAssociations.value),
+  mapAssociationToItems(productAssociations.value ?? []),
 );
 
-onMounted(() => {
-  loadAssociations({ method: LOAD_ASSOCIATIONS_METHOD, searchParams: {} });
-});
-
 watch(selectedExtras, () => emit("extras-selected", selectedExtras.value), {
   deep: true,
 });

package/app/components/Product/Detail2.vue

@@ -0,0 +1,100 @@
+<script setup lang="ts">
+import type { Schemas } from "#shopware";
+import type { AssociationItemProduct } from "~/types/Association";
+
+const props = defineProps<{
+  product: Schemas["Product"];
+}>();
+
+const { apiClient } = useShopwareContext();
+
+const productId = toRef(props.product.id);
+const { data: productDetails, pending } = useAsyncData(
+  () => `product-${productId.value ?? "none"}`,
+  async () => {
+    if (!productId.value) return null;
+    const response = await apiClient.invoke(
+      "readProductDetail post /product/{productId}",
+      {
+        pathParams: { productId: productId.value },
+      },
+    );
+    return response.data;
+  },
+);
+
+const {
+  selectedProduct,
+  selectedQuantity,
+  addToCart,
+  setSelectedProduct,
+  setSelectedExtras,
+  setDeselectedIngredients,
+} = useAddToCart();
+
+// Initialize when productDetails is loaded
+watch(
+  () => productDetails.value?.product,
+  (product) => {
+    if (product) {
+      setSelectedProduct(product);
+    }
+  },
+  { immediate: true },
+);
+
+const onVariantSwitched = (variant: Schemas["Product"]) => {
+  setSelectedProduct(variant);
+};
+
+const onExtrasSelected = (extras: AssociationItemProduct[]) => {
+  setSelectedExtras(extras);
+};
+
+const onIngredientsDeselected = (deselected: string[]) => {
+  setDeselectedIngredients(deselected);
+};
+
+const onAddToCart = () => emit("product-added");
+
+const emit = defineEmits(["product-added"]);
+</script>
+
+<template>
+  <div v-if="!pending">
+    <div v-if="productDetails?.configurator">
+      <ProductConfigurator2
+        v-if="productDetails?.configurator"
+        :p="product"
+        :c="productDetails.configurator"
+        @variant-switched="onVariantSwitched"
+      />
+      <ProductCrossSelling
+        v-if="selectedProduct"
+        :product="selectedProduct"
+        @extras-selected="onExtrasSelected"
+      />
+      <ProductDeselectIngredient
+        v-if="selectedProduct"
+        :product="selectedProduct"
+        @ingredients-deselected="onIngredientsDeselected"
+      />
+    </div>
+    <div class="flex flex-row gap-4 mt-8">
+      <UInputNumber
+        v-model="selectedQuantity"
+        size="xl"
+        placeholder="Anzahl"
+        :min="1"
+        :max="100"
+      />
+      <UButton
+        size="xl"
+        label="In den Warenkorb"
+        icon="i-lucide-shopping-cart"
+        block
+        @click="addToCart(onAddToCart)"
+      />
+    </div>
+  </div>
+</template>

package/app/components/User/RegistrationForm.vue

@@ -61,7 +61,6 @@ const toast = useToast();
 async function onSubmit(event: FormSubmitEvent<RegistrationSchema>) {
   const registrationData = { ...event.data };
 
-  console.log(registrationData);
   if (
     !registrationData.billingAddress.firstName &&
     registrationData.firstName

package/app/composables/useAddToCart.ts

@@ -0,0 +1,174 @@
+import type { Schemas, operations } from "#shopware";
+import type { AssociationItemProduct } from "~/types/Association";
+import { v5 as uuidv5 } from "uuid";
+import { computed, ref } from "vue";
+
+const UUID_NAMESPACE = "b098ef7e-0fa2-4073-b002-7ceec4360fbf";
+const CART_SUCCESS_TITLE = "Gute Wahl!";
+const LINE_ITEM_PRODUCT = "product";
+const LINE_ITEM_CONTAINER = "container";
+
+export function useAddToCart() {
+  const { addProducts, refreshCart } = useCart();
+  const toast = useToast();
+  const { triggerProductAdded } = useProductEvents();
+
+  const selectedExtras = ref<AssociationItemProduct[]>([]);
+  const deselectedIngredients = ref<string[]>([]);
+  const selectedQuantity = ref(1);
+  const selectedProduct = ref<Schemas["Product"] | null>(null);
+
+  const cartItemLabel = computed(() => {
+    if (!selectedProduct.value) return "";
+
+    const formatIngredientModifications = (
+      items: Array<{ label: string } | string>,
+      prefix: string,
+    ): string => {
+      if (!items.length) return "";
+
+      const labels = items.map((item) =>
+        typeof item === "string" ? item : item.label,
+      );
+      const separator = " " + prefix;
+      return " " + prefix + labels.join(separator);
+    };
+
+    const extrasFormatted = formatIngredientModifications(
+      selectedExtras.value,
+      "+",
+    );
+    const removedFormatted = formatIngredientModifications(
+      deselectedIngredients.value,
+      "-",
+    );
+
+    console.log(
+      selectedProduct.value.translated.name,
+      extrasFormatted,
+      removedFormatted,
+    );
+
+    return `${selectedProduct.value.translated.name}${extrasFormatted}${removedFormatted}`;
+  });
+
+  const createExtras = () =>
+    selectedExtras.value.map((extra) => ({
+      id: extra.value,
+      type: LINE_ITEM_PRODUCT,
+      quantity: selectedQuantity.value,
+    }));
+
+  const generateSortedExtrasString = (extras: AssociationItemProduct[]) =>
+    extras
+      .map((extra) => extra.value)
+      .sort()
+      .join("");
+
+  const generateProductId = (
+    baseId: string,
+    extras: AssociationItemProduct[],
+  ) => (extras.length ? baseId + generateSortedExtrasString(extras) : baseId);
+
+  function createCartItems(): operations["addLineItem post /checkout/cart/line-item"]["body"]["items"] {
+    if (!selectedProduct.value) return [];
+
+    const extras = createExtras();
+
+    // Simple product when no extras
+    if (extras.length === 0 && deselectedIngredients.value.length === 0) {
+      return [
+        {
+          id: selectedProduct.value.id,
+          quantity: selectedQuantity.value,
+          type: LINE_ITEM_PRODUCT,
+        },
+      ];
+    }
+
+    // Container product when extras are selected
+    const generatedUuid = uuidv5(
+      generateProductId(selectedProduct.value.id, selectedExtras.value),
+      UUID_NAMESPACE,
+    );
+
+    return [
+      {
+        id: generatedUuid,
+        quantity: selectedQuantity.value,
+        type: LINE_ITEM_CONTAINER,
+        label: cartItemLabel.value,
+        payload: {
+          productNumber: selectedProduct.value.productNumber,
+        },
+        children: [
+          {
+            id: selectedProduct.value.id,
+            quantity: selectedQuantity.value,
+            type: LINE_ITEM_PRODUCT,
+          },
+          ...extras,
+        ],
+      },
+    ];
+  }
+
+  async function showSuccessToast() {
+    if (!selectedProduct.value) return;
+
+    toast.add({
+      title: CART_SUCCESS_TITLE,
+      description: `${selectedProduct.value.translated.name} wurde in den Warenkorb gelegt.`,
+      icon: "i-lucide-shopping-cart",
+      color: "primary",
+      progress: true,
+      duration: 2000,
+    });
+  }
+
+  async function addToCart(onSuccess?: () => void) {
+    if (!selectedProduct.value) return;
+
+    const cartItems = createCartItems();
+    const newCart = await addProducts(cartItems);
+    await refreshCart(newCart);
+    await showSuccessToast();
+
+    triggerProductAdded();
+
+    useTrackEvent("add_to_cart", {
+      props: {
+        product_number: selectedProduct.value.productNumber,
+        quantity: selectedQuantity.value,
+      },
+    });
+
+    if (onSuccess) {
+      onSuccess();
+    }
+  }
+
+  function setSelectedProduct(product: Schemas["Product"]) {
+    selectedProduct.value = product;
+  }
+
+  function setSelectedExtras(extras: AssociationItemProduct[]) {
+    selectedExtras.value = extras;
+  }
+
+  function setDeselectedIngredients(ingredients: string[]) {
+    deselectedIngredients.value = ingredients;
+  }
+
+  return {
+    selectedProduct,
+    selectedExtras,
+    deselectedIngredients,
+    selectedQuantity,
+    cartItemLabel,
+    addToCart,
+    setSelectedProduct,
+    setSelectedExtras,
+    setDeselectedIngredients,
+  };
+}

package/app/composables/useProductConfigurator.ts

@@ -0,0 +1,107 @@
+import { computed, ref } from "vue";
+import type { Schemas } from "#shopware";
+import {
+  useShopwareContext,
+  useProductConfigurator as useProductConfiguratorOriginal,
+  useProduct,
+} from "@shopware/composables";
+import { getTranslatedProperty } from "@shopware/helpers";
+
+export function useProductConfigurator() {
+  const { apiClient } = useShopwareContext();
+
+  const original = useProductConfiguratorOriginal();
+
+  const { configurator, product } = useProduct();
+
+  const selected = ref<{
+    [key: string]: string;
+  }>({});
+  const isLoadingOptions = ref(!!product.value.options?.length);
+  const parentProductId = computed(() => product.value?.parentId);
+  const getOptionGroups = computed<Schemas["PropertyGroup"][]>(() => {
+    return configurator.value || [];
+  });
+
+  const findGroupCodeForOption = (optionId: string) => {
+    const group = getOptionGroups.value.find((optionGroup) => {
+      const optionFound = optionGroup.options?.find((option) => {
+        return option.id === optionId;
+      });
+      return !!optionFound;
+    });
+
+    return getTranslatedProperty(group, "name");
+  };
+
+  // create a group -> optionId map
+  for (const optionId of product.value.optionIds || []) {
+    const optionGroupCode = findGroupCodeForOption(optionId);
+    if (optionGroupCode) {
+      selected.value[optionGroupCode] = optionId;
+    }
+  }
+
+  async function findVariantForSelectedOptions(options?: {
+    [code: string]: string;
+  }): Promise<Schemas["Product"] | undefined> {
+    const filter: Schemas["Filters"] = [
+      {
+        type: "equals",
+        field: "parentId",
+        value: parentProductId.value as string,
+      },
+      ...Object.values(options || selected.value).map(
+        (id) =>
+          ({
+            type: "equals",
+            field: "optionIds",
+            value: id,
+          }) as Schemas["EqualsFilter"],
+      ),
+    ];
+    try {
+      const response = await apiClient.invoke("readProduct post /product", {
+        body: {
+          filter,
+          limit: 1,
+          includes: {
+            product: [
+              "id",
+              "name",
+              "translated",
+              "productNumber",
+              "options",
+              "properties",
+            ],
+            product_option: ["id", "groupId", "name", "translated", "group"],
+            property: ["id", "name", "translated", "options"],
+            property_group_option: ["id", "name", "translated", "group"],
+          },
+          associations: {
+            options: {
+              associations: {
+                group: {},
+              },
+            },
+            properties: {
+              associations: {
+                group: {},
+              },
+            },
+          },
+        },
+      });
+      return response.data.elements?.[0]; // return first matching product
+    } catch (e) {
+      console.error("SwProductDetails:findVariantForSelectedOptions", e);
+      return undefined;
+    }
+  }
+
+  return {
+    ...original,
+    findVariantForSelectedOptions,
+    isLoadingOptions,
+  };
+}

package/app/composables/useProductVariantsZwei.ts

@@ -0,0 +1,62 @@
+import { computed, type ComputedRef, type Ref } from "vue";
+import type { Schemas } from "#shopware";
+
+// Define the SelectItem interface to match what USelect expects
+interface SelectItem {
+  label: string;
+  value: string;
+  productId: string;
+}
+
+type VariantOptions = {
+  name: string;
+  options: SelectItem[];
+};
+
+type useProductVariantsReturn = {
+  variants: ComputedRef<Record<string, VariantOptions>>;
+};
+
+// Accept configuratorSettings as a Ref of PropertyGroup[]
+export function useProductVariantsZwei(
+  configuratorSettings: Ref<Schemas["PropertyGroup"][]>,
+): useProductVariantsReturn {
+  const variants = computed(() => {
+    const groups = configuratorSettings.value || [];
+    const result: Record<string, VariantOptions> = {};
+
+    for (const group of groups) {
+      const groupId = group.id;
+      const groupName = group.translated?.name || group.name;
+      const options = group.options || [];
+
+      if (!groupId || !groupName) continue;
+
+      result[groupId] ??= {
+        name: groupName,
+        options: [],
+      };
+
+      for (const opt of options) {
+        const optionId = opt.id;
+        const optionName = opt.translated?.name || opt.name;
+        if (!optionId || !optionName) continue;
+
+        const exists = result[groupId].options.find(
+          (o) => o.value === optionId,
+        );
+        if (!exists) {
+          result[groupId].options.push({
+            label: optionName,
+            value: optionId,
+            productId: optionId,
+          });
+        }
+      }
+    }
+
+    return result;
+  });
+
+  return { variants };
+}

package/app/error.vue

@@ -5,12 +5,18 @@ const props = defineProps<{
   error: NuxtError;
 }>();
 
+const {
+  public: { site },
+} = useRuntimeConfig();
+
+const pageTitle = computed(() => `${statusCode} | ${site?.name}`);
+
 console.error(props.error);
 
 const statusCode = props.error.statusCode;
 
 useSeoMeta({
-  title: `${statusCode} | Pizzeria La Fattoria`,
+  title: pageTitle,
 });
 </script>
 

package/app/pages/index.vue

@@ -54,6 +54,11 @@ useSeoMeta({
       :images="page.gallery.images"
       :links="page.gallery.links"
     />
-    <Cta />
+    <Cta
+      :title="page.cta.title"
+      :description="page.cta.description"
+      :background-image="page.cta.backgroundImage"
+      :links="page.cta.links"
+    />
   </div>
 </template>

package/app/pages/merkliste.vue

@@ -1,6 +1,12 @@
 <script setup lang="ts">
+const {
+  public: { site },
+} = useRuntimeConfig();
+
+const pageTitle = computed(() => `Merkliste | ${site?.name}`);
+
 useSeoMeta({
-  title: "Merkliste | Pizzeria La Fattoria",
+  title: pageTitle,
 });
 </script>
 

package/content/index.yml

@@ -1,17 +1,17 @@
 seo:
   title: ShopBite – Kostenloses Online-Bestellsystem für Gastronomie
   description: Dein eigenes Bestellsystem ohne Provisionen, ohne monatliche Kosten – 100% Open Source und individuell anpassbar. Perfekt für Pizzerien, Imbisse und Lieferdienste.
-title: Pizzeria La Fattoria
-description: Italienisch-deutsche Küche in Obertshausen seit 1997.
+title: ShopBite
+description: Reduziere Kosten und steigere deinen Umsatz
 hero:
   backgroundVideo: https://shopware.shopbite.de/media/10/59/96/1762465181/background.mp4
-  headline: ALTE SCHMIEDE
+  headline: SHOPBITE
   usps:
     - title: 4.5 ⭐
       subtitle: 720+ Reviews
       icon: i-simple-icons-google
-      link: https://www.google.com/maps/place/?q=place_id:ChIJJ-6VNfcTvUcR2r7Sax3SN2s
-    - title: 28 Jahre
+      link: https://www.google.com/maps/place/?q=place_id
+    - title: 20 Jahre
       subtitle: in Obertshausen
       icon: i-lucide-award
     - title: Lieferservice
@@ -29,12 +29,12 @@ hero:
       size: xl
       color: neutral
       variant: outline
-      to: 'tel:+490610474127'
+      to: 'tel:+490610477777'
       target: _blank
 features:
   title: Alle [Informationen]{.text-primary} auf einen Blick
   description: Sie können Speisen und Getränke abholen, liefern lassen, oder vor Ort in unserem Restaurant genießen.
-  headline: ALTE SCHMIEDE
+  headline: SHOPBITE
   features:
     - title: Öffnungszeiten
       description: Von 11:30 - 14:30 und 17:30 - 23:00 Uhr. Samstags von 17:30 - 23:30 Uhr. Dienstag ist Ruhetag.
@@ -54,7 +54,7 @@ features:
 marquee:
   title: Das lieben unsere Kunden
   description: Kundenbilder
-  headline: ALTE SCHMIEDE
+  headline: SHOPBITE
   items:
     - productId: 019a4f2e717b7df7a349761a56c43ac3
       image: https://shopware.shopbite.de/media/e4/82/55/1762465420/72.webp
@@ -67,7 +67,7 @@ marquee:
 gallery:
   title: Restaurant
   description: Genießen Sie leckeres Essen in einem rustikalen und gemütlichen Ambiente.
-  headline: ALTE SCHMIEDE
+  headline: SHOPBITE
   links:
     - label: Tisch reservieren
       to: tel:+49610471427
@@ -89,3 +89,15 @@ gallery:
       alt: La Fattoria Restaurant Innenbereich 6
     - image: https://nbg1.your-objectstorage.com/lafattoria-public/media/30/f7/76/1763383122/restaurant10.webp
       alt: La Fattoria Restaurant Innenbereich 10
+cta:
+  title: Jetzt bestellen!
+  description: Genieße die italienische Küche, frisch zubereitet und direkt zu dir geliefert oder vor Ort genießen.
+  backgroundImage: https://shopware.shopbite.de/media/f5/19/4a/1762546880/category-pizza-header.webp
+  links:
+    - label: Zur Speisekarte
+      to: /speisekarte
+      color: primary
+    - label: Tisch reservieren
+      to: tel:+49610471427
+      variant: outline
+      trailingIcon: i-lucide-phone

package/content/unternehmen/impressum.md

@@ -2,25 +2,21 @@
 
 ## Angaben gemäß § 5 TMG
 
-Bekim Veliu und Cefajet Veliu GbR
+Lirim Veliu<br>
+Hausener Straße 31<br>
+63165 Mühlheim am Main<br>
+Deutschland
 
-Kantstr. 6<br>63179 Obertshausen<br>Deutschland
-
-**Vertreten durch:**<br>Bekim Veliu
-
-**Kontakt:**<br>Telefon: +49 6104 71427<br>E-Mail: service@pizzeria-lafattoria.de
-
-## Umsatzsteuer-ID
-
-Umsatzsteuer-Identifikationsnummer gemäß § 27 a Umsatzsteuergesetz:
+lirim@veliu.net
 
 ## Verantwortlich für den Inhalt nach § 55 Abs. 2 RStV
 
-Bekim Veliu<br>Kantstr. 6<br>63179 Obertshausen
-
-## Administrator und technischer Ansprechpartner dieser Seite
+Lirim Veliu<br>
+Hausener Straße 31<br>
+63165 Mühlheim am Main<br>
+Deutschland
 
-Lirim Veliu<br>lirim@veliu.net
+lirim@veliu.net
 
 ## Haftungshinweis
 

package/content.config.ts

@@ -10,6 +10,7 @@ const createLinkSchema = () =>
     icon: z.string().optional().editor({ input: "icon" }),
     size: createEnum(["xs", "sm", "md", "lg", "xl"]),
     trailing: z.boolean().optional(),
+    trailingIcon: z.string().optional().editor({ input: "icon" }),
     target: createEnum(["_blank", "_self"]),
     color: createEnum([
       "primary",
@@ -107,6 +108,10 @@ export default defineContentConfig({
           ),
           links: z.array(createLinkSchema()),
         }),
+        cta: createBaseSchema().extend({
+          links: z.array(createLinkSchema()),
+          backgroundImage: z.string().optional(),
+        }),
       }),
     }),
     navigation: defineCollection({

package/nuxt.config.ts

@@ -47,8 +47,8 @@ export default defineNuxtConfig({
     apiClientConfig: {},
     public: {
       site: {
-        name: "Pizzeria La Fattoria",
-        description: "Italienisch-deutsche Küche in Obertshausen",
+        name: "ShopBite",
+        description: "Reduziere deine Kosten und steigere deinen Umsatz",
         countryId: "",
       },
       storeUrl: "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shopbite-de/storefront",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "main": "nuxt.config.ts",
   "description": "Shopware storefront for food delivery shops",
   "keywords": [