erp_app 3.0.0

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

@@ -0,0 +1,49 @@
+module ErpApp
+  module Organizer
+    module Crm
+      class RelationshipController < ErpApp::Organizer::BaseController
+
+
+        #RESTful controller for party relationship
+        #data
+        def index
+
+          render :inline => if request.get?
+            get_party_relationships
+          end
+        end
+
+        # This method returns all party relationships
+        # that involve the params[:party_id] and the passed in
+        # relationship type.  Use this when you just need generic
+        # information about a relationship passed back.
+        # Formats into a hash for consumption by an
+        # ExtJS GridPanel
+        #
+        def get_party_relationships
+          party = Party.find(params[:party_id])
+          relationships = party.find_relationships_by_type(params[:relationship_type])
+
+          total_count = relationships.length
+
+          {:totalCount => total_count,
+            :data => relationships.collect do |relation|
+              related_party = relation.to_party
+              {
+                :party_id => related_party.id,
+                :party_desc => related_party.description,
+                :relationship => relation.description,
+                :created_at => relation.created_at,
+                :updated_at => relation.updated_at,
+                :from_date => relation.from_date,
+                :thru_date => relation.thru_date,
+                :role_type => relation.to_role
+              }
+            end
+          }.to_json
+        end
+      end
+    end
+  end
+end
+

data/app/controllers/erp_app/public_controller.rb

@@ -0,0 +1,12 @@
+module ErpApp
+	class PublicController < ActionController::Base
+
+	  def download_file
+		path = params[:path]
+
+    file_support = ErpTechSvcs::FileSupport::Base.new(:storage => ErpTechSvcs::FileSupport.options[:storage])
+
+		send_file File.join(file_support.root,path), :type=>"text/plain"
+	  end
+	end
+end

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

@@ -0,0 +1,53 @@
+module ErpApp
+	module Shared
+		class Shared::NotesController < ErpApp::ApplicationController
+
+		  def view
+        if params[:party_id].to_i == 0
+          render :json => {:totalCount => 0, :notes => []}
+        else
+          sort_hash = params[:sort].blank? ? {} : Hash.symbolize_keys(JSON.parse(params[:sort]).first)
+          limit = params[:limit] || 30
+          start = params[:start] || 0
+
+          sort = sort_hash[:property] || 'created_at'
+          dir  = sort_hash[:direction] || 'DESC'
+
+          Note.include_root_in_json = false
+			
+          party = Party.find(params[:party_id])
+          notes = party.notes.order("#{sort} #{dir}").limit(limit).offset(start)
+			
+          render :inline => "{\"totalCount\":#{party.notes.count}, \"notes\":#{notes.to_json(:only => [:id, :content, :created_at], :methods => [:summary, :note_type_desc, :created_by_username])}}"
+        end
+		  end
+
+		  def create
+        content  = params[:content]
+        note_type = NoteType.find(params[:note_type_id])
+        party = Party.find(params[:party_id])
+
+        note = Note.create(
+          :note_type => note_type,
+          :content => content,
+          :created_by_id => current_user.party.id
+        )
+
+        party.notes << note
+        party.save
+
+        render :json => {:success => true}
+		  end
+
+		  def delete
+        Note.find(params[:id]).destroy ? (render :json => {:success => true}) : (render :json => {:success => false})
+		  end
+
+		  def note_types
+        NoteType.include_root_in_json = false
+
+        render :json => {:note_types => NoteType.all}
+		  end
+		end
+	end
+end

data/app/controllers/erp_app/widget_proxy_controller.rb

@@ -0,0 +1,22 @@
+module ErpApp
+	class WidgetProxyController < ErpApp::ApplicationController
+	  
+    attr_accessor :performed_redirect
+
+	  def index
+		  @widget_name   = params[:widget_name]
+  		@widget_action = params[:widget_action]
+  		@uuid          = params[:uuid]
+
+  		#get widget params
+  		widget_params = nil
+  		widget_params = JSON.parse(params[:widget_params]) unless params[:widget_params].blank?
+
+  		widget_obj = "::Widgets::#{@widget_name.camelize}::Base".constantize.new(self, @widget_name, @widget_action, @uuid, widget_params)
+
+      result = widget_obj.send(@widget_action)
+      result.nil? ? return : (render result)
+		end
+    
+	end
+end

data/app/helpers/erp_app/application_helper.rb

@@ -0,0 +1,4 @@
+module ErpApp
+  module ApplicationHelper
+  end
+end

data/app/models/app_container.rb

