umwd-components 0.1.715 → 0.1.717

package/dist/esm/src/context/e-commerce/cart/CartContext.js

@@ -0,0 +1,102 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useReducer, useEffect } from 'react';
+import { useCookieConsent } from '../../../components/common/cookie-consent/CookieConsentContext.js';
+import { getCookie } from '../../../lib/getCookie.js';
+import { setCookie } from '../../../lib/setCookie.js';
+
+const initialState = {
+    items: [],
+    totalExVAT: 0,
+    totalVAT: 0,
+    totalInclVAT: 0,
+    totalAmount: 0,
+};
+const CartContext = createContext({
+    state: initialState,
+    dispatch: () => undefined,
+});
+const cartReducer = (state, action) => {
+    switch (action.type) {
+        case "ADD_ITEM": {
+            const existingItemIndex = state.items.findIndex((item) => item.id === action.payload.id);
+            if (existingItemIndex > -1) {
+                const updatedItems = state.items.map((item, index) => index === existingItemIndex
+                    ? { ...item, quantity: item.quantity + action.payload.quantity }
+                    : item);
+                return { ...state, items: updatedItems };
+            }
+            return { ...state, items: [...state.items, action.payload] };
+        }
+        case "REMOVE_ITEM": {
+            const existingItemIndex = state.items.findIndex((item) => item.id === action.payload.id);
+            if (existingItemIndex > -1) {
+                const updatedItems = state.items
+                    .map((item, index) => index === existingItemIndex
+                    ? { ...item, quantity: item.quantity - 1 }
+                    : item)
+                    .filter((item) => item.quantity > 0);
+                return { ...state, items: updatedItems };
+            }
+            return state;
+        }
+        case "SET_ITEMS":
+            return {
+                ...state,
+                items: action.payload,
+            };
+        case "UPDATE_TOTALS":
+            return {
+                ...state,
+                ...action.payload,
+            };
+        default:
+            return state;
+    }
+};
+const CartProvider = ({ children }) => {
+    const [state, dispatch] = useReducer(cartReducer, initialState);
+    const { consentGiven } = useCookieConsent();
+    const calculateTotals = () => {
+        let totalExVAT = 0;
+        let totalVAT = 0;
+        let totalInclVAT = 0;
+        let totalAmount = 0;
+        state.items.forEach((item) => {
+            totalExVAT += item.price_excl_vat * item.quantity;
+            totalVAT += item.price_excl_vat * (item.vat_rate / 100) * item.quantity;
+            totalInclVAT += item.price_incl_vat * item.quantity;
+            totalAmount += item.quantity;
+        });
+        dispatch({
+            type: "UPDATE_TOTALS",
+            payload: { totalExVAT, totalVAT, totalInclVAT, totalAmount },
+        });
+    };
+    useEffect(() => {
+        if (consentGiven) {
+            const savedCart = getCookie("cart");
+            if (savedCart) {
+                dispatch({ type: "SET_ITEMS", payload: JSON.parse(savedCart) });
+            }
+        }
+    }, [consentGiven]);
+    useEffect(() => {
+        if (consentGiven) {
+            setCookie("cart", JSON.stringify(state.items), 365); // Cookie expires in 1 year
+        }
+    }, [state.items, consentGiven]);
+    useEffect(() => {
+        calculateTotals();
+    }, [state.items]);
+    return (jsx(CartContext.Provider, { value: { state, dispatch }, children: children }));
+};
+const useCart = () => useContext(CartContext);
+
+export { CartProvider, useCart };

package/dist/esm/src/context/e-commerce/checkout/CheckoutContext.js

