cas-cms 0.1.0

data/app/assets/javascripts/cas/plugins/cas_image_gallery.js

@@ -0,0 +1,353 @@
+/**
+ * Guess what, Javascript doesn't have .sort() by integer out-of-the-box.
+ */
+function sortNumber(a, b) {
+  return parseInt(a) - parseInt(b);
+}
+
+function CasImage(element, gallery) {
+  var image = this;
+  image.element = element;
+  image.gallery = gallery;
+
+  image.id = image.element.attr("data-id");
+
+  image.isSelected = function() {
+    return image.element.attr("data-selected") == "true";
+  };
+
+  image.markAsSelected = function() {
+    image.element.attr("data-selected", "true");
+  };
+
+  image.unselect = function() {
+    image.element.find(".selection").hide();
+    image.element.attr("data-selected", "false");
+    image.element.find(".unselected-but-selectable").show();
+  };
+
+  image.toggleSelection = function() {
+    if (image.isSelected()) {
+      image.unselect();
+    } else {
+      image.markAsSelected();
+      image.element.find(".unselected-but-selectable").hide();
+      image.element.find(".selection").show();
+    }
+  };
+
+  image.showEditOptions = function() {
+    gallery.element.find(".image .image-options").hide();
+    image.element.find(".image .image-options").show();
+    image.markAsSelected();
+  };
+
+  return {
+    click: function() {
+      if (image.gallery.isSelectionEnabled) {
+        image.toggleSelection();
+      } else {
+        image.showEditOptions();
+      }
+    },
+    unselect: function() {
+      if (image.isSelected()) {
+        image.unselect();
+      }
+    },
+    recordId: function() {
+      return image.element.data("id");
+    },
+    addOrderedInput: function(order) {
+      if (!image.element.find("input.js-image-input").length) {
+        image.element.append("<input type='hidden' name='images[files]["+order+"][id]' class='js-image-input' value='"+image.id+"' />");
+      }
+    }
+  }
+}
+
+function CasImageGallery(options) {
+  var gallery = this;
+  gallery.element = options.element;
+
+  gallery.isSelectionEnabled = options.selectionEnabled || false;
+  gallery.preloadedImagesSelector = options.preloadedImagesElements || gallery.element.find(".cas-gallery-preloaded");
+
+  gallery.allItems = function() {
+    return gallery.element.find(".image-container");
+  };
+
+  gallery.unselectAll = function() {
+    gallery.allItems().each(function(index) {
+      var image = new CasImage($(this), gallery);
+      image.unselect();
+    });
+  };
+
+  gallery.getSelectedItems = function() {
+    var result = [];
+    return gallery.element.find(".image-container[data-selected=true]").map(function(index, value) {
+      return $(value)
+    });
+  };
+
+  gallery.toggleSelection = function() {
+    gallery.isSelectionEnabled = !gallery.isSelectionEnabled;
+
+    if (!gallery.isSelectionEnabled) {
+      gallery.unselectAll();
+    } else {
+      gallery.unselectAll();
+      gallery.element.find(".unselected-but-selectable").show();
+    }
+
+    gallery.updateUi();
+  };
+
+  gallery.markAsCover = function(id) {
+    gallery.element.find(".image-container").attr("data-is-cover", "false");
+    gallery.element.find(".image-container[data-id="+id+"]").attr("data-is-cover", "true");
+    gallery.element.find("input.js-image-cover-input").remove();
+    gallery.element.append("<input type='hidden' name='images[cover_id]' class='js-image-cover-input' value='"+id+"' />");
+  };
+
+  gallery.deleteImages = function() {
+    var ids = [];
+    gallery.getSelectedItems().each(function(index, imageElement) {
+      var image = new CasImage(imageElement, gallery);
+      ids.push( String(image.recordId()) );
+    });
+    var response = options.onDelete(ids);
+
+    if (response) {
+      response.done(function() {
+        var imageSelectors = [];
+        $.each(ids, function(index, value) {
+          imageSelectors.push(".image-container[data-id="+value+"]");
+        });
+        gallery.element.find(imageSelectors.join(", ")).remove();
+        gallery.unselectAll();
+        if (gallery.isSelectionEnabled) {
+          gallery.toggleSelection();
+        }
+      }).fail(function() {
+        alert("Error!");
+      });
+    }
+  };
+
+  gallery.imageClicked = function(element) {
+    if (!gallery.isSelectionEnabled) {
+      gallery.unselectAll();
+    }
+
+    var image = new CasImage($(element), gallery);
+    image.click();
+    gallery.updateUi();
+  };
+
+  gallery.setupEvents = function() {
+    options.element.on("click", ".image-container", function() {
+      gallery.imageClicked($(this));
+    });
+
+    options.element.on("click", ".js-toggle-selection", function() {
+      gallery.toggleSelection();
+    });
+
+    options.element.on("click", ".js-delete-image", function() {
+      gallery.deleteImages();
+    });
+
+    options.element.on("click", ".js-mark-as-cover", function() {
+      var id = $(this).parents(".image-container").data("id");
+      gallery.markAsCover(id);
+    });
+
+    /*
+     * There's a bug with dragleave when over child elements, flickering. This
+     * fixes it.
+     */
+    var dropzoneLastEnter;
+    $(document)
+      .on('dragover dragenter', ".dropzone", function(e) {
+        dropzoneLastEnter = event.target;
+        e.preventDefault();
+
+        var dataTransfer = e.originalEvent.dataTransfer;
+        if (dataTransfer.types && (dataTransfer.types.indexOf ? dataTransfer.types.indexOf('Files') != -1 : dataTransfer.types.contains('Files'))) {
+          $(this).addClass('in');
+        }
+      })
+      .on('dragleave drop', ".dropzone", function(e) {
+        if (dropzoneLastEnter === event.target) {
+          $(this).removeClass('in');
+        }
+      });
+  };
+
+  gallery.preloadImages = function() {
+    var images = gallery.preloadedImagesSelector;
+
+    $.each(images, function(index, value) {
+      var image = $(value);
+      var url = image.data("src");
+      var id = image.data("id");
+      var filename = image.data("filename");
+      var originalOrder = image.data("original-order");
+      var isCover = image.data("is-cover");
+      gallery.addImage({
+        url: url,
+        id: id,
+        filename: filename,
+        orderBy: "order",
+        originalOrder: originalOrder,
+        isCover: isCover
+      });
+    });
+  };
+
+  gallery.imageTemplate = $("#cas-gallery-image-template").html();
+  gallery.addImage = function(options) {
+    var url = options.url,
+        id = options.id,
+        filename = options.filename,
+        orderBy = options.orderBy,
+        // order that comes from the server
+        originalOrder = options.originalOrder,
+        isCover = options.isCover;
+
+    /**
+     * The new image information/HTML code
+     */
+    var finalHtml = $(gallery.imageTemplate);
+    finalHtml.attr("data-id", id);
+    finalHtml.attr("data-filename", filename);
+    finalHtml.attr("data-original-order", originalOrder);
+    finalHtml.find(".image").css("backgroundImage", "url('"+url+"')");
+
+    /**
+     * We need to add images in order by filename. The sorting algorithm
+     * compares current image with the new image, and when the new image is
+     * going to be the last one, the algorithm in the loop below doesn't
+     * add it to the list of images.
+     *
+     * So we create `addedImage` to false. In case it's still false after the
+     * loop, we append the file to the end of the list.
+     */
+    var addedImage = false;
+    gallery.allItems().each(function(index) {
+      if (addedImage === true) {
+        return false;
+      }
+      var ordering;
+
+      if (orderBy == "filename") {
+        var listedItemFilename = $(this).data("filename");
+        ordering = [listedItemFilename, filename].sort();
+
+        /**
+         * We compare the crrent file name and new file name. We sort them
+         * both.
+         *
+         * Say current images are 3.jpg and 6.jpg and new image is 5.jpg.
+         * We compare ["3.jpg", "5.jpg"].sort() and see that element zero is not
+         * 5.jpg. We discard it.
+         *
+         * Then ["6.jpg", "5.jpg"].sort() and "5.jpg" is the first element,
+         * therefore we surpassed the position 5.jpg should be in. At this
+         * point we take 5.jpg and `insertBefore()` 6.jpg.
+         */
+        if (ordering[0] === filename) {
+          finalHtml.insertBefore($(this));
+          addedImage = true;
+          return;
+        }
+      } else if (orderBy == "order") {
+        var listedItemOrder = $(this).data("original-order");
+        ordering = [listedItemOrder, originalOrder].sort(sortNumber);
+
+        /**
+         * We compare the crrent file name and new file name. We sort them
+         * both.
+         *
+         * Say current images are 3.jpg and 6.jpg and new image is 5.jpg.
+         * We compare ["3.jpg", "5.jpg"].sort() and see that element zero is not
+         * 5.jpg. We discard it.
+         *
+         * Then ["6.jpg", "5.jpg"].sort() and "5.jpg" is the first element,
+         * therefore we surpassed the position 5.jpg should be in. At this
+         * point we take 5.jpg and `insertBefore()` 6.jpg.
+         */
+        if (ordering[0] === originalOrder) {
+          finalHtml.insertBefore($(this));
+          addedImage = true;
+          return;
+        }
+      }
+    });
+
+    if (addedImage === false) {
+      gallery.element.find(".images").append(finalHtml);
+    }
+
+    gallery.refreshImagesFormInputs();
+    gallery.unselectAll();
+
+    if (isCover) {
+      gallery.markAsCover(id);
+    }
+
+    gallery.updateUi();
+  };
+
+  gallery.refreshImagesFormInputs = function() {
+    $(".js-image-input").remove();
+    gallery.allItems().each(function(index) {
+      var image = new CasImage($(this), gallery);
+      image.addOrderedInput(index);
+    });
+  };
+
+  gallery.updateUi = function() {
+    if (gallery.isSelectionEnabled) {
+      gallery.element.find(".when-selection-enabled").show();
+      gallery.element.find(".when-selection-disabled").hide();
+      gallery.element.find(".image .image-options").hide();
+    } else {
+      gallery.element.find(".unselected-but-selectable").hide();
+      gallery.element.find(".when-selection-enabled").hide();
+      gallery.element.find(".when-selection-disabled").show();
+    }
+  };
+
+  return {
+    init: function() {
+      gallery.preloadImages();
+      gallery.setupEvents();
+      gallery.updateUi();
+    },
+
+    addImage: function(options) {
+      gallery.addImage({
+        url: options.url,
+        id: options.id,
+        filename: options.filename,
+        orderBy: options.orderBy,
+        isCover: options.isCover
+      });
+    },
+
+    resetImagesOrder: function() {
+      gallery.element.find("input.js-image-input").remove();
+      gallery.refreshImagesFormInputs();
+    },
+
+    attachable: function() {
+      return {
+        type: gallery.element.data("attachable-type"),
+        id:   gallery.element.data("attachable-id")
+      };
+    }
+  }
+}

