umwd-components 0.1.834 → 0.1.836

package/dist/esm/src/data/actions/logistics/note/createNoteAction.js

@@ -0,0 +1,77 @@
+"use server";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { z } from 'zod';
+import { mutateData } from '../../../services/mutate-data.js';
+import { flattenAttributes } from '../../../../lib/utils.js';
+
+const schemaUpdate = z.object({
+    content: z
+        .string()
+        .min(10, "Description must be at least 10 characters long")
+        .max(5000, "Description cannot be more than 5000 characters long"),
+});
+async function createNoteAction(related, prevState, formData) {
+    if (related === null || related === undefined) {
+        return {
+            ...prevState,
+            zodErrors: null,
+            strapiErrors: null,
+            message: "Failed to Create Note. Related entity is missing.",
+            severity: "error",
+        };
+    }
+    const validatedFields = schemaUpdate.safeParse({
+        content: formData.get("content"),
+    });
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            strapiErrors: null,
+            message: null,
+            severity: null,
+        };
+    }
+    const { data } = validatedFields;
+    const noteData = {
+        data: {
+            ...data,
+            related,
+        },
+    };
+    const responseData = await mutateData("POST", `/api/notes`, noteData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            zodErrors: null,
+            strapiErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+            severity: "error",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            zodErrors: null,
+            strapiErrors: responseData.error,
+            message: "Failed to Create Note.",
+            severity: "error",
+        };
+    }
+    const flattenedData = flattenAttributes(responseData);
+    return {
+        ...prevState,
+        zodErrors: null,
+        message: "New Note Created",
+        severity: "success",
+        data: flattenedData,
+        strapiErrors: null,
+    };
+}
+
+export { createNoteAction };

package/dist/esm/src/data/actions/logistics/report/createReportAction.js

@@ -0,0 +1,53 @@
+"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';
+
+// import { format } from "date-fns";
+async function createReportAction(related, type, prevState, formData) {
+    const parsedFormData = parseFormData(formData);
+    const reportData = {
+        data: {
+            ...parsedFormData.data,
+            related,
+            type,
+        },
+    };
+    const responseData = await mutateData("POST", `/api/reports`, reportData);
+    console.log("responseData", responseData);
+    if (!responseData) {
+        return {
+            ...prevState,
+            zodErrors: null,
+            strapiErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+            severity: "error",
+        };
+    }
+    if (responseData.error) {
+        return {
+            ...prevState,
+            zodErrors: null,
+            strapiErrors: responseData.error,
+            message: "Failed to Create Report.",
+            severity: "error",
+        };
+    }
+    const flattenedData = flattenAttributes(responseData);
+    return {
+        ...prevState,
+        zodErrors: null,
+        message: "New Report Created",
+        severity: "success",
+        data: flattenedData,
+        strapiErrors: null,
+    };
+}
+
+export { createReportAction };

package/dist/esm/src/data/actions/logistics/vendor/createVendorAction.js

@@ -0,0 +1,60 @@
+"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 createVendorAction(prevState, formData) {
+    try {
+        const parsedFormData = parseFormData(formData);
+        if (parsedFormData.data.products) {
+            parsedFormData.data.products = JSON.parse(parsedFormData.data.products);
+        }
+        const responseData = await mutateData("POST", `/api/vendor-profiles`, parsedFormData);
+        if (!responseData) {
+            return {
+                ...prevState,
+                strapiErrors: null,
+                zodErrors: null,
+                message: "Something went wrong while creating the vendor. Please try again.",
+                severity: "error",
+            };
+        }
+        if (responseData.error) {
+            return {
+                ...prevState,
+                strapiErrors: responseData.error,
+                zodErrors: null,
+                message: "Failed to create vendor. Please check the form and try again.",
+                severity: "error",
+            };
+        }
+        const flattenedData = flattenAttributes(responseData);
+        return {
+            ...prevState,
+            data: flattenedData,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Vendor created successfully!",
+            severity: "success",
+        };
+    }
+    catch (error) {
+        console.error("Error creating vendor:", error);
+        return {
+            ...prevState,
+            data: null,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "An unexpected error occurred. Please try again later.",
+            severity: "error",
+        };
+    }
+}
+
+export { createVendorAction };

