attachwave 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1230691e6a9b38db9147f4b245eda8722e15c431b98813a2e85c7b96406a1db5
+  data.tar.gz: b6367e1e2218d5c1e85f8ede6062debf62dc67ef532932b065470986fc190e1e
+SHA512:
+  metadata.gz: 891b690c3a0e7f6b5731090ae71423a728c89db6bd32c59950fa2c117b836cee9e2712d772b2cdaba8cbd68ad5cb171130dd3055800187d895444099733c8374
+  data.tar.gz: 01e8efe7cd9624f2d5a6cb625411f9601932b8115282e8a88bf375ab3b826274ff53b7067a0798fce0f3e0ad48afb7b985e652176a9910f6fa96415fdbb6ba68

data/app/assets/config/attachwave_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/attachwave .js
+//= link_directory ../stylesheets/attachwave .css

data/app/assets/config/manifest.js

@@ -0,0 +1,9 @@
+//= link_directory ../javascripts/attachwave .js
+//= link_directory ../stylesheets/attachwave .css
+
+//= link attachwave/attachwave.js
+//= link attachwave/filepond.min.js
+//= link attachwave/filepond.min.css
+//= link attachwave/filepond-plugin-file-validate-type.min.js
+//= link attachwave/filepond-plugin-file-validate-size.min.js
+//= link attachwave/controllers/filepond_controller.js

data/app/assets/javascripts/attachwave/attachwave.js

@@ -0,0 +1,124 @@
+(function () {
+    console.log("📂 Attachwave inicializado (sin Stimulus)");
+
+    document.addEventListener("click", function (e) {
+        const btn = e.target.closest(".delete-attachment");
+        if (!btn) return;
+
+        e.preventDefault();
+
+        if (!confirm(btn.dataset.confirm || "¿Eliminar este archivo?")) return;
+
+        const id  = btn.dataset.id;
+        const row = document.getElementById(`adjunto_${id}`);
+
+        // Marcar fila como "en proceso"
+        if (row) {
+            row.style.backgroundColor = "#f0f0f0"; // gris clarito
+            row.style.opacity = "0.6";
+        }
+        btn.disabled = true;
+        btn.textContent = "Eliminando…";
+
+        fetch(btn.href, {
+            method: "DELETE",
+            headers: {
+                "X-CSRF-Token": document.querySelector('meta[name="csrf-token"]').content,
+                "Accept": "application/json"
+            }
+        })
+            .then(resp => resp.json())
+            .then(data => {
+                if (data.success) {
+                    if (row) row.remove();
+                } else {
+                    alert(data.error || "❌ Error al eliminar el archivo.");
+                    // restaurar estilos si falló
+                    if (row) {
+                        row.style.backgroundColor = "";
+                        row.style.opacity = "1";
+                    }
+                    btn.disabled = false;
+                    btn.textContent = "Eliminar";
+                }
+            })
+            .catch(err => {
+                console.error("Error:", err);
+                alert("❌ No se pudo eliminar el archivo.");
+                // restaurar estilos si falló
+                if (row) {
+                    row.style.backgroundColor = "";
+                    row.style.opacity = "1";
+                }
+                btn.disabled = false;
+                btn.textContent = "Eliminar";
+            });
+    });
+
+
+
+
+
+    function initFilepondUploader(el) {
+        const input = el.querySelector("input[type=file]");
+        if (!input) return;
+
+        if (typeof FilePond === "undefined") {
+            console.error("❌ Attachwave: FilePond no está cargado.");
+            return;
+        }
+
+        // Registrar plugins
+        FilePond.registerPlugin(
+            FilePondPluginFileValidateType,
+            FilePondPluginFileValidateSize
+        );
+
+        // Crear instancia de FilePond
+        FilePond.create(input, {
+            allowMultiple: true,
+            server: {
+                process: {
+                    url: el.dataset.uploadUrl,
+                    headers: {
+                        "X-CSRF-Token": document.querySelector(
+                            'meta[name="csrf-token"]'
+                        ).content,
+                    },
+                    onload: () => {
+                        console.info("✅ Archivo subido, refrescando tabla…");
+                        const model = el.dataset.model;
+                        const id = el.dataset.id;
+
+                        fetch(`/attachwave/attachments/index/${model}/${id}`)
+                            .then((resp) => resp.text())
+                            .then((html) => {
+                                const container = document.querySelector("#adjuntosTable");
+                                if (container) container.innerHTML = html;
+                            });
+                    },
+                },
+            },
+        });
+    }
+
+    // Inicializar en todos los uploaders ya presentes
+    document.querySelectorAll("#filepond-uploader").forEach(initFilepondUploader);
+
+    // Escuchar cuando se agreguen dinámicamente al DOM
+    const observer = new MutationObserver((mutations) => {
+        mutations.forEach((m) => {
+            m.addedNodes.forEach((node) => {
+                if (
+                    node.nodeType === 1 &&
+                    node.matches &&
+                    node.matches("#filepond-uploader")
+                ) {
+                    initFilepondUploader(node);
+                }
+            });
+        });
+    });
+
+    observer.observe(document.body, { childList: true, subtree: true });
+})();

