erp_tech_svcs 4.0.0 → 4.2.0

data/lib/erp_tech_svcs/file_support/manager.rb

@@ -53,13 +53,17 @@ module ErpTechSvcs
       end
 
       def build_file_assets_tree_for_model(model, starting_path)
-        files = model.files
+        files = model.files.where('directory like ?', starting_path + '%')
 
         node_tree = [{:text => root, :leaf => false, :id => root, :children => []}]
         
         paths = files.collect{|file| File.join(file.directory,file.name)}
 
-        node_tree.first[:children] << {:id => starting_path, :text => starting_path.split('/').last, :children => []} if paths.select{|path| path.split('/')[1] == starting_path.split('/')[1]}.empty?
+        node_tree.first[:children] << {:id => starting_path,
+                                       :text => starting_path.split('/').last,
+                                       leaf: true,
+                                       iconCls: 'icon-document',
+                                       :children => []} if paths.select{|path| path.split('/')[1] == starting_path.split('/')[1]}.empty?
         
         nesting_depth = paths.collect{|item| item.split('/').count}.max
         unless nesting_depth.nil?
@@ -117,7 +121,12 @@ module ErpTechSvcs
         file_asset_nodes.each do |child_asset_node|
           node = find_node(File.join(self.root,child_asset_node[:id]))
           unless node.nil?
-            folders = node[:children].select{|item| !item[:leaf]}
+            if node[:leaf]
+              folders = []
+            else
+              folders = node[:children].select{|item| !item[:leaf]}
+            end
+
             child_asset_node[:children] = [] if child_asset_node[:children].nil? && !folders.empty?
             folders.each do |folder|
               folder[:id].gsub!(self.root,'')

data/lib/erp_tech_svcs/file_support/railties/compass_ae_resolver.rb

@@ -0,0 +1,49 @@
+module ActionView
+  class CompassAeFileResolver < OptimizedFileSystemResolver
+    def cached(key, path_info, details, locals) #:nodoc:
+      name, prefix, partial = path_info
+      locals = locals.map { |x| x.to_s }.sort!
+
+      if key && caching?
+        if @cached[key][name][prefix][partial][locals].nil? or @cached[key][name][prefix][partial][locals].empty?
+          @cached[key][name][prefix][partial][locals] = decorate(yield, path_info, details, locals)
+        else
+          @cached[key][name][prefix][partial][locals].each do |template|
+            #check if the file still exists
+            if File.exists? template.identifier
+              last_update = mtime(template.identifier)
+              if last_update > template.updated_at
+                @cached[key][name][prefix][partial][locals].delete_if{|item| item.identifier == template.identifier}
+                @cached[key][name][prefix][partial][locals] << build_template(template.identifier, template.virtual_path, (details[:formats] || [:html] if template.formats.empty?), template.locals)
+              end
+            else
+              @cached[key][name][prefix][partial][locals].delete_if{|item| item.identifier == template.identifier}
+            end
+          end
+          @cached[key][name][prefix][partial][locals]
+        end
+      else
+        fresh = decorate(yield, path_info, details, locals)
+        return fresh unless key
+
+        scope = @cached[key][name][prefix][partial]
+        cache = scope[locals]
+        mtime = cache && cache.map(&:updated_at).max
+
+        if !mtime || fresh.empty?  || fresh.any? { |t| t.updated_at > mtime }
+          scope[locals] = fresh
+        else
+          cache
+        end
+      end
+    end
+
+    protected
+
+    def build_template(p, virtual_path, formats, locals=nil)
+      handler, format = extract_handler_and_format(p, formats)
+      contents = File.open(p, "rb") { |io| io.read }
+      Template.new(contents, p, handler, :virtual_path => virtual_path, :format => format, :updated_at => mtime(p), :locals => locals)
+    end
+  end
+end

data/lib/erp_tech_svcs/file_support/s3_manager.rb

@@ -11,10 +11,10 @@ module ErpTechSvcs
           @@configuration = YAML::load_file(File.join(Rails.root, 'config', 's3.yml'))[Rails.env]
 
           # S3 debug logging
