alchemy-custom-model 0.1.0

data/lib/alchemy/custom/model/el_finder/volumes/alchemy_files.rb

@@ -0,0 +1,51 @@
+module Alchemy::Custom::Model::ElFinder
+  module Volumes
+    class AlchemyFiles < AlchemyFile
+
+      def initialize(options = {root: '/files', name: 'Alchemy Library - Files', id: 'alchemy_library_files', url: '/'})
+        super
+      end
+
+      def files(target = '.')
+        super(root_path)
+      end
+
+      def decode(hash)
+        super do |path|
+          Paths::File.new(@root, path, volume: self)
+        end
+      end
+
+      def upload(target, upload)
+        super do |file|
+          f = ::Alchemy::Attachment.create(
+              file: file
+          )
+          root_path.build_file_path(f)
+        end
+      end
+
+      def search(type:, q:)
+
+        super do
+          search_query_build(klass: ::Alchemy::Attachment, type: type, q: q, mime_attribute: :file_mime_type)
+        end
+
+      end
+
+      def disabled_commands
+
+        super + ['rm']
+
+      end
+
+      private
+
+      def root_path
+        Paths::Files.new(@root, '.', volume: self)
+      end
+
+    end
+  end
+end
+

data/lib/alchemy/custom/model/el_finder/volumes/alchemy_images.rb

@@ -0,0 +1,69 @@
+module Alchemy::Custom::Model::ElFinder
+  module Volumes
+    class AlchemyImages < AlchemyFile
+
+      def initialize(options = {root: '/images', name: acm_t("volume",scope:'elfinder.alchemy_images'), id: 'alchemy_library_images', url: '/'})
+        super
+      end
+
+      def files(target = '.')
+        super(root_path)
+      end
+
+      def decode(hash)
+        super do |path|
+          Paths::Image.new(@root, path, volume: self)
+        end
+      end
+
+      def upload(target, upload)
+        super do |file|
+          img = ::Alchemy::Picture.new(
+              image_file: file
+          )
+          img.name = img.humanized_name
+          img.save!
+          root_path.build_file_path(img)
+        end
+      end
+
+      def search(type:, q:)
+
+        super do
+          search_query_build(klass: ::Alchemy::Picture, type: type, q: q, mime_attribute: :file_mime_type)
+        end
+
+      end
+
+      def disabled_commands
+
+        super + ['rm']
+
+      end
+
+      def duplicate(t)
+
+        new_path = Rails.root.join('tmp', "copy_#{File.basename(t.name)}")
+
+        ::FileUtils.cp(t.file.path, new_path)
+
+        img = ::Alchemy::Picture.new(
+            image_file: new_path
+        )
+        img.name = img.humanized_name
+        img.save
+        root_path.build_file_path(img)
+      end
+
+      def duplicable?(target)
+        true
+      end
+
+
+      def root_path
+        Paths::Images.new(@root, '.', volume: self)
+      end
+
+    end
+  end
+end

data/lib/alchemy/custom/model/el_finder/volumes/base.rb

