erp_tech_svcs 3.0.0

data/lib/erp_tech_svcs/extensions/active_record/has_capabilities.rb

@@ -0,0 +1,139 @@
+module ErpTechSvcs
+	module Extensions
+		module ActiveRecord
+			module HasCapabilities
+
+				def self.included(base)
+					base.extend(ClassMethods)  	        	      	
+				end
+
+				module ClassMethods
+
+				  def has_capabilities
+				    extend HasCapabilities::SingletonMethods
+    				include HasCapabilities::InstanceMethods
+    				
+    				after_initialize :initialize_capable_model
+    				after_update     :save_capable_model
+    				after_create     :save_capable_model
+    				after_destroy    :destroy_capable_model
+    				
+    				has_one :capable_model, :as => :capable_model_record
+				  end
+				end
+				
+				module SingletonMethods			
+				end
+						
+				module InstanceMethods
+				  def capabilities
+            capable_model.capabilities
+          end
+
+          def available_capability_resources
+            capabilities.collect{|capability| capability.resource}.uniq
+          end
+
+          def capabilites_by_resource(resource)
+            self.capabilities.where('resource = ?', resource)
+          end
+
+          def user_has_capability?(capability_type, resource, user)
+            capability_type = convert_capability_type(capability_type)
+            raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityTypeDoesNotExist if capability_type.nil?
+
+            capability = self.capabilities.where('capability_type_id = ? and resource = ?', capability_type.id, resource).first
+            unless capability.nil?
+              capability.has_access?(user)
+            else
+              raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityDoesNotExist
+            end
+          end
+
+          def add_capability(capability_type, resource, *roles)
+            capability_type = convert_capability_type(capability_type)
+            raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityTypeDoesNotExist if capability_type.nil?
+            
+            capability = self.capabilities.where('capability_type_id = ? and resource = ?', capability_type.id, resource).first
+            if capability.nil?
+              capability = Capability.create(:capability_type => capability_type, :resource => resource)
+              capability.add_roles(roles)
+              self.capable_model.capabilities << capability
+              self.capable_model.save
+            else
+              raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityAlreadytExists
+            end
+
+            capability
+          end
+
+          def update_capability(capability_type, resource, *roles)
+            capability_type = convert_capability_type(capability_type)
+            raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityTypeDoesNotExist if capability_type.nil?
+
+            capability = self.capabilities.where('capability_type_id = ? and resource = ?', capability_type.id, resource).first
+            unless capability.nil?
+              capability.remove_all_roles
+              capability.add_roles(roles)
+            else
+              raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityDoesNotExist
+            end
+          end
+
+          def remove_all_capabilities
+            self.capabilities.each do |capability|
+              remove_capability(capability.type, capability.resource)
+            end
+          end
+
+          def remove_capability(capability_type, resource)
+            capability_type = convert_capability_type(capability_type)
+            raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityTypeDoesNotExist if capability_type.nil?
+
+            capability = self.capabilities.where('capability_type_id = ? and resource = ?', capability_type.id, resource).first
+            unless capability.nil?
+              capability.destroy
+            else
+              raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::CapabilityDoesNotExist
+            end
+          end
+
+          def capabilites_to_hash
+            self.capabilities.map do|capability| 
+              {
+                :capability_type_iid => capability.type.internal_identifier,
+                :resource => capability.resource,
+                :roles => capability.roles.collect{|role| role.internal_identifier}
+              }
+            end
+          end
+
+          def initialize_capable_model
+            if self.capable_model.nil?
+              capable_model = CapableModel.new
+              self.capable_model = capable_model
+              capable_model.capable_model_record = self
+            end
+          end
+
+				  def save_capable_model
+  					capable_model.save
+				  end
+				  
+				  def destroy_capable_model
+					  if self.capable_model && !self.capable_model.frozen?
+  					  self.capable_model.destroy
+  					end
+				  end
+
+          private
+
+          def convert_capability_type(type)
+            CapabilityType.find_by_internal_identifier(type.to_s) if (type.is_a?(String) || type.is_a?(Symbol))
+          end
+
+				end
+			end
+		end
+	end
+end