package/dist/esm/src/data/actions/logistics/vendor/updateVendorAction.js

@@ -0,0 +1,63 @@
+"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 updateVendorAction(documentId, prevState, formData) {
+    try {
+        const rawFormData = Object.fromEntries(formData);
+        const parsedFormData = parseFormData(formData);
+        if (parsedFormData.data.products) {
+            parsedFormData.data.products = JSON.parse(parsedFormData.data.products);
+        }
+        const responseData = await mutateData("PUT", `/api/vendor-profiles/${documentId}`, parsedFormData);
+        if (!responseData) {
+            return {
+                ...prevState,
+                data: null,
+                strapiErrors: null,
+                zodErrors: null,
+                message: "Something went wrong while updating the vendor. Please try again.",
+                severity: "error",
+            };
+        }
+        if (responseData.error) {
+            return {
+                ...prevState,
+                data: null,
+                strapiErrors: responseData.error,
+                zodErrors: null,
+                message: "Failed to update vendor. Please check the form and try again.",
+                severity: "error",
+            };
+        }
+        const flattenedData = flattenAttributes(responseData);
+        return {
+            ...prevState,
+            data: flattenedData,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Vendor updated successfully!",
+            severity: "success",
+        };
+    }
+    catch (error) {
+        console.error("Error updating vendor:", error);
+        return {
+            ...prevState,
+            data: null,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "An unexpected error occurred. Please try again later.",
+            severity: "error",
+        };
+    }
+}
+
+export { updateVendorAction };

package/dist/esm/src/data/actions/media/minio/deleteMinioMediaAction.js

@@ -0,0 +1,47 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { minioDeleteService } from '../../../services/common/media/minio/minioDeleteService.js';
+import { flattenAttributes } from '../../../../lib/utils.js';
+
+async function deleteMinioMediaAction(bucketName, fileName, prevState) {
+    if (!bucketName || !fileName) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            data: null,
+            message: "Invalid Image",
+        };
+    }
+    // DELETE IMAGE FROM MINIO
+    const fileDeleteResponse = await minioDeleteService(bucketName, fileName);
+    if (!fileDeleteResponse) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (fileDeleteResponse.error) {
+        return {
+            ...prevState,
+            strapiErrors: fileDeleteResponse.error,
+            zodErrors: null,
+            message: "Failed to Delete File.",
+        };
+    }
+    const flattenedData = flattenAttributes(fileDeleteResponse);
+    return {
+        ...prevState,
+        data: flattenedData,
+        zodErrors: null,
+        strapiErrors: null,
+        message: "Image Deleted Successfully",
+    };
+}
+
+export { deleteMinioMediaAction };

package/dist/esm/src/data/actions/media/minio/uploadMinioMediaAction.js

