erp_app 3.0.0

data/app/controllers/erp_app/desktop/system_management/application_role_management_controller.rb

@@ -0,0 +1,88 @@
+module ErpApp
+	module Desktop
+		module SystemManagement
+			class ApplicationRoleManagementController < ErpApp::Desktop::BaseController
+			  def applications
+          desktop_apps_hash = {:text => 'Desktop', :iconCls => 'icon-folder', :children => []}
+          organizer_apps_hash = {:text => 'Organizer', :iconCls => 'icon-folder', :children => []}
+
+          build_applications_hash(DesktopApplication.all, desktop_apps_hash)
+          build_applications_hash(OrganizerApplication.all, organizer_apps_hash)
+          
+          render :json => [desktop_apps_hash, organizer_apps_hash]
+			  end
+
+			  def available_roles
+          if params[:id].blank? or params[:klass].blank?
+            render :json => []
+          else
+            id = params[:id]
+            klass = params[:klass].constantize
+            model = klass.find(id)
+            all_roles = Role.all
+            current_role_ids = model.roles.collect{|r| r.id}
+            roles = all_roles.delete_if{|r| current_role_ids.include?(r.id)}
+
+            render :json => roles.map{|role| {:text => role.description, :leaf => true, :iconCls => 'icon-user', :role_id => role.id}}
+          end
+			  end
+
+			  def current_roles
+          if params[:id].blank? or params[:klass].blank?
+            render :json => []
+          else
+            id = params[:id]
+            klass = params[:klass].constantize
+            model = klass.find(id)
+
+            roles = model.roles
+
+            render :json => roles.map{|role| {:text => role.description, :leaf => true, :iconCls => 'icon-user', :role_id => role.id}}
+          end
+			  end
+
+			  def save_roles
+          id = params[:id]
+          role_ids = params[:role_ids]
+
+          klass = params[:klass].constantize
+          model = klass.find(id)
+          roles = Role.where("id in (#{role_ids.join(',')})").all
+          model.remove_all_roles
+          model.add_roles(roles)
+          model.save
+
+          render :json => {:success => true, :message => 'Roles Saved'}
+			  end
+
+        private
+
+        def build_applications_hash(applications, parent_hash)
+          applications.each do |app|
+            widgets_hash = {:text => 'Widgets', :iconCls => 'icon-folder', :children => []}
+            app.widgets.each do |widget|
+              widgets_hash[:children] << {:text => widget.description, :iconCls => 'icon-key', :hasRoles => true, :modelId => widget.id, :klass => 'Widget', :children => build_capabilites_hash(widget)}
+            end
+
+            app_children = [build_capabilites_hash(app),widgets_hash]
+            parent_hash[:children] << {:text => app.description, :iconCls => app.icon, :leaf => false, :children => app_children, :app_id => app.id}
+          end
+        end
+
+        def build_capabilites_hash(model)
+          capabilities_hash = {:text => 'Capabilities', :iconCls => 'icon-folder', :children => []}
+          available_capability_resources = model.available_capability_resources
+          available_capability_resources.each do |resource|
+            capability_resource_hash = {:text => resource, :iconCls => 'icon-folder', :children => []}
+            model.capabilites_by_resource(resource).each do |capability|
+              capability_resource_hash[:children] << {:text => capability.type.description, :iconCls => 'icon-key', :hasRoles => true, :leaf => true, :modelId => capability.id, :klass => 'Capability'}
+            end
+            capabilities_hash[:children] << capability_resource_hash
+          end
+          capabilities_hash
+        end
+			  
+			end
+		end
+	end
+end

data/app/controllers/erp_app/desktop/system_management/base_controller.rb

@@ -0,0 +1,8 @@
+module ErpApp
+	module Desktop
+		module SystemManagement
+			class BaseController < ErpApp::Desktop::BaseController
+			end
+		end
+	end
+end

data/app/controllers/erp_app/desktop/user_management/application_management_controller.rb

