erp_app 3.0.0 → 3.0.1

data/app/controllers/erp_app/organizer/crm/base_controller.rb

@@ -2,6 +2,9 @@ module ErpApp
 	module Organizer
 		module Crm
 			class BaseController < ErpApp::Organizer::BaseController
+        @@date_format = "%m/%d/%Y"
+        @@datetime_format = "%m/%d/%Y %l:%M%P"
+
 			  def menu
           menu = []
 
@@ -47,6 +50,10 @@ module ErpApp
             params.delete(:action)
             params.delete(:controller)
             params.delete(:party_type)
+            params.delete(:authenticity_token)
+
+            params[:birth_date] = Date.strptime(params[:birth_date], @@date_format) unless params[:birth_date].blank?
+            params[:current_passport_expire_date] = Date.strptime(params[:current_passport_expire_date], @@date_format) unless params[:current_passport_expire_date].blank?
 
             business_party = klass.create(params)
             business_party.party.enterprise_identifier = enterprise_identifier
@@ -60,16 +67,21 @@ module ErpApp
           render :json => result
 			  end
 
-			  private
-
 			  def update_party
+          enterprise_identifier = params[:enterprise_identifier]
           party_type = params[:party_type]
-          business_party_data = params[:data]
-          businesss_party_id = business_party_data['business_party_id']
-          enterprise_identifier = business_party_data[:enterprise_identifier]
+          businesss_party_id = params[:business_party_id]
+          business_party_data = params
           business_party_data.delete(:id)
           business_party_data.delete(:business_party_id)
           business_party_data.delete(:enterprise_identifier)
+          business_party_data.delete(:authenticity_token)
+          business_party_data.delete(:party_type)
+          business_party_data.delete(:controller)
+          business_party_data.delete(:action)
+          puts business_party_data[:birth_date]
+          business_party_data[:birth_date] = Date.strptime(business_party_data[:birth_date], @@date_format) unless business_party_data[:birth_date].blank?
+          business_party_data[:current_passport_expire_date] = Date.strptime(business_party_data[:current_passport_expire_date], @@date_format) unless business_party_data[:current_passport_expire_date].blank?
 
           klass = party_type.constantize
           business_party = klass.find(businesss_party_id)
@@ -88,17 +100,107 @@ module ErpApp
             party.save
           end unless enterprise_identifier.blank?
 
-          {:message => "#{party_type} updated", :data => [{
-                :id => party.id,
-                :enterprise_identifier => party.enterprise_identifier,
-                :created_at => party.created_at,
-                :updated_at => party.updated_at,
-                :business_party => party.business_party
-              }]
-          }.to_json
-
+          render :json => { :success => true,
+                :message => "#{party_type} updated", 
+                :data => [{
+                  :id => party.id,
+                  :enterprise_identifier => party.enterprise_identifier,
+                  :created_at => party.created_at,
+                  :updated_at => party.updated_at,
+                  :business_party => party.business_party
+                }]
+          }
 			  end
 
+        def get_party_details
+          @party = Party.find(params[:id]) rescue nil
+          
+        end
+
+        def get_user
+          party = Party.find(params[:party_id]) rescue nil
+
+          if params[:party_id] and !party.nil?
+            user = party.user
+            if user.nil?
+              success = true
+              message = "User Does Not Exist"
+              u = {
+                :username => '',
+                :email => '',
+                :activation_state => '',
+                :last_login_at => '',
+                :failed_logins_count => '',
+                :activation_token => ''
+              }
+            else
+              success = true
+              message = "User Found"
+
+              last_login_at = user.last_login_at.blank? ? '' : user.last_login_at.getlocal.strftime(@@datetime_format)
+
+              u = {
+                :username => user.username,
+                :email => user.email,
+                :activation_state => user.activation_state,
+                :last_login_at => last_login_at,
+                :failed_logins_count => user.failed_logins_count,
+                :activation_token => user.activation_token
+              }
+            end
+          else
+            success = false
+            message = "Party Not Found"
+            u = {}
+          end
+
+          render :json => { :success => success,
+                            :message => message,
+                            :data => [u] 
+                          }
+        end
+
+        def update_user
+          party = Party.find(params[:party_id]) rescue nil
+
+          if params[:party_id] and !party.nil?
+            user = party.user
+            if user.nil?
+              success = true
+              message = "User Does Not Exist"              
+            else              
+              user.username = params[:username]
+              user.email = params[:email]
+              if user.save
+                success = true
+                message = "User Successfully Updated"
+              else
+                success = false
+                message = 'Update Failed'
+              end
+            end
+          else
+            success = false
+            message = "Party Not Found"
+          end
+
+          render :json => { :success => success, :message => message } and return
+        end
+
+        def activate
+          if @user = User.load_from_activation_token(params[:activation_token])
+            @user.activate!
+            success = true
+            message = 'User was successfully activated.'
+          else
+            success = false
+            message = "Invalid activation token."
+          end
+
+          render :json => { :success => success, :message => message } and return
+        end
+
+        private
 			  def get_parties
           search_name = params[:party_name]
           party_type = params[:party_type]