data/lib/erp_tech_svcs/extensions/active_record/has_file_assets.rb

@@ -0,0 +1,40 @@
+module ErpTechSvcs
+	module Extensions
+		module ActiveRecord
+			module HasFileAssets
+
+				def self.included(base)
+					base.extend(ClassMethods)  	        	      	
+				end
+
+				module ClassMethods
+					def has_file_assets
+						extend HasFileAssets::SingletonMethods
+						include HasFileAssets::InstanceMethods
+						
+						has_many :files, :as => :file_asset_holder, :class_name => 'FileAsset', :dependent => :delete_all 								
+					end
+				end
+  		
+				module SingletonMethods
+				end
+				
+				module InstanceMethods
+				  
+          def add_file(data, path=nil)
+						FileAsset.create!(:file_asset_holder => self, :base_path => path, :data => data)
+          end
+
+          def images
+						self.files.where('type = ?', 'Image')
+          end
+
+          def templates
+						self.files.where('type = ?', 'Template')
+          end
+          
+				end
+			end
+		end
+	end
+end

data/lib/erp_tech_svcs/extensions/active_record/has_roles.rb

@@ -0,0 +1,126 @@
+module ErpTechSvcs
+	module Extensions
+		module ActiveRecord
+			module HasRoles
+
+        module Errors
+          exceptions = %w[UserDoesNotHaveAccess]
+          exceptions.each { |e| const_set(e, Class.new(StandardError)) }
+        end
+
+				def self.included(base)
+					base.extend(ClassMethods)  	        	      	
+				end
+
+				module ClassMethods
+				  def has_roles
+				    extend HasRoles::SingletonMethods
+    				include HasRoles::InstanceMethods
+    				
+    				after_initialize :initialize_secured_model
+    				after_update     :save_secured_model
+    				after_create     :save_secured_model
+    				after_destroy    :destroy_secured_model
+    				
+    				has_one :secured_model, :as => :secured_record    												
+				  end
+				end
+				
+				module SingletonMethods			
+				end
+						
+				module InstanceMethods
+				  def roles
+					  self.secured_model.roles
+				  end
+
+          def has_access?(user)
+					  has_access = true
+  					unless self.secured_model.roles.empty?
+  					  has_access = if user.nil?
+  						  false
+  					  else
+  					    user.has_role?(self.secured_model.roles.collect{|item| item.internal_identifier})
+  					  end
+  					end
+            has_access
+				  end
+
+          def with_access(user, &block)
+            if has_access?(user)
+              yield
+            else
+              raise ErpTechSvcs::Extensions::ActiveRecord::HasRoles::UserDoesNotHaveAccess
+            end
+          end
+
+				  def add_role(role)
+					  role = Role.find_by_internal_identifier(role) if role.is_a? String
+            unless self.has_role?(role)
+  					  self.secured_model.roles << role
+  					  self.secured_model.save
+  					end
+				  end
+
+          def add_roles(*roles)
+            roles.flatten!
+            roles = roles[0] if roles[0].is_a? Array
+            roles.each do |role|
+              self.add_role(role)
+            end
+          end
+
+          def remove_role(role)
+            role = Role.find_by_internal_identifier(role) if role.is_a? String
+            self.secured_model.roles.delete(role) if has_role?(role)
+				  end
+
+          def remove_roles(*roles)
+            roles.flatten!
+            roles.each do |role|
+              self.remove_role(role)
+            end
+				  end
+
+          def remove_all_roles
+            self.roles.delete_all
+				  end
+
+          def has_role?(*passed_roles)
+            result = false
+            passed_roles.flatten!
+            passed_roles.each do |role|
+              role_iid = (role.is_a?(String)) ? role : role.internal_identifier
+              self.roles.each do |this_role|
+                result = true if (this_role.internal_identifier == role_iid)
+                break if result
+              end
+              break if result
+            end
+            result
+          end
+				  
+          def initialize_secured_model
+            if self.new_record? && self.secured_model.nil?
+              secured_model = SecuredModel.new
+              self.secured_model = secured_model
+              secured_model.secured_record = self
+            end
+          end
+
+          def save_secured_model
+            secured_model.save
+          end
+				  
+          def destroy_secured_model
+            if self.secured_model && !self.secured_model.frozen?
+              self.secured_model.destroy
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/erp_tech_svcs/extensions.rb