@@ -0,0 +1,51 @@
+module ErpApp
+	module Desktop
+		module UserManagement
+			class ApplicationManagementController < ErpApp::Desktop::UserManagement::BaseController
+			  
+			  def available_applications
+          user_id            = params[:user_id]
+          app_container_type = params[:app_container_type]
+
+          if app_container_type == 'Desktop'
+            app_container = ::Desktop.find_by_user(User.find(user_id))
+            applications = DesktopApplication.all
+          else
+            app_container = ::Organizer.find_by_user(User.find(user_id))
+            applications = OrganizerApplication.all
+          end
+          current_applications = app_container.applications
+          applications.delete_if{|r| current_applications.collect(&:id).include?(r.id)}
+
+          render :json => applications.map{|application| {:text => application.description, :app_id => application.id, :iconCls => application.icon, :leaf => true}}
+			  end
+
+			  def current_applications
+          user_id            = params[:user_id]
+          app_container_type = params[:app_container_type]
+
+          app_container = (app_container_type == 'Desktop') ? ::Desktop.find_by_user(User.find(user_id)) : ::Organizer.find_by_user(User.find(user_id))
+          render :json => app_container.applications.map{|application| {:text => application.description, :app_id => application.id, :iconCls => application.icon, :leaf => true}}
+			  end
+
+			  def save_applications
+          app_ids            = params[:app_ids]
+          user_id            = params[:user_id]
+          app_container_type = params[:app_container_type]
+
+          app_container = (app_container_type == 'Desktop') ? ::Desktop.find_by_user(User.find(user_id)) : ::Organizer.find_by_user(User.find(user_id))
+          app_container.applications = []
+          app_container.save
+
+          app_ids.each do |app_id|
+            app_container.applications << Application.find(app_id)
+          end
+          app_container.save
+				
+          render :json => {:success => true, :message => 'Application(s) Saved'}
+			  end
+			  
+			end
+		end
+	end
+end

data/app/controllers/erp_app/desktop/user_management/base_controller.rb

@@ -0,0 +1,101 @@
+module ErpApp
+	module Desktop
+		module UserManagement
+			class BaseController < ErpApp::Desktop::BaseController
+			  before_filter :get_user, :only => [:get_details, :delete]
+
+			  def index
+          username = params[:username]
+          sort_hash = params[:sort].blank? ? {} : Hash.symbolize_keys(JSON.parse(params[:sort]).first)
+          sort = sort_hash[:property] || 'username'
+          dir  = sort_hash[:direction] || 'ASC'
+          limit = params[:limit] || 25
+          start = params[:start] || 0
+          total_count = 0
+
+          if username.blank?
+            users = User.order("#{sort} #{dir}").offset(start).limit(limit)
+            total_count = User.count
+          else
+            users = User.where('username like ?', "%#{username}%").order("#{sort} #{dir}").offset(start).limit(limit)
+            total_count = users.count
+          end
+
+          render :inline => "{\"totalCount\":#{total_count},data:#{users.to_json(:only => [:id, :username, :email, :party_id])}}"
+			  end
+
+			  def new
+          response = {}
+          application = DesktopApplication.find_by_internal_identifier('user_management')
+          begin
+            current_user.with_capability(application, :create, 'User') do
+            
+              user = User.new(
+                :email => params[:email],
+                :username => params[:username],
+                :password => params[:password],
+                :password_confirmation => params[:password_confirmation]
+              )
+              #set this to tell activation where to redirect_to for login and temp password
+              user.add_instance_attribute(:login_url, '/erp_app/login');
+              user.add_instance_attribute(:temp_password, params[:password]);
+
+              if user.save
+                individual = Individual.create(:gender => params[:gender], :current_first_name => params[:first_name], :current_last_name => params[:last_name])
+                user.party = individual.party
+                user.save
+
+                response = {:success => true}
+              else
+                message = "<ul>"
+                user.errors.collect do |e, m|
+                  message << "<li>#{e} #{m}</li>"
+                end
+                message << "</ul>"
+                response = {:success => false, :message => message}
+              end
+
+              render :json => response
+            end
+          rescue ErpTechSvcs::Utils::CompassAccessNegotiator::Errors::UserDoesNotHaveCapability=>ex
+            render :json => {:success => false, :message => ex.message}
+          end
+        end
+
+        def get_details
+          if @user.party.business_party.is_a?(Individual)
+            business_party = @user.party.business_party.to_json(:only => [:current_first_name, :current_last_name, :gender, :total_years_work_experience])
+          else
+            business_party = @user.party.business_party.to_json(:only => [:description])
+          end
+
+          render :inline => "{entityType:'#{@user.party.business_party.class.to_s}',
+                              businessParty:#{business_party},
+                              userInfo:#{@user.to_json(:only => [:username, :email, :last_login_at, :last_activity_at, :failed_login_count, :activation_state])}}"
+        end
+
+        def delete
+          application = DesktopApplication.find_by_internal_identifier('user_management')
+          if current_user.has_capability?(application, 'create', 'User')
+            unless @user.party.nil?
+              @user.party.destroy
+            else
+              @user.destroy
+            end
+
+            render :json => {:success => true}
+          else
+            render :json => {:success => false, :message => 'Invalid Access'}
+          end
+        end
+
+        protected
+
+        def get_user
+          @user = User.find(params[:id])
+        end
+        
+      end
+    end
+  end
+end

data/app/controllers/erp_app/desktop/user_management/role_management_controller.rb