@@ -169,7 +271,7 @@ module ErpApp
 
           contact_mechanism.save
 
-          contact_mechanism_class.class_eval do
+          contact_type.constantize.class_eval do
             def contact_purpose_id
               self.contact_purpose ? contact_purpose.id : nil
             end

data/app/controllers/erp_app/public_controller.rb

@@ -1,12 +1,79 @@
 module ErpApp
 	class PublicController < ActionController::Base
+    before_filter :set_file_support
 
-	  def download_file
-		path = params[:path]
+    # DEPRECATED, use erp_app/public#download
+    # def download_file
+    #    path = params[:path]
+    #    file_klass = FileAsset.type_by_extension(File.extname(path))
+    #    if file_klass == Image
+    #      send_file path, :type => "image/#{File.extname(path)}"
+    #    else
+    #      send_file path, :type => file_klass.content_type
+    #    end
+	  # end
 
-    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+    # TODO:
+    # test X Send file in apache
+    # reorder menuitems
+    # drag and drop image into ckeditor uses bad (but somehow not broken, i.e. ../../images/) url (filesystem on firefox, chrome OK) 
+
+    # Download Inline Example: /download/filename.ext?path=/directory&disposition=inline
+    # Download Prompt Example: /download/filename.ext?path=/directory&disposition=attachment
+    def download
+      filename = "#{params[:filename]}.#{params[:format]}"
+      disposition = params[:disposition]
+
+      file = FileAsset.where(:name => filename)
+      file = file.where(:directory => params[:path]) unless params[:path].blank?
+      file = file.first
+
+      unless file.nil?
+        if file.has_capabilities?
+          begin
+            unless current_user == false
+              current_user.with_capability(file, :download, nil) do
+                serve_file(file, disposition)
+              end
+            else
+              raise ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability
+            end
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability=>ex
+            render :text => ex.message and return
+          rescue Exception=>ex
+            render :text => "User does not have capability." and return
+          end
+        else
+          serve_file(file, disposition)
+        end
+      else
+        render :text => 'File not found.'
+      end
+    end
+
+    protected
+
+    def serve_file(file, disposition=nil)
+      type = (file.type == 'Image' ? "image/#{params[:format]}" : file.content_type)
+
+      if Rails.application.config.erp_tech_svcs.file_storage == :s3
+        path = File.join(file.directory,file.name).sub(%r{^/},'')
+        options = { :response_content_disposition => disposition }
+        options[:expires] = Rails.application.config.erp_tech_svcs.s3_url_expires_in_seconds if file.has_capabilities?
+        redirect_to @file_support.bucket.objects[path].url_for(:read, options).to_s
+      else
+        # to use X-Sendfile or X-Accel-Redirect, set config.action_dispatch.x_sendfile_header in environment config file
+        if disposition
+          send_file File.join(Rails.root,file.directory,file.name), :type => type, :disposition => disposition
+        else
+          send_file File.join(Rails.root,file.directory,file.name), :type => type
+        end
+      end
+    end
+
+    def set_file_support
+      @file_support = ErpTechSvcs::FileSupport::Base.new(:storage => Rails.application.config.erp_tech_svcs.file_storage)
+    end
 
-		send_file File.join(file_support.root,path), :type=>"text/plain"
-	  end
 	end
-end
+end

data/app/controllers/erp_app/shared/configuration_controller.rb