@@ -0,0 +1,23 @@
+class AppContainer < ActiveRecord::Base
+  has_user_preferences
+
+  belongs_to :user, :dependent => :destroy
+  belongs_to :app_container_record, :polymorphic => true
+  has_and_belongs_to_many :applications
+
+  def preferences()
+    self.user_preferences.includes([:preference]).where('user_id = ?', self.user.id).map(&:preference)
+  end
+
+  def get_preference(preference_type_iid)
+    get_user_preference(self.user, preference_type_iid)
+  end
+
+  def set_preference(preference_type_iid, preference_option_iid)
+    set_user_preference(self.user, preference_type_iid, preference_option_iid)
+  end
+
+  def setup_default_preferences
+    #template method
+  end
+end

data/app/models/application.rb

@@ -0,0 +1,24 @@
+class Application < ActiveRecord::Base
+  has_capabilities
+  has_user_preferences
+
+  has_and_belongs_to_many :app_containers
+  has_and_belongs_to_many :widgets
+
+  validates_uniqueness_of :javascript_class_name
+  validates_uniqueness_of :internal_identifier, :scope => :type
+
+  def to_access_hash
+    {
+      :iid => self.internal_identifier,
+      :capabilities => self.capabilites_to_hash,
+      :widgets => widgets.collect{|widget| widget.to_access_hash}
+    }
+  end
+
+  def locate_resources(resource_type)
+    resource_loader = self.resource_loader.constantize.new(self)
+    resource_loader.locate_resources(resource_type)
+  end
+  
+end

data/app/models/desktop.rb

@@ -0,0 +1,89 @@
+class Desktop < ActiveRecord::Base
+  acts_as_app_container
+
+  BACKGROUND_IMAGES_PATH = "#{Rails.root}/public/images/wallpaper"
+
+  def shortcuts
+    self.applications.select{|app| app.get_user_preference(self.user, :desktop_shortcut) === 'yes'}
+  end
+
+  def autoloads
+    self.applications.select{|app| app.get_user_preference(self.user, :autoload_application) === 'yes'}
+  end
+
+  def setup_default_preferences
+    #setup desktop background
+    desktop_backgroud_pt = PreferenceType.iid('desktop_background')
+    desktop_backgroud_pt.preferenced_records << self
+    desktop_backgroud_pt.save
+
+    pref = Preference.create(
+      :preference_type => desktop_backgroud_pt,
+      :preference_option => PreferenceOption.iid('portablemind_desktop_background')
+    )
+
+    self.user_preferences << UserPreference.create(
+      :user => self.user,
+      :preference => pref
+    )
+
+    #setup theme
+    theme_pt = PreferenceType.iid('extjs_theme')
+    theme_pt.preferenced_records << self
+    theme_pt.save
+
+    pref = Preference.create(
+      :preference_type => theme_pt,
+      :preference_option => PreferenceOption.iid('blue_extjs_theme')
+    )
+
+    self.user_preferences << UserPreference.create(
+      :user => self.user,
+      :preference => pref
+    )
+    
+    self.save
+  end
+
+  class << self
+    def add_background(description, image_data)
+      result = {:success => true, :msg => nil}
+      name = image_data.original_filename
+      #make sure this is an image
+      if name =~ /^.?[^\.]+\.(jpe?g|png|gif|tiff)$/
+        #check to make sure this description is not already being used
+        if PreferenceOption.iid(description.gsub(' ','').underscore + '_desktop_background').nil?
+          #check the file does not already exist
+          unless File.exists? File.join(BACKGROUND_IMAGES_PATH,name)
+            if image_data.respond_to?(:read)
+              contents = image_data.read
+            elsif image_data.respond_to?(:path)
+              contents = File.read(image_data.path)
+            end
+            FileUtils.mkdir_p(BACKGROUND_IMAGES_PATH) unless File.directory? BACKGROUND_IMAGES_PATH 
+            File.open(File.join(BACKGROUND_IMAGES_PATH,name), 'wb'){|f| f.puts(contents)}
+            pref_type = PreferenceType.iid('desktop_background')
+            pref_type.preference_options << PreferenceOption.create(:description => description, :internal_identifier => (description.gsub(' ','').underscore + '_desktop_background'), :value => name)
+            pref_type.save
+          else
+            result[:success] = false
+            result[:msg] = 'Image file already exists'
+          end
+        else
+          result[:success] = false
+          result[:msg] = 'Description already used'
+        end
+      else
+        result[:success] = false
+        result[:msg] = 'Invalid file type. Must be an image'
+      end
+
+      result
+    end
+
+    def find_by_user(user)
+      find_by_user_and_klass(user, Desktop)
+    end
+  end
+  
+end

data/app/models/desktop_application.rb

@@ -0,0 +1,2 @@
+class DesktopApplication < Application
+end

data/app/models/extensions/note_type.rb

@@ -0,0 +1,5 @@
+::NoteType.class_eval do
+  has_many_polymorphic :valid_note_type_records,
+                       :through => :valid_note_types,
+                       :models => [:applications]
+end

