erp_tech_svcs 3.0.0

data/lib/erp_tech_svcs/file_support/paperclip_patch.rb

@@ -0,0 +1,28 @@
+module Paperclip
+  module Storage
+    module S3
+      def flush_writes #:nodoc:
+        @queued_for_write.each do |style, file|
+          begin
+            log("saving #{path(style)}")
+            AWS::S3::S3Object.store(path(style),
+              file,
+              bucket_name,
+              {:content_type => content_type,
+                :access => (@s3_permissions[style] || @s3_permissions[:default]),
+              }.merge(@s3_headers))
+          rescue AWS::S3::NoSuchBucket => e
+            create_bucket
+            retry
+          rescue AWS::S3::ResponseError => e
+            raise
+          end
+        end
+
+        after_flush_writes # allows attachment to clean up temp files
+
+        @queued_for_write = {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module ActionView
+  class S3Resolver < PathResolver
+    def initialize(path, pattern=nil)
+      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
+      super(pattern)
+      @path = path
+    end
+
+    def to_s
+      @path.to_s
+    end
+    alias :to_path :to_s
+
+    def eql?(resolver)
+      self.class.equal?(resolver.class) && to_path == resolver.to_path
+    end
+    alias :== :eql?
+
+    def cached(key, path_info, details, locals) #:nodoc:
+      file_support = ErpTechSvcs::FileSupport::Base.new(:storage => :s3)
+      name, prefix, partial = path_info
+      locals = sort_locals(locals)
+
+      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|
+            last_update = mtime(template.identifier, file_support)
+            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?), file_support, template.locals)
+            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
+
+    def query(path, details, formats)
+      file_support = ErpTechSvcs::FileSupport::Base.new(:storage => :s3)
+      templates = []
+      get_dir_entries(path, file_support).each{|p|templates << build_template(p, path.virtual, formats, file_support)}
+      templates
+    end
+
+    def get_dir_entries(path, file_support)
+      full_path = File.join(@path, path)
+      node = file_support.find_node(File.dirname(full_path))
+      node.nil? ? [] : node[:children].select{|child| child[:leaf]}.collect{|child| child[:id]}.select{|p|!p.scan(full_path).empty?}
+    end
+
+    def mtime(p, file_support)
+      node = file_support.find_node(p)
+      node[:last_modified]
+    end
+
+    protected
+
+    def build_template(p, virtual_path, formats, file_support, locals=nil)
+      handler, format = extract_handler_and_format(p, formats)
+      contents, message = file_support.get_contents(p)
+      Template.new(contents, p, handler, :virtual_path => virtual_path, :format => format, :updated_at => mtime(p, file_support), :locals => locals)
+    end
+  end
+end

data/lib/erp_tech_svcs/file_support/s3_manager.rb