@@ -0,0 +1,53 @@
+module ErpApp
+	module Shared
+		class ConfigurationController < ErpApp::ApplicationController
+
+      def setup_categories
+        configuration = ::Configuration.find(params[:id])
+        tree_array = [].tap do |array|
+          configuration.item_types.collect{|item| item.category_classification.category}.uniq.each do |category|
+            array << category.to_tree_hash(:only => [], :methods => [{:id => :categoryId}], :icon_cls => 'icon-index')
+          end
+        end
+        render :json => tree_array
+      end
+
+		  def setup
+        category_id = params[:category_id]
+        configuration = ::Configuration.find(params[:id])
+
+        render :json => {:success => true, :configurationItemTypes => configuration.item_types.by_category(Category.find(category_id)).collect(&:to_js_hash)}
+      end
+
+      def load
+        category_id = params[:category_id]
+        configuration = ::Configuration.find(params[:id])
+
+        render :json => {:success => true, :configurationItems => configuration.items.by_category(Category.find(category_id)).collect(&:to_js_hash)}
+      end
+
+      def update
+        configuration = ::Configuration.find(params[:id])
+
+        begin
+          params.each do |k,v|
+            #options can come is a comma delimited strings and may need to be broken apart
+            options = [].tap do |options_array|
+              v.split(',').each do |option|
+                options_array << option
+              end
+            end
+            configuration.update_configuration_item(ConfigurationItemType.find_by_internal_identifier(k), options) unless (k.to_s == 'action' or k.to_s == 'controller' or k.to_s == 'id' or k.to_s == 'authenticity_token')
+          end
+
+          render :json => {:success => true, :configurationItems => configuration.items.collect(&:to_js_hash)}
+        rescue Exception=>ex
+          logger.error(ex.message)
+          logger.error(ex.backtrace)
+          render :json => {:success => false, :message => ex.message}
+        end
+      end
+
+    end#ConfigurationController
+  end#Shared
+end#ErpApp

data/app/controllers/erp_app/widget_proxy_controller.rb

@@ -14,7 +14,7 @@ module ErpApp
 
   		widget_obj = "::Widgets::#{@widget_name.camelize}::Base".constantize.new(self, @widget_name, @widget_action, @uuid, widget_params)
 
-      result = widget_obj.send(@widget_action)
+      result = widget_obj.process(@widget_action)
       result.nil? ? return : (render result)
 		end
     

data/app/models/app_container.rb

@@ -1,11 +1,11 @@
 class AppContainer < ActiveRecord::Base
   has_user_preferences
 
-  belongs_to :user, :dependent => :destroy
+  belongs_to :user
   belongs_to :app_container_record, :polymorphic => true
   has_and_belongs_to_many :applications
 
-  def preferences()
+  def preferences
     self.user_preferences.includes([:preference]).where('user_id = ?', self.user.id).map(&:preference)
   end
 
@@ -20,4 +20,10 @@ class AppContainer < ActiveRecord::Base
   def setup_default_preferences
     #template method
   end
+
+  class << self
+    def find_by_user(user)
+      AppContainer.where('user_id = ?', user.id).first
+    end
+  end
 end

data/app/models/application.rb

@@ -17,7 +17,7 @@ class Application < ActiveRecord::Base
   end
 
   def locate_resources(resource_type)
-    resource_loader = self.resource_loader.constantize.new(self)
+    resource_loader = ErpApp::ApplicationResourceLoader::DesktopOrganizerLoader.new(self)
     resource_loader.locate_resources(resource_type)
   end
   

data/app/models/configuration.rb