@@ -0,0 +1,5 @@
+#active record extensions
+require 'erp_tech_svcs/extensions/active_record/has_file_assets'
+require 'erp_tech_svcs/extensions/active_record/has_roles'
+require 'erp_tech_svcs/extensions/active_record/has_capabilities'
+require 'erp_tech_svcs/extensions/active_record/acts_as_versioned'

data/lib/erp_tech_svcs/file_support/aws_s3_patch.rb

@@ -0,0 +1,3 @@
+Module.class_eval do
+  alias_method :const_missing, :const_missing_not_from_s3_library
+end

data/lib/erp_tech_svcs/file_support/base.rb

@@ -0,0 +1,30 @@
+module ErpTechSvcs
+  module FileSupport
+    DEFAULT_OPTIONS = {
+      :storage => :filesystem
+    }
+
+    mattr_accessor :options
+    @@options = HashWithIndifferentAccess.new(DEFAULT_OPTIONS)
+
+    class Base
+      attr_accessor :storage
+
+      def initialize(options={})
+        @storage = options[:storage].nil? ? :filesystem : options[:storage]
+
+        case @storage
+        when :s3
+          @manager = S3Manager.new
+        when :filesystem
+          @manager = FileSystemManager.new
+        end
+      end
+
+      def method_missing(m, *args, &block)
+        @manager.respond_to?(m) ? @manager.send(m, *args) : super
+      end
+
+    end
+  end
+end

data/lib/erp_tech_svcs/file_support/file_manipulator.rb

@@ -0,0 +1,37 @@
+module ErpTechSvcs
+  class FileManipulator
+    class << self
+
+      def patch_file(path, current, insert, options = {})
+        options = {
+          :patch_mode => :insert_after
+        }.merge(options)
+
+        old_text = current
+        new_text = patch_string(current, insert, options[:patch_mode])
+
+        content = File.open(path) { |f| f.read }
+        content.gsub!(old_text, new_text) unless content =~ /#{Regexp.escape(insert)}/mi
+        File.open(path, 'w') { |f| f.puts(content) }
+      end
+
+      def append_file(path, content)
+        File.open(path, 'a') { |f| f.puts(content) }
+      end
+
+      def patch_string(current, insert, mode = :insert_after)
+        case mode
+        when :change
+          "#{insert}"
+        when :insert_after
+          "#{current}\n#{insert}"
+        when :insert_before
+          "#{insert}\n#{current}"
+        else
+          patch_string(current, insert, :insert_after)
+        end
+      end
+
+    end
+  end
+end

data/lib/erp_tech_svcs/file_support/file_system_manager.rb