-           AWS.config(
-               :logger => Rails.logger,
-               :log_level => :info
-           )
+          AWS.config(
+              :logger => Rails.logger,
+              :log_level => :info
+          )
 
           @@s3_connection = AWS::S3.new(
               :access_key_id => @@configuration['access_key_id'],
@@ -106,7 +106,7 @@ module ErpTechSvcs
           options = (file.nil? ? {} : {:acl => acl})
           path = path.sub(%r{^/}, '')
           new_path = new_path.sub(%r{^/}, '')
-#          Rails.logger.info "renaming from #{path} to #{new_path}"
+
           old_object = bucket.objects[path]
           if new_object = old_object.move_to(new_path, options)
             message = "#{old_name} was renamed to #{name} successfully"
@@ -132,13 +132,9 @@ module ErpTechSvcs
         result = false
         message = nil
         begin
-          if options[:force] or bucket.as_tree(:prefix => path).children.count <= 1 # aws-sdk includes the folder itself as a child (like . is current dir), this needs revisited as <= 1 is scary
-            bucket.objects.with_prefix(path).delete_all
-            message = "File was deleted successfully"
-            result = true
-          else
-            message = FOLDER_IS_NOT_EMPTY
-          end
+          bucket.objects.with_prefix(path).delete_all
+          message = "File was deleted successfully"
+          result = true
         rescue => ex
           result = false
           message = ex
@@ -178,57 +174,83 @@ module ErpTechSvcs
       end
 
       def find_node(path, options={})
+        parent = {
+            :text => path.split('/').pop,
+            :iconCls => "icon-content",
+            :leaf => false,
+            :id => path,
+            :children => []
+        }
+
         #remove proceeding slash for s3
         path.sub!(%r{^/}, '')
 
-        parent = {:text => path.split('/').pop, :leaf => false, :id => path, :children => []}
-
-        tree = bucket.as_tree(:prefix => path)
-        tree.children.each do |node|
-          if node.leaf?
-            #ignore current path that comes as leaf from s3
-            next if node.key == path + '/'
-
-            leaf_hash = {
-                :text => node.key.split('/').pop,
-                :downloadPath => "/#{node.key}",
-                :id => "/#{node.key}",
-                :leaf => true
-            }
-
-            if options[:file_asset_holder]
-              files = options[:file_asset_holder].files
-
-              parent_directories =  leaf_hash[:id].split('/')
-              parent_directories.pop
-              parent_directory = parent_directories.join('/')
-
-              file = files.find { |file| file.directory == parent_directory and file.name == leaf_hash[:text] }
-              unless file.nil?
-                leaf_hash[:isSecured] = file.is_secured?
-                leaf_hash[:roles] = file.roles.collect { |r| r.internal_identifier }
-                leaf_hash[:iconCls] = 'icon-document_lock' if leaf_hash[:isSecured]
-                leaf_hash[:size] = file.data_file_size
-                leaf_hash[:width] = file.width
-                leaf_hash[:height] = file.height
-                leaf_hash[:url] = file.url
+        if File.extname(path).blank?
+          tree = bucket.as_tree(:prefix => path)
+
+          tree.children.each do |node|
+            if node.leaf?
+              #ignore current path that comes as leaf from s3
+              next if node.key == path + '/'
+
+              leaf_hash = {
+                  :text => node.key.split('/').pop,
+                  :downloadPath => "/#{node.key.split('/')[0..-2].join('/')}",
+                  :id => "/#{node.key}",
+                  :iconCls => 'icon-document',
+                  :leaf => true
+              }
+
+              if options[:file_asset_holder]
+                leaf_hash = apply_file_asset_properties(options[:file_asset_holder], leaf_hash)
               end
+
+              parent[:children] << leaf_hash
+            else
+              parent[:children] << {
+                  :iconCls => "icon-content",
+                  :text => node.prefix.split('/').pop,
+                  :id => "/#{node.prefix}".chop,
+                  :leaf => false
+              }
             end
+          end
 
-            parent[:children] << leaf_hash
-          else
-            parent[:children] << {
-                :iconCls => "icon-content",
-                :text => node.prefix.split('/').pop,
-                :id => "/#{node.prefix}".chop,
-                :leaf => false
-            }
+        else
+          parent[:iconCls] = 'icon-document'
+          parent[:leaf] = true
+          parent[:downloadPath] = "/#{path.split('/')[0..-2].join('/')}"
+
+          if options[:file_asset_holder]
+            parent = apply_file_asset_properties(options[:file_asset_holder], parent)
           end
         end
 
+        # add preceding slash back to parent
+        parent[:id] = "/#{parent[:id]}"
+
         parent
       end
 
+      private
+
+      def apply_file_asset_properties(file_asset_holder, hash)
+        files = file_asset_holder.files
+
+        file = files.find { |file| file.directory == hash[:downloadPath] and file.name == hash[:text] }
+        unless file.nil?
+          hash[:isSecured] = file.is_secured?
+          hash[:roles] = file.roles.collect { |r| r.internal_identifier }
+          hash[:iconCls] = 'icon-document_lock' if hash[:isSecured]
+          hash[:size] = file.data_file_size
+          hash[:width] = file.width
+          hash[:height] = file.height
+          hash[:url] = file.data.url
+        end
+
+        hash
+      end
+
     end #S3Manager
   end #FileSupport
 end #ErpTechSvcs

data/lib/erp_tech_svcs/utils/compass_access_negotiator.rb

@@ -5,15 +5,24 @@ module ErpTechSvcs
       # pass in (capability_type_iid, class name) or (capability_type_iid, any class instance)
       # Example: can user upload files? user.has_capability?('upload', 'FileAsset')
       # Example: can download this file? user.has_capability?('download', file_asset)
-      def has_capability?(capability_type_iid, klass)
+      def has_capability?(capability_type_iid, klass, instance_id = nil)
         capability_type_iid = capability_type_iid.to_s if capability_type_iid.is_a?(Symbol)
-        if klass.is_a?(String)
+        if klass.is_a?(String) and instance_id.nil?
           scope_type = ScopeType.find_by_internal_identifier('class')
           capability = Capability.joins(:capability_type).
                                   where(:capability_resource_type => klass).
                                   where(:scope_type_id => scope_type.id).
                                   where(:capability_types => {:internal_identifier => capability_type_iid}).first
           return nil if capability.nil? # capability not found so return nil
+        elsif klass.is_a?(String)
+          scope_type = ScopeType.find_by_internal_identifier('instance')
+
+          capability = Capability.joins(:capability_type).
+              where(:capability_resource_type => klass).
+              where(:capability_resource_id => instance_id).
+              where(:scope_type_id => scope_type.id).
+              where(:capability_types => {:internal_identifier => capability_type_iid}).first
+          return !klass.constantize.protect_all_instances if capability.nil?
         else
           scope_type = ScopeType.find_by_internal_identifier('instance')
           capability = klass.capabilities.joins(:capability_type).

data/lib/erp_tech_svcs/utils/default_nested_set_methods.rb

@@ -1,65 +1,257 @@
 module ErpTechSvcs
-	module Utils
-		module DefaultNestedSetMethods
-			def self.included(base)
-				base.extend(ClassMethods)
-			end
+  module Utils
+    module DefaultNestedSetMethods
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
 
-			def to_label
-				description
-			end
+      module ClassMethods
+        # returns an array of hashes which represent all nodes in nested set order,
+        # each of which consists of the node's id, internal identifier and representation
+        # if a parent is passed it starts there in the tree
+        def to_all_representation(parent=nil, container_arr=[], level=0, ancestors=nil)
+          if parent
+            parent.children.each do |node|
+              container_arr << {id: node.id,
+                                description: node.to_representation(level),
+                                internal_identifier: node.internal_identifier}
 
-			def leaf
-			  children.size == 0
-			end
+              unless node.leaf?
+                to_all_representation(node, container_arr, (level + 1))
+              end
 
-			def to_json_with_leaf(options = {})
-				self.to_json_without_leaf(options.merge(:methods => :leaf))
-			end
-			alias_method_chain :to_json, :leaf
+            end
+          else
+            ancestors = (ancestors || self.roots)
+            ancestors.each do |root|
+              container_arr << {id: root.id,
+                                description: root.to_representation(level),
+                                internal_identifier: root.internal_identifier}
 
-      def to_tree_hash(options={})
-        options = options.merge({
-          :text => self.to_label,
-          :leaf => self.leaf,
-          :children => self.children.collect{|child| child.to_tree_hash(options)}
-        })
+              to_all_representation(root, container_arr, (level + 1))
+            end
+          end
 
-        self.to_hash(options)
-      end
+          container_arr
+        end
 
-			module ClassMethods
-				def find_roots
-					where("parent_id = nil")
-				end
+        def find_roots
+          where("parent_id is null")
+        end
+
+        def find_children(parent_id = nil)
+          parent_id.to_i == 0 ? self.roots : find(parent_id).children
+        end
 
-				def find_children(parent_id = nil)
-					parent_id.to_i == 0 ? self.roots : find(parent_id).children
-				end
-				
-				# find_by_ancestor_iids
+        # find_by_ancestor_iids
         # allows you to find a nested set element by the internal_identifiers in its ancestry
         # for example, to find a GlAccount whose internal_identifier is “site_4”, and whose parent’s internal_identifier is “nightly_room_charge”
         # and whose grandparent’s internal_identifier is “charge”, you would make this call:
         # gl_account = GlAccount.find_by_iids(['charge', 'nightly_room_charge', "site_4"])
         def find_by_ancestor_iids(iids)
-          return nil unless iids.is_a? Array
-
           node = nil
-          iids.each do |iid|
-            if (iid == iids.first)
-              node = where("parent_id is null and internal_identifier = ?",iid).first
-            else
-              node = where("parent_id = ? and internal_identifier = ?",node.id,iid).first
+
+          if iids.is_a? Array
+            iids.each do |iid|
+              if (iid == iids.first)
+                node = where("parent_id is null and internal_identifier = ?", iid).first
+              else
+                node = where("parent_id = ? and internal_identifier = ?", node.id, iid).first
+              end
             end
-            return nil if node.nil?
           end
-          return node
+
+          node
         end
-        
-			end
 
-		end #DefaultNestedSetMethods
-	end #Utils
-end #ErpTechSvcs
+        # find existing node or create it and return it.  Parent can be passed
+        # which will scope this node by the parent
+        def find_or_create(iid, description, parent=nil)
+          # look for it
+          record = if parent
+            parent.children.find_by_internal_identifier(iid)
+          else
+            find_by_internal_identifier(iid)
+          end
+
+          unless record
+            record = create(description: description, internal_identifier: iid)
+
+            if parent
+              record.move_to_child_of(parent)
+            end
+          end
+
+          record
+        end
+
+        # Build a tree based on internal identifiers passed
+        #
+        # @param [Array] Array of internal identifiers
+        # @return [Array] Tree from nodes
+        def build_tree_from_nodes(node_iids)
+          tree = []
+
+          # first we convert the nodes to a hash based array
+          node_iids.each do |node_iid|
+            node = self.iid(node_iid)
+
+            tree << node.to_hash({only: [{id: :record_id}, :parent_id, :internal_identifier],
+                                  leaf: node.leaf?,
+                                  text: node.to_label,
+                                  children: []})
+          end
+
+          # next we need to build the tree structure based on the nodes
+          sorted_tree = tree.dup
+          tree.each do |node_hash|
+            node = self.find(node_hash[:record_id])
+
+            parent_node = nil
+            if node.parent
+              parent_node = find_parent_in_tree(sorted_tree, node.parent.id)
+            end
+
+            if parent_node
+              # add to children of parent
+              parent_node[:children] << node_hash
+
+              # remove from updated tree
+              sorted_tree.delete_if { |item| node_hash[:record_id] == item[:record_id] }
+            end
+          end
+
+          sorted_tree
+        end
+
+        # Delete nodes from a tree based on passed ids
+        #
+        # @param [Integer, Array] Either an Id or an array of ids to remove
+        # @return [Array] Tree with items removed
+        def delete_from_tree(tree, id)
+          if id.is_a? Array
+            id.each do |_id|
+              delete_from_tree(tree, _id)
+            end
+          else
+            tree.each do |node|
+              if node[:record_id] == id
+                tree.delete(node)
+              end
+
+              if node[:children]
+                delete_from_tree(node[:children], id)
+              end
+            end
+          end
+
+          tree
+        end
+
+        private
 
+        def find_parent_in_tree(tree, id)
+          parent = nil
+
+          tree.each do |node|
+            if node[:record_id] == id
+              parent = node
+              break
+            end
+
+            if node[:children]
+              parent = find_parent_in_tree(node[:children], id)
+
+              if parent
+                break
+              end
+            end
+          end
+
+          parent
+        end
+
+      end
+
+      def to_label
+        description
+      end
+
+      def leaf
+        children.size == 0
+      end
+
+      def to_json_with_leaf(options = {})
+        self.to_json_without_leaf(options.merge(:methods => :leaf))
+      end
+
+      alias_method_chain :to_json, :leaf
+
+      def to_tree_hash(options={})
+        options = {
+          only: [:parent_id, :internal_identifier],
+          leaf: self.leaf?,
+          text: self.to_label,
+          children: self.children.collect { |child| child.to_tree_hash(options) }
+        }.merge(options)
+
+        self.to_hash(options)
+      end
+
+      def children_to_tree_hash(options={})
+        self.children.collect { |child| child.to_tree_hash(options) }
+      end
+
+      def to_representation(level)
+        # returns a string that consists of 1) a number of dashes equal to
+        # the category's level and 2) the category's description attr
+        rep = ''
+
+        if level > 0
+          level.times { rep << '-' }
+          rep += ' '
+        end
+
+        rep << description
+      end
+
+      def to_record_representation(root = self.class.root)
+        # returns a string of category descriptions like
+        # 'main_category > sub_category n > ... > this category instance'
+        if root?
+          description
+        else
+          crawl_up_from(self, root).split('///').compact.reverse.join(' > ')
+        end
+      end
+
+      def is_descendant_of?(type)
+        type = self.class.iid(type) if (type.is_a? String)
+        parent = self.parent
+
+        if type.id == self.id
+          result = true
+        elsif parent.nil?
+          result = false
+        elsif parent.id == type.id
+          result = true
+        else
+          result = parent.is_descendant_of? type
+        end
+        result
+      end
+
+      private
+
+      def crawl_up_from(node, to_node = self.class.root)
+        unless node.nil?
+          # returns a string that is a '///'-separated list of nodes
+          # from child node to root
+          "#{node.description}///#{crawl_up_from(node.parent, to_node) if node != to_node}"
+        end
+      end
+
+
+    end #DefaultNestedSetMethods
+  end #Utils
+end #ErpTechSvcs