@@ -0,0 +1,129 @@
+class Configuration < ActiveRecord::Base
+  scope :templates, where('is_template = ?', true)
+
+  validates :internal_identifier, :presence => true, :uniqueness =>  {:scope => [:id, :is_template]}
+  validates :is_template, :uniqueness => {:scope => :internal_identifier}
+
+  has_many :configuration_items, :dependent => :destroy do
+    def by_category(category)
+      includes({:configuration_item_type => [:category_classification]}).where(:category_classifications => {:category_id => category})
+    end
+
+    def grouped_by_category
+      group_by(&:category)
+    end
+  end
+  has_and_belongs_to_many :configuration_item_types, :uniq => true do
+    def by_category(category)
+      includes(:category_classification).where(:category_classifications => {:category_id => category})
+    end
+
+    def grouped_by_category
+      group_by(&:category)
+    end
+  end
+  
+  alias :items :configuration_items
+  alias :item_types :configuration_item_types
+
+  def is_template?
+    self.is_template
+  end
+
+  def add_configuration_item(configuration_item_type, *option_internal_identifiers)
+    item = get_configuration_item(configuration_item_type)
+    if item
+      update_configuration_item(configuration_item_type, option_internal_identifiers)
+    else
+      unless self.configuration_item_types.where("id = ?", configuration_item_type.id).first.nil?
+        item = ConfigurationItem.create(:configuration_item_type => configuration_item_type)
+        item.set_options(option_internal_identifiers)
+        self.configuration_items << item
+        self.save
+      else
+        raise "Configuration Item Type #{configuration_item_type.description} is not valid for this configuration"
+      end
+    end
+  end
+
+  alias :add_item :add_configuration_item
+
+  def update_configuration_item(configuration_item_type, *option_internal_identifiers)
+    item = self.items.where('configuration_item_type_id = ?', configuration_item_type.id).first
+    raise "Configuration item #{configuration_item_type.description} does not exist for configuration #{self.description}" if item.nil?
+
+    item.clear_options
+    item.set_options(option_internal_identifiers.flatten)
+  end
+
+  alias :update_item :update_configuration_item
+
+  def get_configuration_item(configuration_item_type)
+    self.items.where('configuration_item_type_id = ?', configuration_item_type.id).first
+  end
+
+  alias :get_item :get_configuration_item
+
+  #Clone
+  #
+  #Will copy all configuration item types
+  #
+  # * *Args*
+  #   - +set_defaults+ -> create items and set default options default = true
+  # * *Returns* :
+  #   - the cloned configuration
+  def clone(set_defaults=true)
+    configuration_dup = self.dup
+    configuration_dup.internal_identifier = "#{self.internal_identifier} clone"
+    configuration_dup.description = "#{self.description} clone"
+    configuration_dup.is_template = false
+
+    self.configuration_item_types.each do |configuration_item_type|
+      configuration_dup.configuration_item_types << configuration_item_type
+    end
+    configuration_dup.save
+
+    configuration_dup.configuration_item_types.each do |configuration_item_type|
+      configuration_item = ConfigurationItem.create(:configuration_item_type => configuration_item_type)
+      configuration_item.configuration_options = configuration_item_type.options.default if set_defaults
+      configuration_item.save
+      configuration_dup.configuration_items << configuration_item
+    end
+    configuration_dup.save
+    
+    configuration_dup
+  end
+
+  #Copy
+  #
+  #Will copy all configuration item types and items
+  #
+  # * *Returns* :
+  #   - the copied configuration
+  def copy
+    configuration_dup = self.clone
+    configuration_dup.internal_identifier = "#{self.internal_identifier} copy"
+    configuration_dup.description = "#{self.description} copy"
+
+    #clone items
+    self.configuration_items.each do |item|
+      item_dup = item.dup
+      item_dup.configuration_item_type = item.configuration_item_type
+      item.configuration_options.each do |option|
+        item_dup.configuration_options << option
+      end
+      item_dup.save
+      configuration_dup.configuration_items << item_dup
+    end
+
+    configuration_dup.save
+    configuration_dup
+  end
+
+  class << self
+    def find_template(iid)
+      self.templates.where('internal_identifier = ?', iid).first
+    end
+  end
+
+end

data/app/models/configuration_item.rb

@@ -0,0 +1,45 @@
+class ConfigurationItem < ActiveRecord::Base
+  belongs_to :configuration
+  belongs_to :configuration_item_type
+  has_and_belongs_to_many :configuration_options
+
+  alias :config :configuration
+  alias :options :configuration_options
+  alias :type :configuration_item_type
+
+  def category
+    self.type.category
+  end
+
+  def to_js_hash
+    {:id => self.id,
+      :configruationItemType => self.type.to_js_hash,
+      :configurationOptions => options.collect(&:to_js_hash)
+    }
+  end
+
+  def clear_options
+    self.options.each{|option|option.destroy} if self.configuration_item_type.allow_user_defined_options?
+    self.options.destroy_all
+    self.save
+  end
+
+  def set_options(internal_identifiers_or_value)
+    if self.configuration_item_type.allow_user_defined_options?
+      value = internal_identifiers_or_value.first
+      unless value.blank?
+        option = ConfigurationOption.find_by_value_and_user_defined(value, true)
+        self.options << (option ? option : ConfigurationOption.create(:value => value, :user_defined => true))
+      end
+    elsif self.configuration_item_type.is_multi_optional?
+      internal_identifiers_or_value.each do |value|
+        self.options << self.configuration_item_type.find_configuration_option(value) unless value.blank?
+      end
+    else
+      value = internal_identifiers_or_value.first
+      self.options << self.configuration_item_type.find_configuration_option(internal_identifiers_or_value) unless value.blank?
+    end
+
+    self.save
+  end
+end