@@ -0,0 +1,140 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useReducer, useEffect } from 'react';
+import { isCustomerProfileCompleteV2 } from '../../../lib/isCustomerProfileCompleteV2.js';
+import { isAddressComplete } from '../../../lib/isAddressComplete.js';
+import { areBusinessCredentailsComplete } from '../../../lib/areBusinessCredentialsComplete.js';
+import { useClientSideCart } from '../../../components/e-commerce/cart/hooks.js';
+import { useSession } from '../../auth/SessionContext.js';
+import isVATValid from '../../../lib/isVATValid.js';
+import isEORIValid from '../../../lib/isEORIValid.js';
+
+const initialState = {
+    confirmations: {
+        itemsInCart: false,
+        customerProfileComplete: false,
+        companyAddressComplete: false,
+        deliveryAddressComplete: false,
+        billingAddressComplete: false,
+        businessCredentailsComplete: false,
+        hasVAT: false,
+        hasEORI: false,
+        hasValidatedVAT: false,
+        hasValidatedEORI: false,
+    },
+    delivery_options: [{ id: 1, label: "ptt" }],
+    payment_options: [{ id: 1, label: "ideal" }],
+    prefersBillingAddress: true,
+    prefersDeliveryAddress: true,
+    customer_reference: "",
+};
+const CheckoutContext = createContext({
+    state: initialState,
+    runAllChecks: () => undefined,
+    togglePrefersBillingAddress: () => undefined,
+    togglePrefersDeliveryAddress: () => undefined,
+    setCustomerInternalReference: () => undefined,
+});
+const checkoutReducer = (state, action) => {
+    switch (action.type) {
+        case "UPDATE_CONFIRMATIONS":
+            return {
+                ...state,
+                confirmations: {
+                    ...state.confirmations,
+                    ...action.payload,
+                },
+            };
+        case "SET_PREFERS_BILLING_ADDRESS":
+            return {
+                ...state,
+                prefersBillingAddress: action.payload.prefersBillingAddress,
+            };
+        case "SET_PREFERS_DELIVERY_ADDRESS":
+            return {
+                ...state,
+                prefersDeliveryAddress: action.payload.prefersDeliveryAddress,
+            };
+        case "SET_customer_reference":
+            return {
+                ...state,
+                customer_reference: action.payload.customer_reference,
+            };
+        default:
+            return state;
+    }
+};
+const CheckoutProvider = ({ children }) => {
+    const [state, dispatch] = useReducer(checkoutReducer, initialState);
+    const { user, loading, error } = useSession();
+    const cart = useClientSideCart();
+    const runAllChecks = () => {
+        const itemsInCart = cart.state.items.length > 0;
+        const customerProfileComplete = user?.customer_profile
+            ? Object.values(isCustomerProfileCompleteV2(user?.customer_profile)).every((value) => value === true)
+            : false;
+        const companyAddressComplete = isAddressComplete(user?.customer_profile?.company_address);
+        const deliveryAddressComplete = isAddressComplete(user?.customer_profile?.delivery_address);
+        const billingAddressComplete = isAddressComplete(user?.customer_profile?.billing_address);
+        const businessCredentailsComplete = areBusinessCredentailsComplete(user?.customer_profile?.business_credentials);
+        const hasVAT = Boolean(user?.customer_profile?.business_credentials?.VAT_number);
+        const hasEORI = Boolean(user?.customer_profile?.business_credentials?.EORI_number);
+        const hasValidatedVAT = isVATValid(user?.customer_profile?.business_credentials);
+        const hasValidatedEORI = isEORIValid(user?.customer_profile?.business_credentials);
+        dispatch({
+            type: "UPDATE_CONFIRMATIONS",
+            payload: {
+                itemsInCart,
+                customerProfileComplete,
+                companyAddressComplete,
+                deliveryAddressComplete,
+                billingAddressComplete,
+                businessCredentailsComplete,
+                hasVAT,
+                hasEORI,
+                hasValidatedVAT,
+                hasValidatedEORI,
+            },
+        });
+    };
+    const togglePrefersBillingAddress = () => {
+        dispatch({
+            type: "SET_PREFERS_BILLING_ADDRESS",
+            payload: { prefersBillingAddress: !state.prefersBillingAddress },
+        });
+    };
+    const togglePrefersDeliveryAddress = () => {
+        dispatch({
+            type: "SET_PREFERS_DELIVERY_ADDRESS",
+            payload: { prefersDeliveryAddress: !state.prefersDeliveryAddress },
+        });
+    };
+    const setCustomerInternalReference = (value) => {
+        dispatch({
+            type: "SET_customer_reference",
+            payload: { customer_reference: value },
+        });
+    };
+    useEffect(() => {
+        if (user) {
+            runAllChecks();
+        }
+    }, [user]);
+    const value = {
+        state,
+        runAllChecks,
+        togglePrefersBillingAddress,
+        togglePrefersDeliveryAddress,
+        setCustomerInternalReference,
+    };
+    return (jsx(CheckoutContext.Provider, { value: value, children: children }));
+};
+const useCheckout = () => useContext(CheckoutContext);
+
+export { CheckoutProvider, useCheckout };