data/app/assets/javascripts/cas/vendor/file_upload/canvas-to-blob.min.js

@@ -0,0 +1,2 @@
+!function(t){"use strict";var e=t.HTMLCanvasElement&&t.HTMLCanvasElement.prototype,o=t.Blob&&function(){try{return Boolean(new Blob)}catch(t){return!1}}(),n=o&&t.Uint8Array&&function(){try{return 100===new Blob([new Uint8Array(100)]).size}catch(t){return!1}}(),r=t.BlobBuilder||t.WebKitBlobBuilder||t.MozBlobBuilder||t.MSBlobBuilder,a=/^data:((.*?)(;charset=.*?)?)(;base64)?,/,i=(o||r)&&t.atob&&t.ArrayBuffer&&t.Uint8Array&&function(t){var e,i,l,u,b,c,d,B,f;if(e=t.match(a),!e)throw new Error("invalid data URI");for(i=e[2]?e[1]:"text/plain"+(e[3]||";charset=US-ASCII"),l=!!e[4],u=t.slice(e[0].length),b=l?atob(u):decodeURIComponent(u),c=new ArrayBuffer(b.length),d=new Uint8Array(c),B=0;B<b.length;B+=1)d[B]=b.charCodeAt(B);return o?new Blob([n?d:c],{type:i}):(f=new r,f.append(c),f.getBlob(i))};t.HTMLCanvasElement&&!e.toBlob&&(e.mozGetAsFile?e.toBlob=function(t,o,n){t(n&&e.toDataURL&&i?i(this.toDataURL(o,n)):this.mozGetAsFile("blob",o))}:e.toDataURL&&i&&(e.toBlob=function(t,e,o){t(i(this.toDataURL(e,o)))})),"function"==typeof define&&define.amd?define(function(){return i}):"object"==typeof module&&module.exports?module.exports=i:t.dataURLtoBlob=i}(window);
+//# sourceMappingURL=canvas-to-blob.min.js.map