data/app/models/configuration_item_type.rb

@@ -0,0 +1,96 @@
+class ConfigurationItemType < ActiveRecord::Base
+  validates :internal_identifier, :uniqueness => true
+
+  has_and_belongs_to_many :configuration_options, :uniq => true do
+    def default
+      where('is_default = ?', true)
+    end
+
+    def non_default
+      where('is_default = ?', false)
+    end
+  end
+  has_many :configuration_items, :dependent => :destroy
+  has_one :category_classification, :as => :classification, :dependent => :destroy
+
+  def category
+    self.category_classification.category unless self.category_classification.nil?
+  end
+
+  alias :options :configuration_options
+
+  def add_default_configuration_option(option)
+    self.clear_options if self.allow_user_defined_options?
+    
+    #if this is not multi_optional clear out any default options set
+    unless self.is_multi_optional?
+      ConfigurationItemTypeConfigurationOption.where('configuration_item_type_id = ?', self.id).each do |configuration_item_type_configuration_option|
+        configuration_item_type_configuration_option.is_default = false
+      configuration_item_type_configuration_option.save
+      end
+    end
+
+    existing_option = self.configuration_options.where(:id => option.id).first
+    if existing_option.nil?
+      ConfigurationItemTypeConfigurationOption.create(:configuration_item_type => self, :configuration_option => option, :is_default => true)
+    else
+      configuration_item_type_configuration_option = ConfigurationItemTypeConfigurationOption.where('configuration_option_id = ? and configuration_item_type_id = ?', existing_option.id, self.id).first
+      configuration_item_type_configuration_option.is_default = true
+      configuration_item_type_configuration_option.save
+    end
+  end
+
+  alias :add_default_option :add_default_configuration_option
+
+  def add_configuration_option(option)
+    self.clear_options if self.allow_user_defined_options?
+    
+    existing_option = self.configuration_options.where(:id => option.id).first
+    if existing_option.nil?
+      self.options << option
+    end
+  end
+
+  alias :add_option :add_configuration_option
+
+  def remove_configuration_option(option)
+    existing_option = self.configuration_options.where(:id => option.id).first
+    unless existing_option.nil?
+      self.configuration_options.delete(option)
+    end
+  end
+
+  alias :remove_option :remove_configuration_option
+
+  def is_multi_optional?
+    self.is_multi_optional
+  end
+
+  def allow_user_defined_options?
+    self.allow_user_defined_options
+  end
+
+  def find_configuration_option(internal_identifier, type=:internal_identifier)
+    option = self.options.where("#{type.to_s} = ?", internal_identifier).first
+    raise "Option #{internal_identifier} does not exist for configuration item type #{self.description}" if option.nil?
+    option
+  end
+
+  def clear_options
+    self.options.each{|option|option.destroy} if self.allow_user_defined_options?
+    self.options.destroy_all
+    self.save
+  end
+
+  def to_js_hash
+    {:id => self.id,
+      :description => self.description,
+      :internalIdentifier => self.internal_identifier,
+      :configurationOptions => configuration_options.collect(&:to_js_hash),
+      :defaultOptions => self.options.default.collect(&:to_js_hash),
+      :isMultiOptional => self.is_multi_optional,
+      :allowUserDefinedOptions => self.allow_user_defined_options
+    }
+  end
+
+end

data/app/models/configuration_item_type_configuration_option.rb

@@ -0,0 +1,10 @@
+class ConfigurationItemTypeConfigurationOption < ActiveRecord::Base
+  self.table_name = 'configuration_item_types_configuration_options'
+
+  belongs_to :configuration_item_type
+  belongs_to :configuration_option
+
+  def is_default?
+    is_default
+  end
+end

data/app/models/configuration_option.rb

@@ -0,0 +1,20 @@
+class ConfigurationOption < ActiveRecord::Base
+  validates :internal_identifier, :uniqueness => {:scope => :id}
+
+  has_and_belongs_to_many :configuration_item_types
+  has_and_belongs_to_many :configuration_items
+
+  validates :value, :presence => {:message => 'Value can not be blank.'}
+
+  def to_js_hash
+    {
+      :id => self.id,
+      :value => self.value,
+      :description => self.description,
+      :internalIdentifier => self.internal_identifier,
+      :comment => self.comment,
+      :createdAt => self.created_at,
+      :updatedAt => self.updated_at
+    }
+  end
+end