@@ -0,0 +1,40 @@
+module ErpApp
+	module Desktop
+		module UserManagement
+			class RoleManagementController < ErpApp::Desktop::UserManagement::BaseController
+
+			  def available_roles
+          user_id = params[:user_id]
+
+          roles = Role.all
+          current_role_ids = User.find(user_id).roles.collect{|r| r.id}
+          roles.delete_if{|r| current_role_ids.include?(r.id)}
+
+          render :json => roles.map{|role| {:text => role.description, :iconCls => 'icon-user', :leaf => true, :role_id => role.id}}
+			  end
+
+			  def current_roles
+          user_id = params[:user_id]
+				
+          roles = User.find(user_id).roles
+
+          render :json => roles.map{|role| {:text => role.description, :iconCls => 'icon-user', :leaf => true, :role_id => role.id}}
+			  end
+
+			  def save_roles
+          role_ids = params[:role_ids]
+          user_id  = params[:user_id]
+
+          user = User.find(user_id)
+          roles = Role.where("id in (#{role_ids.join(',')})").all
+          user.remove_all_roles
+          user.add_roles(roles)
+          user.save
+
+          render :json => {:success => true, :message => 'Roles Saved'}
+			  end
+			  
+			end
+		end
+	end
+end

data/app/controllers/erp_app/login_controller.rb

@@ -0,0 +1,8 @@
+module ErpApp
+	class LoginController < ApplicationController
+	  layout :nil
+	  
+	  def index
+	  end
+	end
+end

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

@@ -0,0 +1,39 @@
+module ErpApp
+	module Organizer
+		class BaseController < ErpApp::ApplicationController
+		  layout nil
+      before_filter :require_login
+		  
+		  def index
+        @organizer = ::Organizer.find_by_user(current_user)
+        @user = current_user
+		  end
+		  
+		  def get_preferences
+        user = current_user
+        organizer = ::Organizer.find_by_user(user)
+
+        render :inline => "{\"success\":true, \"preferences\":#{organizer.preferences.to_json(:include => [:preference_type, :preference_option])}}"
+		  end
+
+		  def setup_preferences
+		    user = current_user
+        organizer = ::Organizer.find_by_user(user)
+			
+        render :inline => "{\"success\":true, \"preference_types\":#{organizer.preference_types.to_json(:include => :preference_options)}}"
+		  end
+
+		  def update_preferences
+        user = current_user
+        organizer = ::Organizer.find_by_user(user)
+
+        params.each do |k,v|
+          organizer.set_preference(k, v) unless k.to_s == 'action' or k.to_s == 'controller'
+        end
+        organizer.save
+			
+        render :inline => "{\"success\":true, \"preferences\":#{organizer.preferences.to_json(:include => [:preference_type, :preference_option])}}"
+		  end
+		end
+	end
+end

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