data/app/assets/javascripts/cas/vendor/file_upload/jquery.fileupload-image.js

@@ -0,0 +1,326 @@
+/*
+ * jQuery File Upload Image Preview & Resize Plugin
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* jshint nomen:false */
+/* global define, require, window, Blob */
+
+;(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            'jquery',
+            'load-image',
+            'load-image-meta',
+            'load-image-scale',
+            'load-image-exif',
+            'canvas-to-blob',
+            './jquery.fileupload-process'
+        ], factory);
+    } else if (typeof exports === 'object') {
+        // Node/CommonJS:
+        factory(
+            require('jquery'),
+            require('blueimp-load-image/js/load-image'),
+            require('blueimp-load-image/js/load-image-meta'),
+            require('blueimp-load-image/js/load-image-scale'),
+            require('blueimp-load-image/js/load-image-exif'),
+            require('blueimp-canvas-to-blob'),
+            require('./jquery.fileupload-process')
+        );
+    } else {
+        // Browser globals:
+        factory(
+            window.jQuery,
+            window.loadImage
+        );
+    }
+}(function ($, loadImage) {
+    'use strict';
+
+    // Prepend to the default processQueue:
+    $.blueimp.fileupload.prototype.options.processQueue.unshift(
+        {
+            action: 'loadImageMetaData',
+            disableImageHead: '@',
+            disableExif: '@',
+            disableExifThumbnail: '@',
+            disableExifSub: '@',
+            disableExifGps: '@',
+            disabled: '@disableImageMetaDataLoad'
+        },
+        {
+            action: 'loadImage',
+            // Use the action as prefix for the "@" options:
+            prefix: true,
+            fileTypes: '@',
+            maxFileSize: '@',
+            noRevoke: '@',
+            disabled: '@disableImageLoad'
+        },
+        {
+            action: 'resizeImage',
+            // Use "image" as prefix for the "@" options:
+            prefix: 'image',
+            maxWidth: '@',
+            maxHeight: '@',
+            minWidth: '@',
+            minHeight: '@',
+            crop: '@',
+            orientation: '@',
+            forceResize: '@',
+            disabled: '@disableImageResize'
+        },
+        {
+            action: 'saveImage',
+            quality: '@imageQuality',
+            type: '@imageType',
+            disabled: '@disableImageResize'
+        },
+        {
+            action: 'saveImageMetaData',
+            disabled: '@disableImageMetaDataSave'
+        },
+        {
+            action: 'resizeImage',
+            // Use "preview" as prefix for the "@" options:
+            prefix: 'preview',
+            maxWidth: '@',
+            maxHeight: '@',
+            minWidth: '@',
+            minHeight: '@',
+            crop: '@',
+            orientation: '@',
+            thumbnail: '@',
+            canvas: '@',
+            disabled: '@disableImagePreview'
+        },
+        {
+            action: 'setImage',
+            name: '@imagePreviewName',
+            disabled: '@disableImagePreview'
+        },
+        {
+            action: 'deleteImageReferences',
+            disabled: '@disableImageReferencesDeletion'
+        }
+    );
+
+    // The File Upload Resize plugin extends the fileupload widget
+    // with image resize functionality:
+    $.widget('blueimp.fileupload', $.blueimp.fileupload, {
+
+        options: {
+            // The regular expression for the types of images to load:
+            // matched against the file type:
+            loadImageFileTypes: /^image\/(gif|jpeg|png|svg\+xml)$/,
+            // The maximum file size of images to load:
+            loadImageMaxFileSize: 10000000, // 10MB
+            // The maximum width of resized images:
+            imageMaxWidth: 1920,
+            // The maximum height of resized images:
+            imageMaxHeight: 1080,
+            // Defines the image orientation (1-8) or takes the orientation
+            // value from Exif data if set to true:
+            imageOrientation: false,
+            // Define if resized images should be cropped or only scaled:
+            imageCrop: false,
+            // Disable the resize image functionality by default:
+            disableImageResize: true,
+            // The maximum width of the preview images:
+            previewMaxWidth: 80,
+            // The maximum height of the preview images:
+            previewMaxHeight: 80,
+            // Defines the preview orientation (1-8) or takes the orientation
+            // value from Exif data if set to true:
+            previewOrientation: true,
+            // Create the preview using the Exif data thumbnail:
+            previewThumbnail: true,
+            // Define if preview images should be cropped or only scaled:
+            previewCrop: false,
+            // Define if preview images should be resized as canvas elements:
+            previewCanvas: true
+        },
+
+        processActions: {
+
+            // Loads the image given via data.files and data.index
+            // as img element, if the browser supports the File API.
+            // Accepts the options fileTypes (regular expression)
+            // and maxFileSize (integer) to limit the files to load:
+            loadImage: function (data, options) {
+                if (options.disabled) {
+                    return data;
+                }
+                var that = this,
+                    file = data.files[data.index],
+                    dfd = $.Deferred();
+                if (($.type(options.maxFileSize) === 'number' &&
+                            file.size > options.maxFileSize) ||
+                        (options.fileTypes &&
+                            !options.fileTypes.test(file.type)) ||
+                        !loadImage(
+                            file,
+                            function (img) {
+                                if (img.src) {
+                                    data.img = img;
+                                }
+                                dfd.resolveWith(that, [data]);
+                            },
+                            options
+                        )) {
+                    return data;
+                }
+                return dfd.promise();
+            },
+
+            // Resizes the image given as data.canvas or data.img
+            // and updates data.canvas or data.img with the resized image.
+            // Also stores the resized image as preview property.
+            // Accepts the options maxWidth, maxHeight, minWidth,
+            // minHeight, canvas and crop:
+            resizeImage: function (data, options) {
+                if (options.disabled || !(data.canvas || data.img)) {
+                    return data;
+                }
+                options = $.extend({canvas: true}, options);
+                var that = this,
+                    dfd = $.Deferred(),
+                    img = (options.canvas && data.canvas) || data.img,
+                    resolve = function (newImg) {
+                        if (newImg && (newImg.width !== img.width ||
+                                newImg.height !== img.height ||
+                                options.forceResize)) {
+                            data[newImg.getContext ? 'canvas' : 'img'] = newImg;
+                        }
+                        data.preview = newImg;
+                        dfd.resolveWith(that, [data]);
+                    },
+                    thumbnail;
+                if (data.exif) {
+                    if (options.orientation === true) {
+                        options.orientation = data.exif.get('Orientation');
+                    }
+                    if (options.thumbnail) {
+                        thumbnail = data.exif.get('Thumbnail');
+                        if (thumbnail) {
+                            loadImage(thumbnail, resolve, options);
+                            return dfd.promise();
+                        }
+                    }
+                    // Prevent orienting the same image twice:
+                    if (data.orientation) {
+                        delete options.orientation;
+                    } else {
+                        data.orientation = options.orientation;
+                    }
+                }
+                if (img) {
+                    resolve(loadImage.scale(img, options));
+                    return dfd.promise();
+                }
+                return data;
+            },
+
+            // Saves the processed image given as data.canvas
+            // inplace at data.index of data.files:
+            saveImage: function (data, options) {
+                if (!data.canvas || options.disabled) {
+                    return data;
+                }
+                var that = this,
+                    file = data.files[data.index],
+                    dfd = $.Deferred();
+                if (data.canvas.toBlob) {
+                    data.canvas.toBlob(
+                        function (blob) {
+                            if (!blob.name) {
+                                if (file.type === blob.type) {
+                                    blob.name = file.name;
+                                } else if (file.name) {
+                                    blob.name = file.name.replace(
+                                        /\.\w+$/,
+                                        '.' + blob.type.substr(6)
+                                    );
+                                }
+                            }
+                            // Don't restore invalid meta data:
+                            if (file.type !== blob.type) {
+                                delete data.imageHead;
+                            }
+                            // Store the created blob at the position
+                            // of the original file in the files list:
+                            data.files[data.index] = blob;
+                            dfd.resolveWith(that, [data]);
+                        },
+                        options.type || file.type,
+                        options.quality
+                    );
+                } else {
+                    return data;
+                }
+                return dfd.promise();
+            },
+
+            loadImageMetaData: function (data, options) {
+                if (options.disabled) {
+                    return data;
+                }
+                var that = this,
+                    dfd = $.Deferred();
+                loadImage.parseMetaData(data.files[data.index], function (result) {
+                    $.extend(data, result);
+                    dfd.resolveWith(that, [data]);
+                }, options);
+                return dfd.promise();
+            },
+
+            saveImageMetaData: function (data, options) {
+                if (!(data.imageHead && data.canvas &&
+                        data.canvas.toBlob && !options.disabled)) {
+                    return data;
+                }
+                var file = data.files[data.index],
+                    blob = new Blob([
+                        data.imageHead,
+                        // Resized images always have a head size of 20 bytes,
+                        // including the JPEG marker and a minimal JFIF header:
+                        this._blobSlice.call(file, 20)
+                    ], {type: file.type});
+                blob.name = file.name;
+                data.files[data.index] = blob;
+                return data;
+            },
+
+            // Sets the resized version of the image as a property of the
+            // file object, must be called after "saveImage":
+            setImage: function (data, options) {
+                if (data.preview && !options.disabled) {
+                    data.files[data.index][options.name || 'preview'] = data.preview;
+                }
+                return data;
+            },
+
+            deleteImageReferences: function (data, options) {
+                if (!options.disabled) {
+                    delete data.img;
+                    delete data.canvas;
+                    delete data.preview;
+                    delete data.imageHead;
+                }
+                return data;
+            }
+
+        }
+
+    });
+
+}));