data/app/models/extensions/party.rb

@@ -0,0 +1,39 @@
+Party.class_eval do
+
+  #************************************************************************************************
+  #** relationship Methods
+  #************************************************************************************************
+
+
+  # Gathers all party relationships that contain this particular party id
+  # on the from side
+  def relationships
+    @relationships ||= PartyRelationship.where('party_id_from = ?', id)
+  end
+
+  # Creates a new PartyRelationship for this particular
+  # party instance.
+  def create_relationship(description, to_party_id)
+    PartyRelationship.create(:description => description, :party_id_from => id, :party_id_to => to_party_id)
+  end
+
+
+  # Get only the relationships this party is involved in with the
+  # passed in internal_identifier.
+  # TODO: Move all this to SQL
+  def find_relationships_by_type(relationship_type)
+    valid_relations_for_type = []
+
+    #TODO: Log this instead of raising an exception
+    #raise ArgumentError, "No relationships apply for the relationship_type passed" if @relationships == nil
+    if relationships != nil
+      @relationships.each do |item|
+        if item.relationship_type.internal_identifier == relationship_type
+          valid_relations_for_type << item
+        end
+      end
+    end
+
+    valid_relations_for_type
+  end
+end

data/app/models/extensions/user.rb

@@ -0,0 +1,11 @@
+User.class_eval do
+  has_many :app_containers, :dependent => :destroy
+
+  def desktop
+    Desktop.includes([:app_container]).where('app_containers.user_id = ?', self.id).first
+  end
+
+  def organizer
+    Organizer.includes([:app_container]).where('app_containers.user_id = ?', self.id).first
+  end
+end

data/app/models/organizer.rb

@@ -0,0 +1,28 @@
+class Organizer < ActiveRecord::Base
+  acts_as_app_container
+
+  def setup_default_preferences
+    #setup theme
+    theme_pt = PreferenceType.iid('extjs_theme')
+    theme_pt.preferenced_records << self
+    theme_pt.save
+
+    pref = Preference.create(
+      :preference_type => theme_pt,
+      :preference_option => PreferenceOption.iid('blue_extjs_theme')
+    )
+
+    self.user_preferences << UserPreference.create(
+      :user => self.user,
+      :preference => pref
+    )
+
+    self.save
+  end
+
+  class << self
+    def find_by_user(user)
+      find_by_user_and_klass(user, Organizer)
+    end
+  end
+end

data/app/models/organizer_application.rb

@@ -0,0 +1,2 @@
+class OrganizerApplication < Application
+end

data/app/models/preference.rb

@@ -0,0 +1,5 @@
+class Preference < ActiveRecord::Base
+  belongs_to :preference_type, :dependent => :destroy
+  belongs_to :preference_option, :dependent => :destroy
+
+end

data/app/models/preference_option.rb

@@ -0,0 +1,8 @@
+class PreferenceOption < ActiveRecord::Base
+  has_many   :preferences
+  has_and_belongs_to_many :preference_type
+
+  def self.iid( internal_identifier )
+    where('internal_identifier = ?', internal_identifier.to_s).first
+  end
+end

data/app/models/preference_type.rb

@@ -0,0 +1,25 @@
+class PreferenceType < ActiveRecord::Base
+  has_many_polymorphic :preferenced_records,
+               :through => :valid_preference_types,
+               :models => [:app_containers, :desktops, :organizers, :applications]
+
+  has_many    :preferences
+  belongs_to  :default_preference_option, :foreign_key => 'default_pref_option_id', :class_name => 'PreferenceOption', :dependent => :destroy
+  has_and_belongs_to_many :preference_options
+  
+  alias :options :preference_options
+  alias :default_option :default_preference_option
+
+  def options_hash
+    Hash[*self.preference_options.collect { |v|[v.internal_identifier, v.value]}.flatten]
+  end
+
+  def self.iid( internal_identifier )
+    where('internal_identifier = ?', internal_identifier.to_s).first
+  end
+
+  def default_value
+    default_preference_option.value
+  end
+  
+end

data/app/models/tree_menu_node_def.rb

@@ -0,0 +1,37 @@
+class TreeMenuNodeDef < ActiveRecord::Base
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+
+  def refers_to_ar_class?
+    return (self.resource_class != nil) 
+  end
+
+  def find_parent_text
+    parent_text = ''
+
+    unless self.parent_id.nil?
+      parent_text = self.parent.text
+    end
+
+    parent_text
+
+  end
+
+  def self.find_menu_roots( menu_short_name )
+    where("parent_id = nil and menu_short_name  = menu_short_name")
+  end
+
+  def self.find_children(parent_id = nil)
+    parent_id.to_i == 0 ? self.roots : find(parent_id).children
+  end
+
+  def leaf
+    unknown? || 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     
+  
+end