data/app/assets/javascripts/attachwave/controllers/filepond_controller.js

@@ -0,0 +1,39 @@
+import { Controller } from "@hotwired/stimulus";
+import * as FilePond from "filepond";
+import FilePondPluginFileValidateType from "filepond-plugin-file-validate-type";
+import FilePondPluginFileValidateSize from "filepond-plugin-file-validate-size";
+
+export default class extends Controller {
+    static values = { model: String, id: String }
+
+    connect() {
+        FilePond.registerPlugin(FilePondPluginFileValidateType, FilePondPluginFileValidateSize);
+
+        const inputElement = document.createElement("input");
+        inputElement.type = "file";
+        inputElement.multiple = true;
+        inputElement.name = "file";
+        this.element.appendChild(inputElement);
+
+        FilePond.create(inputElement, {
+            allowMultiple: true,
+            server: {
+                process: {
+                    url: `/attachwave/attachments/direct_upload/${this.modelValue}/${this.idValue}`,
+                    method: "POST",
+                    headers: {
+                        "X-CSRF-Token": document.querySelector('meta[name="csrf-token"]').getAttribute("content")
+                    },
+                    onload: () => {
+                        fetch(`/attachwave/attachments/index/${this.modelValue}/${this.idValue}`)
+                            .then(resp => resp.text())
+                            .then(html => {
+                                const container = document.querySelector("#adjuntosTable");
+                                if (container) container.innerHTML = html;
+                            });
+                    }
+                }
+            }
+        });
+    }
+}

data/app/assets/javascripts/attachwave/controllers/index.js

@@ -0,0 +1,6 @@
+// engines/attachwave/app/assets/javascripts/attachwave/controllers/index.js
+import FilepondController from "./filepond_controller.js"
+
+export function registerAttachwaveControllers(app) {
+    app.register("attachwave--filepond", FilepondController)
+}

data/app/assets/javascripts/attachwave/filepond-plugin-file-validate-size.min.js