@@ -0,0 +1,95 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { minioUploadService } from '../../../services/common/media/minio/minioUploadService.js';
+import { flattenAttributes } from '../../../../lib/utils.js';
+
+async function uploadMinioMediaAction(prevState, formData) {
+    try {
+        // CONVERT FORM DATA TO OBJECT
+        const rawFormData = Object.fromEntries(formData);
+        const bucketName = rawFormData.bucketName;
+        const files = formData.getAll("files");
+        const reference = rawFormData.reference;
+        const refID = rawFormData.refID;
+        const field = rawFormData.field;
+        // Filter out empty files and ensure we have File objects
+        const validFiles = files.filter((file) => file instanceof File && file.size > 0 && file.name !== undefined);
+        if (validFiles.length === 0) {
+            return {
+                ...prevState,
+                strapiErrors: null,
+                zodErrors: null,
+                message: "No valid files provided",
+                severity: "error",
+            };
+        }
+        // Prepare files data for upload
+        const filesData = [];
+        for (const file of validFiles) {
+            const arrayBuffer = await file.arrayBuffer();
+            const fileContent = Buffer.from(arrayBuffer).toString("base64");
+            filesData.push({
+                fileName: file.name,
+                fileContent: fileContent,
+            });
+        }
+        // UPLOAD ALL FILES TO MINIO
+        const fileUploadResponse = await minioUploadService(bucketName, filesData, reference, refID, field);
+        if (!fileUploadResponse) {
+            return {
+                ...prevState,
+                strapiErrors: null,
+                zodErrors: null,
+                message: "Failed to upload files",
+                severity: "error",
+            };
+        }
+        if (fileUploadResponse.error) {
+            return {
+                ...prevState,
+                strapiErrors: fileUploadResponse.error,
+                zodErrors: null,
+                message: "Failed to upload files",
+                severity: "error",
+            };
+        }
+        // Handle partial failures
+        if (fileUploadResponse.errors && fileUploadResponse.errors.length > 0) {
+            const successCount = fileUploadResponse.uploadResults?.length || 0;
+            const errorCount = fileUploadResponse.errors.length;
+            return {
+                ...prevState,
+                data: fileUploadResponse.uploadResults,
+                zodErrors: null,
+                strapiErrors: null,
+                message: `Uploaded ${successCount} file(s) successfully. ${errorCount} file(s) failed.`,
+                severity: successCount > 0 ? "warning" : "error",
+            };
+        }
+        const flattenedData = flattenAttributes(fileUploadResponse);
+        return {
+            ...prevState,
+            data: flattenedData,
+            zodErrors: null,
+            strapiErrors: null,
+            message: `Successfully uploaded ${validFiles.length} file(s)`,
+            severity: "success",
+        };
+    }
+    catch (error) {
+        console.error("Upload action error:", error);
+        return {
+            ...prevState,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Failed to process file upload",
+            severity: "error",
+        };
+    }
+}
+
+export { uploadMinioMediaAction };

package/dist/esm/src/data/actions/media/updateMediaAction.js

@@ -0,0 +1,40 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { flattenAttributes } from '../../../lib/utils.js';
+import { parseFormData } from '../../../lib/parseFormData.js';
+import { fileUpdateService } from '../../services/file-service.js';
+
+async function updateMediaAction(prevState, formData) {
+    const rawFormData = Object.fromEntries(formData);
+    const parsedFormData = parseFormData(formData);
+    const id = rawFormData.id;
+    const responseData = await fileUpdateService(parsedFormData.data, id.toString());
+    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 Register.",
+        };
+    }
+    const flattenedData = flattenAttributes(responseData);
+    return {
+        ...prevState,
+        message: "Media Updated",
+        data: flattenedData,
+        strapiErrors: null,
+    };
+}
+
+export { updateMediaAction };

package/dist/esm/src/data/actions/media/uploadBase64MediaAction.js

@@ -0,0 +1,112 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { z } from 'zod';
+import { mutateData } from '../../services/mutate-data.js';
+import { flattenAttributes } from '../../../lib/utils.js';
+import { parseFormData } from '../../../lib/parseFormData.js';
+
+//"use server"
+// VALIDATE IMAGE WITH ZOD
+const fileSchema = z.object({
+    files: z.any(),
+    /* .refine((file) => {
+        if (file.size === 0 || file.name === undefined) return false;
+        else return true;
+      }, "Please update or add new image.")
+  
+      .refine(
+        (file) => ACCEPTED_FILE_TYPES.includes(file?.type),
+        ".jpg, .jpeg, .png and .webp files are accepted."
+      )
+      .refine((file) => file.size <= MAX_FILE_SIZE, `Max file size is 5MB.`), */
+});
+async function uploadBase64MediaAction(path, documentId, component_name, prevState, formData) {
+    // CONVERT FORM DATA TO OBJECT
+    const rawFormData = Object.fromEntries(formData);
+    parseFormData(formData);
+    // VALIDATE THE IMAGE
+    const validatedFields = fileSchema.safeParse({
+        files: rawFormData.files,
+    });
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            strapiErrors: null,
+            data: null,
+            message: "Invalid Image",
+        };
+    }
+    // UPLOAD NEW IMAGE TO MEDIA LIBRARY
+    // const fileUploadResponse = await fileUploadService(formData);
+    const url = `${path}/${documentId}`;
+    // const files = rawFormData.files;
+    const files = formData.getAll("files");
+    files
+        .map((file) => {
+        if (file instanceof File) {
+            return file.name;
+        }
+        return null;
+    })
+        .filter((name) => name !== null);
+    const filesData = await Promise.all(files.map(async (file) => {
+        if (file instanceof File) {
+            const ext = file.name.split(".").pop(); // Extract the file extension
+            const mime = file.type; // Get the MIME type of the file
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            return new Promise((resolve) => {
+                reader.onloadend = () => {
+                    const base64_string = reader.result?.toString().split(",")[1] || "";
+                    // Get the base64 string representation of the file
+                    // Use the mime and base64_string as needed
+                    resolve({
+                        name: file.name,
+                        ext: ext,
+                        mime: mime,
+                        base64_string: base64_string,
+                    });
+                };
+            });
+        }
+        return null;
+    }));
+    const parsedData = {
+        data: {
+            documentId: documentId,
+            [component_name]: filesData[0],
+        },
+    };
+    const fileUploadResponse = await mutateData("PUT", url, parsedData);
+    if (!fileUploadResponse) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (fileUploadResponse.error) {
+        return {
+            ...prevState,
+            strapiErrors: fileUploadResponse.error,
+            zodErrors: null,
+            message: "Failed to Upload File.",
+        };
+    }
+    const flattenedData = flattenAttributes(fileUploadResponse);
+    return {
+        ...prevState,
+        data: flattenedData,
+        zodErrors: null,
+        strapiErrors: null,
+        message: "File Uploaded",
+    };
+}
+
+export { uploadBase64MediaAction };