@@ -0,0 +1,211 @@
+require 'yaml'
+require 'aws/s3'
+
+module ErpTechSvcs
+  module FileSupport
+    class S3Manager < Manager
+      class << self
+        cattr_accessor :node_tree
+
+        def setup_connection
+          @@configuration = YAML::load_file(File.join(Rails.root,'config','s3.yml'))[Rails.env]
+
+          AWS::S3::Base.establish_connection!(
+            :access_key_id     => @@configuration['access_key_id'],
+            :secret_access_key => @@configuration['secret_access_key']
+          )
+
+          @@s3_bucket = AWS::S3::Bucket.find(@@configuration['bucket'])
+          @@node_tree = build_node_tree
+        end
+
+        def reload
+          AWS::S3::Base.connected? ? (@@node_tree = build_node_tree(true)) : setup_connection
+        end
+
+        def build_node_tree(reload=false)
+          tree_data = [{:text => @@s3_bucket.name, :leaf => false, :id => '', :children => []}]
+          objects = reload ? @@s3_bucket.objects(:reload) : @@s3_bucket.objects()
+
+
+          nesting_depth = objects.collect{|object| object.key.split('/').count}.max
+          unless nesting_depth.nil?
+            levels = []
+            (1..nesting_depth).each do |i|
+              current_items = []
+              objects_this_depth = objects.collect{|object|
+                text = object.key.split('/')[i - 1]
+                path ='/' + (object.key.split('/')[0..(i-1)].join('/'))
+                if object.key.split('/').count >= i && current_items.select{|item| item[:text] == text and item[:path] == path}.empty?
+                  item_hash = {:text => text, :path => path, :last_modified => object.last_modified}
+                  current_items << item_hash
+                  item_hash
+                end
+              }
+              objects_this_depth.delete_if{|item| (item.nil? or item[:text].nil?)}
+              levels << objects_this_depth
+            end
+
+            old_parents = []
+            new_parents = [tree_data[0]]
+            levels.each do |level|
+              old_parents = new_parents
+              new_parents = []
+              level.each do |item|
+                parent = old_parents.count == 1 ? old_parents.first : self.find_parent(item, old_parents)
+                path = File.join(parent[:id], item[:text])
+                child_hash = {:last_modified => item[:last_modified], :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
+
+          tree_data
+        end
+      end
+
+      def buckets
+        AWS::S3::Service.buckets
+      end
+
+      def bucket=(name)
+        @@s3_bucket = AWS::S3::Bucket.find(name)
+      end
+
+      def bucket
+        @@s3_bucket
+      end
+
+      def root
+        ''
+      end
+
+      def update_file(path, content)
+        AWS::S3::S3Object.store(path, content, bucket.name, :access => :public_read)
+      end
+
+      def create_file(path, name, contents)
+        AWS::S3::S3Object.store(File.join(path,name), contents, @@s3_bucket.name, :access => :public_read)
+      end
+
+      def create_folder(path, name)
+        AWS::S3::S3Object.store(File.join(path,name) + "/", '', @@s3_bucket.name, :access => :public_read)
+      end
+
+      def save_move(path, new_parent_path)
+        result = nil
+        unless self.exists? path
+          message = 'File does not exists'
+        else
+          name = File.basename(path)
+          if AWS::S3::S3Object.rename path, File.join(new_parent_path,name), @@s3_bucket.name, :copy_acl => true
+            message = "#{name} was moved to #{new_parent_path} successfully"
+            result = true
+          else
+            message = "#Error renaming {old_name}"
+          end
+        end
+
+        return result, message
+      end
+
+      def rename_file(path, name)
+        result = nil
+        old_name = File.basename(path)
+        path_pieces = path.split('/')
+        path_pieces.delete(path_pieces.last)
+        path_pieces.push(name)
+        new_path = path_pieces.join('/')
+        if AWS::S3::S3Object.rename path, new_path, @@s3_bucket.name, :copy_acl => true
+          message = "#{old_name} was renamed to #{name} successfully"
+          result = true
+        else
+          message = "#Error renaming {old_name}"
+        end
+
+        return result, message
+      end
+
+      def delete_file(path, options={})
+        result = nil
+        message = nil
+
+        node = find_node(path)
+
+        if node[:children].empty?
+          is_directory = !node[:leaf]
+          path << '/' unless node[:leaf]
+          result = AWS::S3::S3Object.delete path, @@s3_bucket.name, :force => true
+          message = "File was deleted successfully"
+          result = true
+        elsif options[:force]
+          node[:children].each do |child|
+            delete_file(child[:id], options)
+          end
+        else
+          message = "Folder is not empty"
+        end unless node.nil?
+
+        return result, message, is_directory
+      end
+
+      def exists?(path)
+        begin
+          path = path[1..path.length] if path.first == '/'
+          !AWS::S3::S3Object.find(path, @@s3_bucket.name).nil?
+        rescue AWS::S3::NoSuchKey
+          return false
+        end
+      end
+
+      def get_contents(path)
+        contents = nil
+        message = nil
+
+        path = path[1..path.length]
+        begin
+          object = AWS::S3::S3Object.find path, @@s3_bucket.name
+        rescue AWS::S3::NoSuchKey => error
+          message = 'File does not exists'
+        end
+
+        contents = object.value.to_s if message.nil?
+
+        return contents, message
+      end
+
+      def build_tree(starting_path, options={})
+        ErpTechSvcs::FileSupport::S3Manager.reload
+        node_tree = find_node(starting_path, options)
+        node_tree.nil? ? [] : node_tree
+      end
+
+      def find_node(path, options={})
+        parent = if options[:file_asset_holder]
+          super
+        else
+          parent = @@node_tree.first
+          unless path.nil?
+            path_pieces = path.split('/')
+            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
+            parent = nil if parent[:id] != path
+          end
+
+          parent
+        end
+
+        parent
+      end
+
+    end#S3Manager
+  end#FileSupport
+end#ErpTechSvcs

data/lib/erp_tech_svcs/file_support.rb

@@ -0,0 +1,10 @@
+require 'erp_tech_svcs/file_support/base'
+require 'erp_tech_svcs/file_support/manager'
+require 'erp_tech_svcs/file_support/file_system_manager'
+require 'erp_tech_svcs/file_support/s3_manager'
+require 'erp_tech_svcs/file_support/aws_s3_patch'
+require 'erp_tech_svcs/file_support/paperclip_patch'
+require 'erp_tech_svcs/file_support/file_manipulator'
+
+#path resolvers
+require 'erp_tech_svcs/file_support/railties/s3_resolver'

data/lib/erp_tech_svcs/sessions/delete_expired_sessions_job.rb

@@ -0,0 +1,40 @@
+module ErpTechSvcs
+  module Sessions
+    # Delayed Job to Reset Daily Assignments to Forecast
+    class DeleteExpiredSessionsJob  
+
+      def initialize
+        @priority = 1
+      end
+  
+      def perform
+        begin
+          process_job
+        rescue => exception
+          ErpTechSvcs::Util::CompassLogger.delete_expired_sessions_job.error("An unrecoverable error has occured, the job will be rescheduled: #{exception.message} : #{exception.backtrace}")
+        end
+    
+        # Run once per day
+        date = Date.tomorrow
+        start_time = DateTime.civil(date.year, date.month, date.day, 2, 0, 1, -(5.0/24.0))
+    
+        Delayed::Job.enqueue(DeleteExpiredSessionsJob.new(), @priority, start_time)
+      end
+
+      def self.schedule_job(schedule_dt)
+        Delayed::Job.enqueue(DeleteExpiredSessionsJob.new(), @priority, schedule_dt)
+      end
+
+      def process_job
+        start_time = Time.now
+    
+        ErpTechSvcs::Sessions::DeleteExpiredSessionsService.new.execute
+    
+        end_time = Time.now
+    
+        return end_time - start_time
+      end
+  
+    end #Close DeleteExpiredSessionsJob
+  end #Close Sessions
+end #Close ErpTechSvcs

data/lib/erp_tech_svcs/sessions/delete_expired_sessions_service.rb

@@ -0,0 +1,15 @@
+module ErpTechSvcs
+  module Sessions
+    class DeleteExpiredSessionsService
+
+      def initialize
+        @session_age = 12.hours
+      end
+    
+      def execute
+        ActiveRecord::SessionStore::Session.delete_all ['updated_at < ?', @session_age.ago] 
+      end
+    
+    end
+  end
+end

data/lib/erp_tech_svcs/utils/attachment_fu_patch.rb

@@ -0,0 +1,15 @@
+#This patch is to make the attachment_fu plugin work on Windows
+#It is not necessary for 'nix operating systems, though it is not known
+#to cause problems
+require 'tempfile'
+	class Tempfile
+		def size
+			if @tmpfile
+				@tmpfile.fsync # added this line
+				@tmpfile.flush
+				@tmpfile.stat.size
+			else
+				0
+		end
+	end
+end

data/lib/erp_tech_svcs/utils/compass_access_negotiator.rb

@@ -0,0 +1,57 @@
+module ErpTechSvcs
+  module Utils
+    module CompassAccessNegotiator
+
+      def has_capability?(model, capability_type, resource)
+        model.user_has_capability?(capability_type.to_s, resource, self)
+      end
+
+      def with_capability(model, capability_type, resource, &block)
+        if model.user_has_capability?(capability_type.to_s, resource, self)
+          yield
+        else
+          raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability
+        end
+      end
+
+      def has_access_to_widget?(widget)
+        widget.has_access?(self)
+      end
+
+      def valid_widgets(application)
+        widgets = []
+        application.widgets.each do |widget|
+          widgets << widget if self.has_access_to_widget?(widget)
+        end
+        widgets
+      end
+      
+      module Errors
+        class CapabilityDoesNotExist < StandardError 
+          def to_s
+            "Capability does not exist."
+          end
+        end
+
+         class CapabilityTypeDoesNotExist < StandardError
+          def to_s
+            "Capability type not exist."
+          end
+        end
+
+        class CapabilityAlreadytExists < StandardError
+          def to_s
+            "Capability already exists."
+          end
+        end
+
+        class UserDoesNotHaveCapability < StandardError
+          def to_s
+            "User does not have capability."
+          end
+        end
+      end
+      
+    end#CompassAccessNegotiator
+  end#Utils
+end#ErpTechSvcs

data/lib/erp_tech_svcs/utils/compass_logger.rb

@@ -0,0 +1,94 @@
+require 'logger'
+module ErpTechSvcs
+  module Util
+    class CompassLogger
+      include Singleton
+
+      @@writers = {}
+
+      def CompassLogger.debug(msg)
+        if defined?(logger)
+          logger.debug(msg)
+        else
+          CompassLogger.app_logger()
+          @@writers["app_logger"].debug(msg)
+        end
+      end
+  
+      def CompassLogger.info(msg)
+        if defined?(logger)
+          logger.info(msg)
+        else
+          CompassLogger.app_logger()
+          @@writers["app_logger"].info(msg)
+        end
+      end
+
+      def CompassLogger.warn(msg)
+        if defined?(logger)
+          logger.warn(msg)
+        else
+          CompassLogger.app_logger()
+          @@writers["app_logger"].warn(msg)
+        end
+      end
+
+      def CompassLogger.error(msg)
+        if defined?(logger)
+          logger.error(msg)
+        else
+          CompassLogger.app_logger()
+          @@writers["app_logger"].error(msg)
+        end
+      end
+
+      def CompassLogger.fatal(msg)
+        if defined?(logger)
+          logger.fatal(msg)
+        else
+          CompassLogger.app_logger()
+          @@writers["app_logger"].fatal(msg)
+        end
+      end
+
+      def CompassLogger.stdout(msg)
+        if CompassLogger.log_level() == 0
+          puts msg
+        end
+      end
+  
+      def CompassLogger.method_missing(method, *args, &block)
+        unless @@writers.has_key?(method)
+          logger = Logger.new(CompassLogger.log_path(method))
+          logger.level = CompassLogger.log_level()
+          @@writers[method] = logger
+        end
+        @@writers[method]
+      end
+
+      def CompassLogger.app_logger()
+        path = "#{Rails.root}/log/#{Rails.env rescue 'rake'}.log"
+        unless RUBY_PLATFORM =~ /(:?mswin|mingw|darwin)/
+          path = "/var/log/rails/#{Rails.env rescue 'rake'}.log"
+        end
+        unless @@writers.has_key?("app_logger")
+          logger = Logger.new(path)
+          logger.level = CompassLogger.log_level()
+          @@writers["app_logger"] = logger
+        end
+      end
+
+      def CompassLogger.log_level()
+        ActiveRecord::Base.logger.level rescue Logger::DEBUG
+      end
+
+      def CompassLogger.log_path(method)
+        if RUBY_PLATFORM =~ /(:?mswin|mingw|darwin)/
+         return "#{Rails.root}/log/#{Rails.env rescue ''}_#{method}.log"
+       else
+         return "/var/log/rails/#{Rails.env rescue ''}_#{method}.log"
+       end
+      end
+    end
+  end
+end

data/lib/erp_tech_svcs/utils/compass_pdf.rb

@@ -0,0 +1,72 @@
+module CompassPDF
+
+  class PDFXLate
+
+    # pdf xlator utility
+    attr_accessor :pdf_util
+
+    # options to the pdf xlator
+    attr_accessor :util_options
+
+    # temp file that contains the html to be xlated
+    attr_accessor :html_filename
+
+    # output option
+    attr_accessor :pdf_out_option
+
+    # pdf file generated
+    attr_accessor :pdf_filename
+
+    # shell command/s to invoke the xlation process and return the results
+    attr_accessor :command
+
+    def initialize(options={})
+      # lets default to using prince, we're big spenders
+      #options = {:pdf_util => "#{PDF_COMMAND}",:util_options => '--input=html --media=screen --baseurl=http://localhost:3000', :pdf_out_option => '-o '}.merge(options)
+
+      # lets use wkhtmltopdf, we're cheap
+      #options = {:pdf_util => "#{PDF_COMMAND}",:util_options => '', :pdf_out_option => ""}.merge(options)
+      options.each{ |k,v| self.send("#{k}=".to_sym, v)  }
+    end
+
+    def command
+      # TODO: send this to a background process to do the xlate
+      # TODO: add timeout
+      # Could bog down the rails process
+#      cmd = "#{@pdf_util} #{@util_options} #{self.html_filename} -o #{self.pdf_out} &>/dev/null;"
+      cmd = "#{@pdf_util} #{@util_options} #{self.html_filename} #{self.pdf_out_option} #{pdf_filename}"
+#      cmd << "cat #{self.pdf_filename}"
+    end
+
+    def html_filename=(file_name)
+      @fname = file_name
+    end
+
+    def html_filename
+      @fname ||= "tmp/html_output_#{Digest::MD5.hexdigest(Time.now.to_i.to_s)}.html"    
+    end
+
+    def pdf_filename
+      html_filename.sub(/\.html/, '.pdf') 
+    end
+
+    def write_html_response(body)
+      File.open("#{html_filename}", "w") { |f| f.puts(body) }
+    end
+
+    def get_pdf_generated
+      pdf_contents = nil
+      File.open("#{pdf_filename}",'rb') do |f|
+        pdf_contents = f.read
+      end
+      pdf_contents
+    end
+
+    def invoke
+      puts "invoking command #{self.command}"
+      `#{self.command}`
+      #TODO: cleanup temp files, etc.
+    end
+  end
+
+end

data/lib/erp_tech_svcs/utils/default_nested_set_methods.rb

@@ -0,0 +1,33 @@
+module ErpTechSvcs
+	module Utils
+		module DefaultNestedSetMethods
+			def self.included(base)
+				base.extend(ClassMethods)
+			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
+
+			module ClassMethods
+				def find_roots
+					where("parent_id = nil")
+				end
+
+				def find_children(parent_id = nil)
+					parent_id.to_i == 0 ? self.roots : find(parent_id).children
+				end
+			end
+		end
+	end
+end
+