@@ -0,0 +1,9 @@
+/*!
+ * FilePondPluginFileValidateSize 2.2.8
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/* eslint-disable */
+
+!function(e,i){"object"==typeof exports&&"undefined"!=typeof module?module.exports=i():"function"==typeof define&&define.amd?define(i):(e=e||self).FilePondPluginFileValidateSize=i()}(this,function(){"use strict";var e=function(e){var i=e.addFilter,E=e.utils,l=E.Type,_=E.replaceInString,n=E.toNaturalFileSize;return i("ALLOW_HOPPER_ITEM",function(e,i){var E=i.query;if(!E("GET_ALLOW_FILE_SIZE_VALIDATION"))return!0;var l=E("GET_MAX_FILE_SIZE");if(null!==l&&e.size>l)return!1;var _=E("GET_MIN_FILE_SIZE");return!(null!==_&&e.size<_)}),i("LOAD_FILE",function(e,i){var E=i.query;return new Promise(function(i,l){if(!E("GET_ALLOW_FILE_SIZE_VALIDATION"))return i(e);var I=E("GET_FILE_VALIDATE_SIZE_FILTER");if(I&&!I(e))return i(e);var t=E("GET_MAX_FILE_SIZE");if(null!==t&&e.size>t)l({status:{main:E("GET_LABEL_MAX_FILE_SIZE_EXCEEDED"),sub:_(E("GET_LABEL_MAX_FILE_SIZE"),{filesize:n(t,".",E("GET_FILE_SIZE_BASE"),E("GET_FILE_SIZE_LABELS",E))})}});else{var L=E("GET_MIN_FILE_SIZE");if(null!==L&&e.size<L)l({status:{main:E("GET_LABEL_MIN_FILE_SIZE_EXCEEDED"),sub:_(E("GET_LABEL_MIN_FILE_SIZE"),{filesize:n(L,".",E("GET_FILE_SIZE_BASE"),E("GET_FILE_SIZE_LABELS",E))})}});else{var a=E("GET_MAX_TOTAL_FILE_SIZE");if(null!==a)if(E("GET_ACTIVE_ITEMS").reduce(function(e,i){return e+i.fileSize},0)>a)return void l({status:{main:E("GET_LABEL_MAX_TOTAL_FILE_SIZE_EXCEEDED"),sub:_(E("GET_LABEL_MAX_TOTAL_FILE_SIZE"),{filesize:n(a,".",E("GET_FILE_SIZE_BASE"),E("GET_FILE_SIZE_LABELS",E))})}});i(e)}}})}),{options:{allowFileSizeValidation:[!0,l.BOOLEAN],maxFileSize:[null,l.INT],minFileSize:[null,l.INT],maxTotalFileSize:[null,l.INT],fileValidateSizeFilter:[null,l.FUNCTION],labelMinFileSizeExceeded:["File is too small",l.STRING],labelMinFileSize:["Minimum file size is {filesize}",l.STRING],labelMaxFileSizeExceeded:["File is too large",l.STRING],labelMaxFileSize:["Maximum file size is {filesize}",l.STRING],labelMaxTotalFileSizeExceeded:["Maximum total size exceeded",l.STRING],labelMaxTotalFileSize:["Maximum total file size is {filesize}",l.STRING]}}};return"undefined"!=typeof window&&void 0!==window.document&&document.dispatchEvent(new CustomEvent("FilePond:pluginloaded",{detail:e})),e});

data/app/assets/javascripts/attachwave/filepond-plugin-file-validate-type.js