@@ -0,0 +1,167 @@
+module ErpTechSvcs
+  module FileSupport
+    class FileSystemManager < Manager
+      REMOVE_FILES_REGEX = /^\./
+
+      def root
+        File.join(Rails.root,'public')
+      end
+
+      def update_file(path, content)
+        File.open(path, 'w+') {|f| f.puts(content) }
+      end
+
+      def create_file(path, name, contents)
+        FileUtils.mkdir_p path unless File.exists? path
+        File.open(File.join(path,name), 'w+') {|f| f.puts(contents) }
+      end
+
+      def create_folder(path, name)
+        FileUtils.mkdir_p File.join(path,name) unless File.directory? File.join(path,name)
+      end
+
+      def save_move(path, new_parent_path)
+        result = nil
+        unless File.exists? path
+          message = 'File does not exists'
+        else
+          name = File.basename(path)
+          #make sure path is there.
+          FileUtils.mkdir_p new_parent_path unless File.directory? new_parent_path
+          FileUtils.mv(path, new_parent_path + '/' + name)
+          message = "#{name} was moved to #{new_parent_path} successfully"
+          result = true
+        end
+
+        return result, message
+      end
+
+      def exists?(path)
+        File.exists? path
+      end
+
+      def rename_file(path, name)
+        result = nil
+        unless File.exists? path
+          message = 'File does not exists'
+        else
+          old_name = File.basename(path)
+          path_pieces = path.split('/')
+          path_pieces.delete(path_pieces.last)
+          path_pieces.push(name)
+          new_path = path_pieces.join('/')
+          File.rename(path, new_path)
+          message = "#{old_name} was renamed to #{name} successfully"
+          result = true
+        end
+
+        return result, message
+      end
+
+      def delete_file(path, options={})
+        result = nil
+        name = File.basename(path)
+        is_directory = false
+        if !File.exists? path and !File.directory? path
+          message = 'File / Folder does not exist'
+        else
+          if File.directory? path
+            is_directory = true
+            entries = Dir.entries(path)
+            entries.delete_if{|entry| entry =~ REMOVE_FILES_REGEX}
+            if entries.count > 0 && !options[:force]
+              message = "Folder is not empty"
+              result = false;
+            else
+              FileUtils.rm_rf(path)
+              message = "Folder #{name} was deleted #{name} successfully"
+              result = true
+            end
+          else
+            FileUtils.rm_rf(path)
+            message = "File #{name} was deleted #{name} successfully"
+            result = true
+          end
+        end
+
+        return result, message, is_directory
+      end
+
+      def get_contents(path)
+        contents = nil
+        message = nil
+        unless File.exists? path
+          message = 'File does not exists'
+        else
+          contents = IO.read(path)
+        end
+        return contents, message
+      end
+
+      def build_tree(starting_path, options={})
+        find_node(starting_path, options)
+      end
+
+      def find_node(path, options={})
+        parent = if options[:file_asset_holder]
+          super
+        else
+          path_pieces = path.split('/')
+          parent = build_tree_for_directory(path, options)
+          unless parent[:id] == path
+            path_pieces.each do |path_piece|
+              next if path_piece.blank?
+              parent[:children].each do |child_node|
+                if child_node[:text] == path_piece
+                  parent = child_node
+                  break
+                end
+              end
+            end
+          end
+
+          parent = nil if parent[:id] != path
+          parent
+        end
+
+        parent
+      end
+
+      private
+
+      def build_tree_for_directory(directory, options)
+        keep_full_path = nil
+        if directory.index(Rails.root.to_s).nil?
+          tree_data = {:text => directory.split('/').last, :id => directory, :leaf => false, :children => []}
+        else
+          keep_full_path = true
+          tree_data = {:text => directory.split('/').last, :id => directory, :leaf => false, :children => []}
+        end
+
+        Dir.entries(directory).each do |entry|
+          #ignore .svn folders and any other folders starting with .
+          next if entry =~ REMOVE_FILES_REGEX
+
+          path = File.join(directory, entry)
+          path.gsub!(root,'') unless keep_full_path
+
+          if File.directory?(File.join(directory,entry))
+            tree_data[:children] << if options[:preload]
+              build_tree_for_directory(path, options) if options[:preload]
+            else
+              {:text => entry, :id => path}
+            end
+          elsif !options[:included_file_extensions_regex].nil? && entry =~ options[:included_file_extensions_regex]
+            tree_data[:children] << {:text => entry, :leaf => true, :downloadPath => path, :id => path}
+          elsif options[:included_file_extensions_regex].nil?
+            tree_data[:children] << {:text => entry, :leaf => true, :downloadPath => path, :id => path}
+          end
+        end if File.directory?(directory)
+
+        tree_data[:children].sort_by{|item| [item[:id]]}
+        tree_data
+      end
+
+    end#FileSystemManager
+  end#FileSupport
+end#ErpTechSvcs

data/lib/erp_tech_svcs/file_support/manager.rb