@@ -0,0 +1,149 @@
+module Alchemy::Custom::Model
+  module ElFinder
+    module Volumes
+      class Base
+
+        include TranslationScope
+
+        attr_reader :id, :name, :root, :url
+
+        def initialize(options)
+          [:id, :name, :root, :url].each do |opt|
+            raise(ArgumentError, "Missing required #{opt} option") unless options.key?(opt)
+          end
+
+          @id = options[:id]
+          @name = options[:name]
+          @root = options[:root]
+          @url = options[:url]
+
+          # @options = {
+          #   upload_file_mode: 0644,
+          #   original_filename_method: lambda {|file| file.original_filename.respond_to?(:force_encoding) ? file.original_filename.force_encoding('utf-8') : file.original_filename}
+          # }
+        end
+
+        def contains?(hash)
+          hash.start_with?("#{@id}_")
+        end
+
+        def cwd(target = '.')
+#       {
+#     "name"   : "Images",             // (String) name of file/dir. Required
+#     "hash"   : "l0_SW1hZ2Vz",        // (String) hash of current file/dir path, first symbol must be letter, symbols before _underline_ - volume id, Required.
+#     "phash"  : "l0_Lw",              // (String) hash of parent directory. Required except roots dirs.
+#     "mime"   : "directory",          // (String) mime type. Required.
+#     "ts"     : 1334163643,           // (Number) file modification time in unix timestamp. Required.
+#     "date"   : "30 Jan 2010 14:25",  // (String) last modification time (mime). Depricated but yet supported. Use ts instead.
+#     "size"   : 12345,                // (Number) file size in bytes
+#     "dirs"   : 1,                    // (Number) Only for directories. Marks if directory has child directories inside it. 0 (or not set) - no, 1 - yes. Do not need to calculate amount.
+#     "read"   : 1,                    // (Number) is readable
+#     "write"  : 1,                    // (Number) is writable
+#     "locked" : 0,                    // (Number) is file locked. If locked that object cannot be deleted and renamed
+#     "tmb"    : 'bac0d45b625f8d4633435ffbd52ca495.png' // (String) Only for images. Thumbnail file name, if file do not have thumbnail yet, but it can be generated than it must have value "1"
+#     "alias"  : "files/images",       // (String) For symlinks only. Symlink target path.
+#     "thash"  : "l1_c2NhbnMy",        // (String) For symlinks only. Symlink target hash.
+#     "dim"    : "640x480"             // (String) For images - file dimensions. Optionally.
+#     "volumeid" : "l1_"               // (String) Volume id. For root dir only.
+# }
+# {
+#   name: @name,
+#   hash: encode('.'),
+#   mime: 'directory',
+#   ts: File.mtime(@root).to_i,
+#   size: 0,
+#   dirs: 0,
+#   read: 1,
+#   write: 1,
+#   locked: 0,
+#   volumeid: "#{@id}_"
+# }
+          path_info(PathName.new(@root, target))
+        end
+
+        # def path_info(target)
+        #   is_dir = File.directory?(target.realpath)
+        #   mime = is_dir ? 'directory' : ElFinder::MimeType.for(target.realpath)
+        #   name = @name if target.is_root?
+        #   name ||= target.basename.to_s
+        #
+        #   dirs = 0
+        #   if is_dir
+        #     # check if has sub directories
+        #     dirs = 1 if Dir[File.join(target.realpath, '*/')].count > 0
+        #   end
+        #
+        #   size = 0
+        #   unless is_dir
+        #     size = File.size(target.realpath)
+        #   end
+        #
+        #   result = {
+        #     name: name,
+        #     hash: encode(target.path.to_s),
+        #     mime: mime,
+        #     ts: File.mtime(target.realpath).to_i,
+        #     size: size,
+        #     dirs: dirs,
+        #     read: 1,
+        #     write: 1,
+        #     locked: 0
+        #   }
+        #   if target.is_root?
+        #     result[:volumeid] = "#{@id}_"
+        #   else
+        #     result[:phash] = encode(target.dirname.path.to_s)
+        #   end
+        #
+        #   result
+        # end
+
+
+        def decode(hash)
+          hash = hash.slice(("#{@id}_".length)..-1) if hash.start_with?("#{@id}_")
+          hash = hash.tr('-_.', '+/=')
+          # restore missing '='
+          len = hash.length % 4
+          hash += '==' if len == 1 or len == 2
+          hash += '=' if len == 3
+          path = Base64.strict_decode64(hash)
+
+          if block_given?
+            yield path
+          else
+            PathName.new(@root, path)
+          end
+
+        end
+
+        def encode(path)
+          # creates hash for the path
+          # path = ElFinder::Pathname.new(@root, path).path.to_s
+          hash = Base64.strict_encode64(path)
+          hash.tr!('+/=', '-_.')
+          hash.gsub!(/\.+\Z/, '')
+          "#{@id}_#{hash}"
+        end
+
+        # def files(target = '.')
+        #   target = ElFinder::Pathname.new(@root, target)
+        #   files = []
+        #   # files = target.children.map {|p| path_info(p)}
+        #   files << cwd(target)
+        #   files
+        # end
+
+        def pathname(target)
+          raise "Absolute Path for file"
+        end
+
+        ##
+        # Elenco comandi disabilitati
+        def disabled_commands
+          []
+        end
+
+      end
+    end
+  end
+end

data/lib/alchemy/custom/model/el_finder/volumes/component_attribute.rb