@@ -0,0 +1,231 @@
+/*!
+ * FilePondPluginFileValidateType 1.2.9
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/* eslint-disable */
+
+(function(global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined'
+        ? (module.exports = factory())
+        : typeof define === 'function' && define.amd
+        ? define(factory)
+        : ((global = global || self), (global.FilePondPluginFileValidateType = factory()));
+})(this, function() {
+    'use strict';
+
+    var plugin = function plugin(_ref) {
+        var addFilter = _ref.addFilter,
+            utils = _ref.utils;
+        // get quick reference to Type utils
+        var Type = utils.Type,
+            isString = utils.isString,
+            replaceInString = utils.replaceInString,
+            guesstimateMimeType = utils.guesstimateMimeType,
+            getExtensionFromFilename = utils.getExtensionFromFilename,
+            getFilenameFromURL = utils.getFilenameFromURL;
+
+        var mimeTypeMatchesWildCard = function mimeTypeMatchesWildCard(mimeType, wildcard) {
+            var mimeTypeGroup = (/^[^/]+/.exec(mimeType) || []).pop(); // image/png -> image
+            var wildcardGroup = wildcard.slice(0, -2); // image/* -> image
+            return mimeTypeGroup === wildcardGroup;
+        };
+
+        var isValidMimeType = function isValidMimeType(acceptedTypes, userInputType) {
+            return acceptedTypes.some(function(acceptedType) {
+                // accepted is wildcard mime type
+                if (/\*$/.test(acceptedType)) {
+                    return mimeTypeMatchesWildCard(userInputType, acceptedType);
+                }
+
+                // is normal mime type
+                return acceptedType === userInputType;
+            });
+        };
+
+        var getItemType = function getItemType(item) {
+            // if the item is a url we guess the mime type by the extension
+            var type = '';
+            if (isString(item)) {
+                var filename = getFilenameFromURL(item);
+                var extension = getExtensionFromFilename(filename);
+                if (extension) {
+                    type = guesstimateMimeType(extension);
+                }
+            } else {
+                type = item.type;
+            }
+
+            return type;
+        };
+
+        var validateFile = function validateFile(item, acceptedFileTypes, typeDetector) {
+            // no types defined, everything is allowed \o/
+            if (acceptedFileTypes.length === 0) {
+                return true;
+            }
+
+            // gets the item type
+            var type = getItemType(item);
+
+            // no type detector, test now
+            if (!typeDetector) {
+                return isValidMimeType(acceptedFileTypes, type);
+            }
+
+            // use type detector
+            return new Promise(function(resolve, reject) {
+                typeDetector(item, type)
+                    .then(function(detectedType) {
+                        if (isValidMimeType(acceptedFileTypes, detectedType)) {
+                            resolve();
+                        } else {
+                            reject();
+                        }
+                    })
+                    .catch(reject);
+            });
+        };
+
+        var applyMimeTypeMap = function applyMimeTypeMap(map) {
+            return function(acceptedFileType) {
+                return map[acceptedFileType] === null
+                    ? false
+                    : map[acceptedFileType] || acceptedFileType;
+            };
+        };
+
+        // setup attribute mapping for accept
+        addFilter('SET_ATTRIBUTE_TO_OPTION_MAP', function(map) {
+            return Object.assign(map, {
+                accept: 'acceptedFileTypes',
+            });
+        });
+
+        // filtering if an item is allowed in hopper
+        addFilter('ALLOW_HOPPER_ITEM', function(file, _ref2) {
+            var query = _ref2.query;
+            // if we are not doing file type validation exit
+            if (!query('GET_ALLOW_FILE_TYPE_VALIDATION')) {
+                return true;
+            }
+
+            // we validate the file against the accepted file types
+            return validateFile(file, query('GET_ACCEPTED_FILE_TYPES'));
+        });
+
+        // called for each file that is loaded
+        // right before it is set to the item state
+        // should return a promise
+        addFilter('LOAD_FILE', function(file, _ref3) {
+            var query = _ref3.query;
+            return new Promise(function(resolve, reject) {
+                if (!query('GET_ALLOW_FILE_TYPE_VALIDATION')) {
+                    resolve(file);
+                    return;
+                }
+
+                var acceptedFileTypes = query('GET_ACCEPTED_FILE_TYPES');
+
+                // custom type detector method
+                var typeDetector = query('GET_FILE_VALIDATE_TYPE_DETECT_TYPE');
+
+                // if invalid, exit here
+                var validationResult = validateFile(file, acceptedFileTypes, typeDetector);
+
+                var handleRejection = function handleRejection() {
+                    var acceptedFileTypesMapped = acceptedFileTypes
+                        .map(
+                            applyMimeTypeMap(
+                                query('GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES_MAP')
+                            )
+                        )
+                        .filter(function(label) {
+                            return label !== false;
+                        });
+
+                    var acceptedFileTypesMappedUnique = acceptedFileTypesMapped.filter(function(
+                        item,
+                        index
+                    ) {
+                        return acceptedFileTypesMapped.indexOf(item) === index;
+                    });
+
+                    reject({
+                        status: {
+                            main: query('GET_LABEL_FILE_TYPE_NOT_ALLOWED'),
+                            sub: replaceInString(
+                                query('GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES'),
+                                {
+                                    allTypes: acceptedFileTypesMappedUnique.join(', '),
+                                    allButLastType: acceptedFileTypesMappedUnique
+                                        .slice(0, -1)
+                                        .join(', '),
+                                    lastType:
+                                        acceptedFileTypesMappedUnique[
+                                            acceptedFileTypesMappedUnique.length - 1
+                                        ],
+                                }
+                            ),
+                        },
+                    });
+                };
+
+                // has returned new filename immidiately
+                if (typeof validationResult === 'boolean') {
+                    if (!validationResult) {
+                        return handleRejection();
+                    }
+                    return resolve(file);
+                }
+
+                // is promise
+                validationResult
+                    .then(function() {
+                        resolve(file);
+                    })
+                    .catch(handleRejection);
+            });
+        });
+
+        // expose plugin
+        return {
+            // default options
+            options: {
+                // Enable or disable file type validation
+                allowFileTypeValidation: [true, Type.BOOLEAN],
+
+                // What file types to accept
+                acceptedFileTypes: [[], Type.ARRAY],
+                // - must be comma separated
+                // - mime types: image/png, image/jpeg, image/gif
+                // - extensions: .png, .jpg, .jpeg ( not enabled yet )
+                // - wildcards: image/*
+
+                // label to show when a type is not allowed
+                labelFileTypeNotAllowed: ['File is of invalid type', Type.STRING],
+
+                // nicer label
+                fileValidateTypeLabelExpectedTypes: [
+                    'Expects {allButLastType} or {lastType}',
+                    Type.STRING,
+                ],
+
+                // map mime types to extensions
+                fileValidateTypeLabelExpectedTypesMap: [{}, Type.OBJECT],
+
+                // Custom function to detect type of file
+                fileValidateTypeDetectType: [null, Type.FUNCTION],
+            },
+        };
+    };
+
+    // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags
+    var isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    if (isBrowser) {
+        document.dispatchEvent(new CustomEvent('FilePond:pluginloaded', { detail: plugin }));
+    }
+
+    return plugin;
+});