package/dist/esm/src/data/actions/auth-actions.js

@@ -0,0 +1,211 @@
+"use server";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { z } from 'zod';
+import { cookies } from 'next/headers';
+import { redirect } from 'next/navigation';
+import { loginUserService, registerUserService, forgotPasswordService, resetPasswordService } from '../services/auth-service.js';
+
+const config = {
+    maxAge: 60 * 60 * 24 * 7, // 1 week
+    path: "/",
+    domain: process.env.HOST ?? "localhost",
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+};
+const schemaRegister = z.object({
+    username: z.string().min(3).max(20, {
+        message: "Username must be between 3 and 20 characters",
+    }),
+    password: z.string().min(6).max(100, {
+        message: "Password must be between 6 and 100 characters",
+    }),
+    email: z.string().email({
+        message: "Please enter a valid email address",
+    }),
+    redirect: z.string().optional(),
+});
+async function registerUserAction(prevState, formData) {
+    const validatedFields = schemaRegister.safeParse({
+        username: formData.get("username"),
+        password: formData.get("password"),
+        email: formData.get("email"),
+    });
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            strapiErrors: null,
+            message: "Missing Fields. Failed to Register.",
+        };
+    }
+    const responseData = await registerUserService(validatedFields.data);
+    if (!responseData || responseData.error) {
+        return {
+            ...prevState,
+            strapiErrors: responseData?.error?.message || null,
+            zodErrors: null,
+            message: responseData?.error
+                ? "Failed to Register."
+                : "Ops! Something went wrong. Please try again.",
+        };
+    }
+    cookies().set("jwt", responseData.jwt, config);
+    if (!formData.get("redirect")) {
+        return redirect("/dashboard");
+    }
+    const redirectValue = formData.get("redirect");
+    console.log("redirectValue", redirectValue);
+    const searchParams = new URLSearchParams();
+    searchParams.append("message", "Please complete your profile. We've send you an email with a confirmation link.");
+    searchParams.append("severity", "info");
+    const redirectURL = `${redirectValue?.toString() ?? "/dashboard"}?${searchParams.toString()}`;
+    redirect(redirectURL);
+}
+const schemaLogin = z.object({
+    identifier: z
+        .string()
+        .min(3, {
+        message: "Identifier must have at least 3 or more characters",
+    })
+        .max(80, {
+        message: "Please enter a valid username or email address",
+    }),
+    password: z
+        .string()
+        .min(6, {
+        message: "Password must have at least 6 or more characters",
+    })
+        .max(100, {
+        message: "Password must be between 6 and 100 characters",
+    }),
+    redirect: z.string().optional(),
+});
+async function loginUserAction(prevState, formData) {
+    const validatedFields = schemaLogin.safeParse({
+        identifier: formData.get("identifier"),
+        password: formData.get("password"),
+    });
+    // Validate the form fields
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            message: "Missing Fields. Failed to Login.",
+        };
+    }
+    // Call the login service
+    const responseData = await loginUserService(validatedFields.data);
+    // Handle the case where the response data is null or contains an error
+    if (!responseData || responseData.error) {
+        console.log("Login Error:", responseData);
+        return {
+            ...prevState,
+            strapiErrors: responseData?.error?.message || null,
+            zodErrors: null,
+            message: responseData?.error
+                ? "Failed to Login."
+                : "Ops! Something went wrong. Please try again.",
+        };
+    }
+    // Set the JWT cookie and redirect the user
+    cookies().set("jwt", responseData.jwt, config);
+    const redirectURL = formData.get("redirect")?.toString() ?? null;
+    const successRedirectURL = `${redirectURL ? redirectURL : "/dashboard"}?login=success`;
+    redirect(successRedirectURL);
+}
+const schemaForgotPassword = z.object({
+    email: z.string().email({
+        message: "Please enter a valid email address",
+    }),
+});
+async function forgotPasswordAction(prevState, formData) {
+    const validatedFields = schemaForgotPassword.safeParse({
+        email: formData.get("email"),
+    });
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            message: "Invalid email address.",
+        };
+    }
+    const responseData = await forgotPasswordService(validatedFields.data);
+    console.log("Forgot Password Response:", responseData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            strapiErrors: responseData.error,
+            zodErrors: null,
+            message: "Failed to send reset email.",
+        };
+    }
+    return {
+        ...prevState,
+        message: "Password reset email sent successfully.",
+    };
+}
+const schemaResetPassword = z.object({
+    password: z.string().min(6).max(100, {
+        message: "Password must be between 6 and 100 characters",
+    }),
+    passwordConfirmation: z.string().min(6).max(100, {
+        message: "Password confirmation must be between 6 and 100 characters",
+    }),
+    code: z.string(),
+});
+async function resetPasswordAction(prevState, formData) {
+    const validatedFields = schemaResetPassword.safeParse({
+        password: formData.get("password"),
+        passwordConfirmation: formData.get("passwordConfirmation"),
+        code: formData.get("code"),
+    });
+    console.log("validatedFields", validatedFields);
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            message: "Invalid input.",
+        };
+    }
+    const responseData = await resetPasswordService(validatedFields.data);
+    console.log("Reset Password Response:", responseData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            strapiErrors: responseData.error,
+            zodErrors: null,
+            message: "Failed to reset password.",
+        };
+    }
+    return {
+        ...prevState,
+        message: "Password reset successfully.",
+    };
+}
+async function logoutAction() {
+    cookies().set("jwt", "", { ...config, maxAge: 0 });
+    redirect("/");
+}
+
+export { forgotPasswordAction, loginUserAction, logoutAction, registerUserAction, resetPasswordAction };