package/dist/esm/src/data/actions/media/uploadMediaAction.js

@@ -0,0 +1,79 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { z } from 'zod';
+import { fileUploadService } from '../../services/file-service.js';
+import { flattenAttributes } from '../../../lib/utils.js';
+import { parseFormData } from '../../../lib/parseFormData.js';
+
+const MAX_FILE_SIZE = 5000000;
+const ACCEPTED_IMAGE_TYPES = [
+    "image/jpeg",
+    "image/jpg",
+    "image/png",
+    "image/webp",
+];
+// VALIDATE IMAGE WITH ZOD
+const imageSchema = z.object({
+    image: z
+        .any()
+        .refine((file) => {
+        if (file.size === 0 || file.name === undefined)
+            return false;
+        else
+            return true;
+    }, "Please update or add new image.")
+        .refine((file) => ACCEPTED_IMAGE_TYPES.includes(file?.type), ".jpg, .jpeg, .png and .webp files are accepted.")
+        .refine((file) => file.size <= MAX_FILE_SIZE, `Max file size is 5MB.`),
+});
+async function uploadMediaAction(prevState, formData) {
+    // CONVERT FORM DATA TO OBJECT
+    const rawFormData = Object.fromEntries(formData);
+    console.log(rawFormData.files);
+    const parsedFormData = parseFormData(formData);
+    console.log(parsedFormData);
+    // VALIDATE THE IMAGE
+    const validatedFields = imageSchema.safeParse({
+        image: rawFormData.files,
+    });
+    if (!validatedFields.success) {
+        return {
+            ...prevState,
+            zodErrors: validatedFields.error.flatten().fieldErrors,
+            strapiErrors: null,
+            data: null,
+            message: "Invalid Image",
+        };
+    }
+    // UPLOAD NEW IMAGE TO MEDIA LIBRARY
+    const fileUploadResponse = await fileUploadService(formData);
+    if (!fileUploadResponse) {
+        return {
+            ...prevState,
+            strapiErrors: null,
+            zodErrors: null,
+            message: "Ops! Something went wrong. Please try again.",
+        };
+    }
+    if (fileUploadResponse.error) {
+        return {
+            ...prevState,
+            strapiErrors: fileUploadResponse.error,
+            zodErrors: null,
+            message: "Failed to Upload File.",
+        };
+    }
+    const flattenedData = flattenAttributes(fileUploadResponse);
+    return {
+        ...prevState,
+        data: flattenedData,
+        zodErrors: null,
+        strapiErrors: null,
+        message: "Image Uploaded",
+    };
+}
+
+export { uploadMediaAction };