data/app/assets/javascripts/attachwave/filepond-plugin-file-validate-type.min.js

@@ -0,0 +1,9 @@
+/*!
+ * FilePondPluginFileValidateType 1.2.9
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/* eslint-disable */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e=e||self).FilePondPluginFileValidateType=t()}(this,function(){"use strict";var e=function(e){var t=e.addFilter,n=e.utils,i=n.Type,T=n.isString,E=n.replaceInString,l=n.guesstimateMimeType,o=n.getExtensionFromFilename,r=n.getFilenameFromURL,u=function(e,t){return e.some(function(e){return/\*$/.test(e)?(n=e,(/^[^/]+/.exec(t)||[]).pop()===n.slice(0,-2)):e===t;var n})},a=function(e,t,n){if(0===t.length)return!0;var i=function(e){var t="";if(T(e)){var n=r(e),i=o(n);i&&(t=l(i))}else t=e.type;return t}(e);return n?new Promise(function(T,E){n(e,i).then(function(e){u(t,e)?T():E()}).catch(E)}):u(t,i)};return t("SET_ATTRIBUTE_TO_OPTION_MAP",function(e){return Object.assign(e,{accept:"acceptedFileTypes"})}),t("ALLOW_HOPPER_ITEM",function(e,t){var n=t.query;return!n("GET_ALLOW_FILE_TYPE_VALIDATION")||a(e,n("GET_ACCEPTED_FILE_TYPES"))}),t("LOAD_FILE",function(e,t){var n=t.query;return new Promise(function(t,i){if(n("GET_ALLOW_FILE_TYPE_VALIDATION")){var T=n("GET_ACCEPTED_FILE_TYPES"),l=n("GET_FILE_VALIDATE_TYPE_DETECT_TYPE"),o=a(e,T,l),r=function(){var e,t=T.map((e=n("GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES_MAP"),function(t){return null!==e[t]&&(e[t]||t)})).filter(function(e){return!1!==e}),l=t.filter(function(e,n){return t.indexOf(e)===n});i({status:{main:n("GET_LABEL_FILE_TYPE_NOT_ALLOWED"),sub:E(n("GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES"),{allTypes:l.join(", "),allButLastType:l.slice(0,-1).join(", "),lastType:l[l.length-1]})}})};if("boolean"==typeof o)return o?t(e):r();o.then(function(){t(e)}).catch(r)}else t(e)})}),{options:{allowFileTypeValidation:[!0,i.BOOLEAN],acceptedFileTypes:[[],i.ARRAY],labelFileTypeNotAllowed:["File is of invalid type",i.STRING],fileValidateTypeLabelExpectedTypes:["Expects {allButLastType} or {lastType}",i.STRING],fileValidateTypeLabelExpectedTypesMap:[{},i.OBJECT],fileValidateTypeDetectType:[null,i.FUNCTION]}}};return"undefined"!=typeof window&&void 0!==window.document&&document.dispatchEvent(new CustomEvent("FilePond:pluginloaded",{detail:e})),e});