@@ -0,0 +1,147 @@
+module ErpTechSvcs
+  module FileSupport
+    class Manager
+
+      class << self
+        def find_parent(item, parents)
+          parents.find do |parent|
+            path = item[:path].gsub(item[:text],'').split('/').join('/')
+            parent[:id] == path
+          end
+        end
+      end
+
+      def sync(path, model)
+        result = nil
+        message = nil
+
+        node = find_node(path)
+        if node.nil?
+          message = "Nothing to sync"
+        else
+          sync_node(node, model)
+          message = "Sync successful"
+          result = true
+        end
+
+        return result, message
+      end
+
+      def find_node(path, options={})
+        node_tree = build_file_assets_tree_for_model(options[:file_asset_holder], path.gsub(root, ''))
+
+        path_pieces = path.split('/')
+        parent = node_tree.first
+        path_pieces.each do |path_piece|
+          next if path_piece.blank?
+          parent[:children].each do |child_node|
+            if child_node[:text] == path_piece
+              parent = child_node
+              break
+            end
+          end
+        end
+
+        path.sub!(self.root,'') if parent[:id].scan(self.root).empty?
+        path = File.join(self.root, path) if !parent[:id].scan(self.root).empty? and path.scan(self.root).empty?
+
+        parent = [] if parent[:id] != path
+        parent
+      end
+
+      def build_file_assets_tree_for_model(model, starting_path)
+        node_tree = [{:text => root, :leaf => false, :id => root, :children => []}]
+        
+        paths = model.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?
+        
+        nesting_depth = paths.collect{|item| item.split('/').count}.max
+        unless nesting_depth.nil?
+          levels = []
+          (1..nesting_depth).each do |i|
+            current_items = []
+            objects_this_depth = paths.collect{|item|
+              text = item.split('/')[i - 1]
+              path = item.split('/')[0..(i-1)].join('/')
+              if item.split('/').count >= i && current_items.select{|item| item[:text] == text and item[:path] == path}.empty?
+                item_hash = {:text => text, :path => path}
+                current_items << item_hash
+                item_hash
+              end
+            }
+            objects_this_depth.delete_if{|item| (item.nil? or item[:text].blank?)}
+            levels << objects_this_depth unless objects_this_depth.empty?
+          end
+
+          old_parents = []
+          new_parents = [node_tree[0]]
+          levels.each do |level|
+            old_parents = new_parents
+            new_parents = []
+            level.each do |item|
+              parent = old_parents.count == 1 ? old_parents.first : self.class.find_parent(item, old_parents)
+              path = File.join(parent[:id], item[:text]).gsub(root, '')
+              child_hash = {:text => item[:text], :downloadPath => path, :leaf => !File.extname(item[:text]).blank?, :id => path, :children => []}
+              new_parents << child_hash
+              parent[:children] << child_hash
+            end
+          end
+        end
+
+        insert_folders(node_tree.first[:children])
+
+        node_tree
+      end
+
+      def insert_folders(file_asset_nodes)
+        file_asset_nodes.each do |child_asset_node|
+          node = find_node(File.join(self.root,child_asset_node[:id]))
+          folders = node[:children].select{|item| !item[:leaf]}
+          child_asset_node[:children] = [] if child_asset_node[:children].nil? && !folders.empty?
+          folders.each do |folder|
+            folder[:id].gsub!(self.root,'')
+            child_asset_node[:children] << folder unless child_asset_node[:children].collect{|child_node| child_node[:text] }.include?(folder[:text])
+          end
+          insert_folders(child_asset_node[:children])
+        end unless file_asset_nodes.nil?
+      end
+
+      private
+
+      def sync_node(node, model)
+        leaves = get_all_leaves(node)
+        leaves.each do |leaf|
+          create_file_asset_for_node(leaf, model)
+        end
+
+        model.files.find(:all, :conditions => "directory like '#{node[:id].sub(self.root, '')}%'").each do |file_asset|
+          unless self.exists? File.join(self.root, file_asset.directory, file_asset.name)
+            puts "File #{File.join(self.root, file_asset.directory, file_asset.name)} does not exists removing"
+            file_asset.destroy
+          end
+        end
+      end
+
+      def get_all_leaves(node)
+        node[:children].map{|child_node| child_node[:leaf] ? child_node : get_all_leaves(child_node) }.flatten
+      end
+
+      def create_file_asset_for_node(node, model)
+        name = File.basename(node[:id])
+        directory = File.dirname(node[:id])
+        file_asset = model.files.find(:first, :conditions => ['directory = ? and name = ?', directory, name])
+
+        if file_asset.nil?
+          contents = get_contents(node[:id]).to_s
+          begin
+            model.add_file(contents, node[:id])
+          rescue Exception=>ex
+            #the file might already exist if it is in the file system.
+          end
+        end
+      end
+
+    end#Manager
+  end#FileSupport
+end#ErpTechSvcs