@@ -0,0 +1,216 @@
+module ErpApp
+	module Organizer
+		module Crm
+			class BaseController < ErpApp::Organizer::BaseController
+			  def menu
+          menu = []
+
+          menu << {:text => 'Individuals', :businessPartType => 'individual', :leaf => true, :iconCls => 'icon-user', :applicationCardId => "individuals_search_grid"}
+          menu << {:text => 'Organizations',:businessPartType => 'organization', :leaf => true, :iconCls => 'icon-user', :applicationCardId => "organizations_search_grid"}
+
+          render :json => menu
+			  end
+
+			  def contact_purposes
+          render :inline => "{\"types\":#{ContactPurpose.all.to_json(:only => [:id, :description])}}"
+			  end
+
+			  def parties
+          render :inline => if request.put?
+            update_party
+          elsif request.get?
+            get_parties
+          elsif request.delete?
+            delete_party
+          end
+			  end
+
+			  def contact_mechanism
+          render :inline => if request.post?
+            create_contact_mechanism
+          elsif request.put?
+            update_contact_mechanism
+          elsif request.get?
+            get_contact_mechanisms
+          elsif request.delete?
+            delete_contact_mechanism
+          end
+			  end
+
+			  def create_party
+          result = {}
+          begin
+            enterprise_identifier = params[:enterprise_identifier]
+            party_type = params[:party_type]
+            klass = party_type.constantize
+            params.delete(:enterprise_identifier)
+            params.delete(:action)
+            params.delete(:controller)
+            params.delete(:party_type)
+
+            business_party = klass.create(params)
+            business_party.party.enterprise_identifier = enterprise_identifier
+            business_party.party.save
+
+            result = {:success => true, :message => "#{party_type} Added", :name => business_party.party.description}
+          rescue Exception=>ex
+            result = {:success => false, :message => "Error adding #{party_type}"}
+          end
+
+          render :json => result
+			  end
+
+			  private
+
+			  def update_party
+          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]
+          business_party_data.delete(:id)
+          business_party_data.delete(:business_party_id)
+          business_party_data.delete(:enterprise_identifier)
+
+          klass = party_type.constantize
+          business_party = klass.find(businesss_party_id)
+
+          business_party_data.each do |key,value|
+            key = key.gsub("business_party.", "")
+            method = key + '='
+            business_party.send method.to_sym, value
+          end
+
+          business_party.save
+          party = business_party.party
+
+          begin
+            party.enterprise_identifier = enterprise_identifier
+            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
+
+			  end
+
+			  def get_parties
+          search_name = params[:party_name]
+          party_type = params[:party_type]
+          start = params[:start] || 0
+          limit = params[:limit] || 30
+
+          total_count = Party.where("description like ? and business_party_type = ?", "%#{search_name}%", party_type).count
+          parties = Party.where("description like ? and business_party_type = ?", "%#{search_name}%", party_type).order("id").offset(start).limit(limit)
+
+           {:totalCount => total_count, :data => parties.collect{|party| {
+                :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
+			  end
+
+			  def delete_party
+          party_type = params[:party_type]
+          Party.destroy(params[:id])
+
+          {:data => [], :message => "#{party_type} deleted"}.to_json
+			  end
+
+			  def create_contact_mechanism
+          party_id = params[:party_id]
+          contact_type = params[:contact_type]
+          contact_purpose_id = params[:data][:contact_purpose_id]
+          params[:data].delete(:contact_purpose_id)
+
+          contact_mechanism_class = contact_type.constantize
+          party = Party.find(party_id)
+          
+          contact_purpose = contact_purpose_id.blank? ? ContactPurpose.find_by_internal_identifier('default') : ContactPurpose.find(contact_purpose_id)
+          contact_mechanism = party.add_contact(contact_mechanism_class, params[:data], contact_purpose)
+
+          contact_mechanism_class.class_eval do
+            def contact_purpose_id
+              self.contact_purpose ? contact_purpose.id : nil
+            end
+          end
+
+          "{\"success\":true, \"data\":#{contact_mechanism.to_json(:methods => [:contact_purpose_id])},\"message\":\"#{contact_type} added\"}"
+			  end
+
+			  def update_contact_mechanism
+          contact_type = params[:contact_type]
+          contact_mechanism_id = params[:data][:id]
+          contact_purpose_id = params[:data][:contact_purpose_id]
+          params[:data].delete(:id)
+          params[:data].delete(:contact_purpose_id)
+          
+          contact_mechanism = contact_type.constantize.find(contact_mechanism_id)
+
+          if !contact_purpose_id.blank?
+            contact_purpose = ContactPurpose.find(contact_purpose_id)
+            contact_mechanism.contact.contact_purposes.destroy_all
+            contact_mechanism.contact.contact_purposes << contact_purpose
+            contact_mechanism.contact.save
+          end
+
+          params[:data].each do |key,value|
+            method = key + '='
+            contact_mechanism.send method.to_sym, value
+          end
+
+          contact_mechanism.save
+
+          contact_mechanism_class.class_eval do
+            def contact_purpose_id
+              self.contact_purpose ? contact_purpose.id : nil
+            end
+          end
+
+          "{\"success\":true, \"data\":#{contact_mechanism.to_json(:methods => [:contact_purpose_id])},\"message\":\"#{contact_type} updated\"}"
+			  end
+
+			  def get_contact_mechanisms
+          party_id = params[:party_id]
+          contact_type = params[:contact_type]
+
+          contact_mechanism_class = contact_type.constantize
+
+          party = Party.find(party_id)
+          contact_mechanisms = party.find_all_contacts_by_contact_mechanism(contact_mechanism_class)
+
+          contact_mechanism_class.class_eval do
+            def contact_purpose_id
+              self.contact_purpose ? contact_purpose.id : nil
+            end
+          end
+
+          "{\"success\":true, \"data\":#{contact_mechanisms.to_json(:methods => [:contact_purpose_id])}}"
+			  end
+
+			  def delete_contact_mechanism
+          party_id = params[:party_id]
+          contact_type = params[:contact_type]
+          contact_mechanism_id = params[:id]
+
+          contact_type_class = contact_type.constantize
+          contact_mechanism = contact_type_class.find(contact_mechanism_id)
+          contact_mechanism.destroy
+
+          party = Party.find(party_id)
+          contact_mechanisms = party.find_all_contacts_by_contact_mechanism(contact_type_class)
+          
+          "{\"success\":true, \"data\":#{contact_mechanisms.to_json(:methods => [:contact_purpose_id])},\"message\":\"#{contact_type} deleted\"}"
+			  end
+			end
+		end
+	end
+end