@@ -0,0 +1,130 @@
+module Alchemy::Custom::Model::ElFinder
+  module Volumes
+    class ComponentAttribute < AlchemyFile
+
+      attr_accessor :record, :attribute, :file_link_ref, :tags
+
+      ##
+      # Elenco opzioni da utilizzare per la configurazione
+      #  - attribute      = relazione dell'oggetto a cui si riferisce il collegamento del volume (la join table per esempio)
+      #  - object         = oggetto identificato con un global_id signed
+      #  - file_link_ref  = rispetto ad un'istanza della relazione come fare a trovare il valore del record alchemy(Picture o Attachment),
+      #                     nel caso avessimo più metodi da chiamare possiamo spezzarlo con il . fra un metodo e l'altro
+      #                     il programma dovrà spezzare per il . e usare dig per chiamare i valori definitivi
+      #  - tags           = Array di stringhe per i tag da associare direttamente ai files caricati
+      def initialize(opts = {})
+
+        self.record = GlobalID::Locator.locate_signed opts.delete(:object)
+        self.attribute = opts.delete(:attribute)
+        self.file_link_ref = opts.delete(:file_link_ref)
+        self.tags = opts.delete(:tags) {[]}
+
+        identificativo_volume = "component_#{self.attribute}" #"_#{record.id}"
+
+        # identificativo_volume='test_semplice_nome'
+
+        # unless self.record.send(self.attribute).klass.new.respond_to?(:alchemy_file_instance)
+        #   raise "Attenzione, non è stata impostata la relazione per collegare la join table con l'elemento il record di alchemy [:alchemy_file_instance]"
+        # end
+
+        super({root: "/#{identificativo_volume}", name: 'Elementi associati', id: "#{identificativo_volume}", url: '/'})
+      end
+
+      def files(target = '.')
+        super(root_path)
+      end
+
+      def root_path
+        Paths::ComponentFiles.new(@root, '.', volume: self)
+      end
+
+      def copy(src)
+        new_rec = associate_record_to_active_instance(src.active_record_instance)
+        root_path.build_file_path(new_rec)
+      end
+
+      def decode(hash)
+        super do |path|
+          Paths::ComponentFile.new(@root, path, volume: self)
+        end
+      end
+
+      def upload(target, upload)
+        super do |file|
+
+          if remote_alchemy_relation == ::Alchemy::Picture
+            img = ::Alchemy::Picture.new(
+                image_file: file
+            )
+            img.name = img.humanized_name
+            img.save
+
+            #lego l'immagine ora al prodotto
+            new_rec = associate_record_to_active_instance(img)
+
+            root_path.build_file_path(new_rec)
+          else
+            raise "TO override"
+          end
+        end
+      end
+
+
+      ##
+      # Indica l'oggetto finale a cui viene legata la join table del componente
+      def remote_alchemy_relation
+        attribute_class.reflect_on_association(:alchemy_file_instance).klass
+      end
+
+      def attribute_class
+        self.record.send(self.attribute).klass
+      end
+
+      def search(type:, q:)
+
+        query_search = search_query_build(klass: remote_alchemy_relation, type: type, q: q, mime_attribute: :image_file_format)
+
+        self.record.send(self.attribute).joins(:alchemy_file_instance).merge(query_search).uniq.collect do |p|
+          path_info(root_path.build_file_path(p))
+        end
+
+      end
+
+
+      def duplicate(t)
+        new_path = Rails.root.join('tmp', "copy_#{File.basename(t.name)}")
+
+        ::FileUtils.cp(t.file.path, new_path)
+
+        img = ::Alchemy::Picture.new(
+            image_file: new_path
+        )
+        img.name = img.humanized_name
+        img.save
+
+        new_rec = associate_record_to_active_instance(img)
+        root_path.build_file_path(new_rec)
+      end
+
+
+      def duplicable?(target)
+        remote_alchemy_relation == ::Alchemy::Picture
+      end
+
+      ##
+      # Nel caso del componente, rm vuol dire dissociare il target elementi
+      def rm(target)
+        target.active_record_instance.destroy
+      end
+
+      private
+
+      def associate_record_to_active_instance(rec)
+        self.record.class.transaction do
+          rec.update_attributes(tag_list: (self.tags + rec.tag_list).flatten.compact)
+          self.record.send(self.attribute).create(:alchemy_file_instance => rec)
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/custom/model/engine.rb

@@ -0,0 +1,40 @@
+module Alchemy
+  module Custom
+    module Model
+      class Engine < ::Rails::Engine
+        isolate_namespace Alchemy::Custom::Model
+        #engine_name 'alchemy'
+
+        config.autoload_paths << config.root.join('lib')
+
+        initializer "alchemy_custom_model.assets.precompile" do |app|
+          app.config.assets.precompile << 'alchemy_custom_model_manifest.js'
+          app.config.assets.precompile << 'elfinder/css/elfinder.min.css'
+          app.config.assets.precompile << 'elfinder/css/theme.css'
+          app.config.assets.paths << config.root.join("vendor")
+
+        end
+
+        config.to_prepare do
+
+          Alchemy::PagesController.include(PagesControllerDec)
+
+          # load degli helpers per alchemy
+          [
+            Alchemy::Custom::Model::Engine.root.join('app', 'helpers', 'alchemy', 'pages_helper_decorator.rb')
+          ].each do |f|
+            Rails.configuration.cache_classes ? require(f) : load(f)
+          end
+
+
+        end
+
+
+        # initializer "alchemy_richmedia_essences.register_ability" do
+        #   Alchemy.register_ability Alchemy::Richmedia::Essences::Ability
+        # end
+
+      end
+    end
+  end
+end

data/lib/alchemy/custom/model/global_id_setter.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+
+module Alchemy
+  module Custom
+    module Model
+      module GlobalIdSetter
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          private
+
+          ##
+          # Metodo per ricevere un global id ed associare il relativo modello
+          #
+          def global_id_setter(field)
+
+            alias_method "_old_#{field}=".to_sym, "#{field}=".to_sym
+
+            define_method "#{field}=" do |v|
+              if v.is_a?(String)
+                v = GlobalID::Locator.locate_signed v
+              end
+              send("_old_#{field}=", v)
+            end
+
+
+          end
+
+
+        end
+      end
+    end
+  end
+end