package/dist/esm/src/data/actions/e-commerce/categories/createCategoryAction.js

@@ -0,0 +1,49 @@
+"use server";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { mutateData } from '../../../services/mutate-data.js';
+import { flattenAttributes } from '../../../../lib/utils.js';
+import { parseFormData } from '../../../../lib/parseFormData.js';
+
+async function createCategoryAction(prevState, formData) {
+    Object.fromEntries(formData);
+    const parsedFormData = parseFormData(formData);
+    /**
+     * INFO: The products are JSONStringyfied in the frontend to add them to the hidden input
+     * in productSelector.tsx but they should be parsed before sending them to the backend
+     */
+    if (parsedFormData.data.products) {
+        parsedFormData.data.products = JSON.parse(parsedFormData.data.products);
+    }
+    const responseData = await mutateData("POST", `/api/product-categories`, parsedFormData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            severity: "error",
+            strapiErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            severity: "error",
+            strapiErrors: responseData.error,
+            message: "Failed to Create Category.",
+        };
+    }
+    const flattenedData = flattenAttributes(responseData);
+    return {
+        ...prevState,
+        severity: "success",
+        message: "Category Created Successfully",
+        data: flattenedData,
+        strapiErrors: null,
+    };
+}
+
+export { createCategoryAction };

package/dist/esm/src/data/actions/e-commerce/categories/updateCategoryAction.js

@@ -0,0 +1,49 @@
+"use server";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { mutateData } from '../../../services/mutate-data.js';
+import { flattenAttributes } from '../../../../lib/utils.js';
+import { parseFormData } from '../../../../lib/parseFormData.js';
+
+async function updateCategoryAction(prevState, formData) {
+    const rawFormData = Object.fromEntries(formData);
+    const parsedFormData = parseFormData(formData);
+    /**
+     * INFO: The products are JSONStringyfied in the frontend to add them to the hidden input
+     * in productSelector.tsx but they should be parsed before sending them to the backend
+     */
+    if (parsedFormData.data.products) {
+        parsedFormData.data.products = JSON.parse(parsedFormData.data.products);
+    }
+    const responseData = await mutateData("PUT", `/api/product-categories/${rawFormData.id}`, parsedFormData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            severity: "error",
+            strapiErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            severity: "error",
+            strapiErrors: responseData.error,
+            message: "Failed to Update Category.",
+        };
+    }
+    const flattenedData = flattenAttributes(responseData);
+    return {
+        ...prevState,
+        severity: "success",
+        message: "Category Updated Successfully",
+        data: flattenedData,
+        strapiErrors: null,
+    };
+}
+
+export { updateCategoryAction };

package/dist/esm/src/data/actions/e-commerce/checkout-action.js

@@ -0,0 +1,93 @@
+"use server";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { mutateData } from '../../services/mutate-data.js';
+import { parseFormData } from '../../../lib/parseFormData.js';
+import { createMolliePayment } from '../../../lib/molliePaymentProvider.js';
+import { redirect } from 'next/navigation';
+
+/** INFO: The checkout action handles
+ * - creation of the order
+ * - creation of the payment
+ * - the creation of the invoice is handled by the Strapi cms
+ * - the shipment should also be handled by the Strapi cms
+ * - this function runs when clicking the "proceed to payment" button
+ * */
+async function checkoutAction(prevState, formData) {
+    const parsedFormData = parseFormData(formData);
+    console.log("parsedFormData", parsedFormData);
+    // validate the parsedFormData
+    // STEP 1
+    // create the order
+    const responseData = await mutateData("POST", `/api/opos/`, parsedFormData);
+    console.log("responseData", responseData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            strapiErrors: responseData.error,
+            message: "Failed to create order.",
+        };
+    }
+    // STEP 2
+    // create a payment with the mollie client api, return either the payment or an error
+    const providerPayment = process.env.NODE_ENV === "production"
+        ? await createMolliePayment(responseData)
+        : null; // for development purposes
+    // TODO Possibly its better to do this within the cms to better seperate concerns, besides this should be created
+    // near to where it will be saved so it will reduce loads being send back and forth
+    // create the payment use id from response data for connection
+    if (typeof providerPayment === "string") {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            message: providerPayment,
+        };
+    }
+    // Safe to access providerPayment.id and providerPayment.parseJSON() here
+    const paymentData = process.env.NODE_ENV === "production" && providerPayment
+        ? await mutateData("POST", `api/payments/`, {
+            data: {
+                opo: responseData.id,
+                payment_status: providerPayment.status,
+                provider_id: providerPayment.id,
+                provider_response: providerPayment,
+            },
+        })
+        : await mutateData("POST", `api/payments/`, {
+            data: {
+                opo: responseData.id,
+                payment_status: "open",
+            },
+        });
+    // Use paymentData as needed
+    if (paymentData.error) {
+        return {
+            ...prevState,
+            strapiErrors: paymentData.error,
+            message: "Failed to create payment.",
+        };
+    }
+    // Creating a invoice
+    // the creation of the invoice is entirely handled by the Strapi cms. the order on creation calls a service on the invoice
+    // that will create the invoice from the order. the same should be done for the payment, be carefull because in that case the
+    // payment should be created before the invoice.
+    // also a solution should be found for handling the redirectUrl and the webhookUrl
+    // create the shipping use id from response data for connection
+    // const flattenedData = flattenAttributes(responseData);
+    process.env.NODE_ENV === "production" && providerPayment
+        ? redirect(`${providerPayment.getCheckoutUrl()}`)
+        : redirect("/shop/check-out");
+}
+
+export { checkoutAction };

package/dist/esm/src/data/actions/e-commerce/enduser/profile-actions.js

@@ -0,0 +1,41 @@
+"use server";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { mutateData } from '../../../services/mutate-data.js';
+import { flattenAttributes } from '../../../../lib/utils.js';
+import { parseFormData } from '../../../../lib/parseFormData.js';
+
+async function updateEnduserProfileAction(id, prevState, formData) {
+    const parsedFormData = parseFormData(formData);
+    const responseData = await mutateData("PUT", `/api/enduser-profiles/${id}`, parsedFormData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            severity: "error",
+            strapiErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            severity: "error",
+            strapiErrors: responseData.error,
+            message: "Failed to update profile.",
+        };
+    }
+    const flattenedData = flattenAttributes(responseData);
+    return {
+        ...prevState,
+        severity: "success",
+        message: "Profile Updated Successfully",
+        data: flattenedData,
+        strapiErrors: null,
+    };
+}
+
+export { updateEnduserProfileAction };