erp_app 4.0.0 → 4.2.0

data/app/controllers/erp_app/desktop/security_management/roles_controller.rb

@@ -1,183 +0,0 @@
-module ErpApp
-  module Desktop
-    module SecurityManagement
-      class RolesController < ErpApp::Desktop::SecurityManagement::BaseController
-
-        def available_setup
-          begin
-            columns = []
-            columns << {header: 'Security Role Name', dataIndex: 'description', flex: 1}
-            columns << {header: 'Internal ID', dataIndex: 'internal_identifier', flex: 1}
-
-            definition = []
-            definition << {fieldLabel: 'Security Role Name', name: 'description'}
-            definition << {fieldLabel: 'Internal ID', name: 'internal_identifier'}
-            definition << {fieldLabel: 'ID', name: 'id'}
-
-            render :json => {success: true, columns: columns, fields: definition}
-
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-
-            render :json => {success: false, message: ex.message}
-          end
-        end
-
-        def selected_setup
-          available_setup
-        end
-
-        def available
-          assign_to = params[:assign_to]
-          assign_to_id = params[:id]
-          sort = (params[:sort] || 'description').downcase
-          dir = (params[:dir] || 'asc').downcase
-          query_filter = params[:query_filter].strip rescue nil
-
-          ar = assign_to_id.blank? ? SecurityRole : assign_to.constantize.find(assign_to_id).roles_not
-          ar = (params[:query_filter].blank? ? ar : ar.where("UPPER(security_roles.description) LIKE UPPER('%#{query_filter}%')"))
-          available = ar.paginate(:page => page, :per_page => per_page, :order => "#{sort} #{dir}")
-
-          render :json => {:total => ar.count, :data => available.map { |x| {:description => x.description, :internal_identifier => x.internal_identifier, :id => x.id} }}
-        end
-
-        def selected
-          assign_to = params[:assign_to]
-          assign_to_id = params[:id]
-          sort = (params[:sort] || 'description').downcase
-          dir = (params[:dir] || 'asc').downcase
-          query_filter = params[:query_filter].strip rescue nil
-
-          ar = assign_to_id.blank? ? SecurityRole : assign_to.constantize.find(assign_to_id).roles
-          ar = (params[:query_filter].blank? ? ar : ar.where("UPPER(security_roles.description) LIKE UPPER('%#{query_filter}%')"))
-          selected = ar.paginate(:page => page, :per_page => per_page, :order => "#{sort} #{dir}")
-
-          render :json => {:total => ar.count, :data => selected.map { |x| {:description => x.description, :internal_identifier => x.internal_identifier, :id => x.id} }}
-        end
-
-        def create
-          begin
-            description = params[:description].strip
-            iid = params[:internal_identifier].strip
-
-            unless description.blank?
-              SecurityRole.create(:description => description, :internal_identifier => iid)
-              render :json => {:success => true, :message => 'Security Role created'}
-            else
-              raise "Role name blank"
-            end
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => ex.message
-            }.to_json
-          end
-        end
-
-        def update
-          begin
-            description = params[:description].strip
-
-            unless description.blank? or params[:id].blank?
-              r = SecurityRole.find(params[:id])
-              r.description = description
-              r.save
-              render :json => {:success => true, :message => 'Security Role updated'}
-            else
-              raise "Role name blank or no role ID"
-            end
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => ex.message
-            }.to_json
-          end
-        end
-
-        def delete
-          begin
-            unless params[:id].blank?
-              SecurityRole.destroy(params[:id])
-              render :json => {:success => true, :message => 'Security Role deleted'}
-            else
-              raise "No Role ID"
-            end
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => ex.message
-            }.to_json
-          end
-        end
-
-        def add
-          begin
-            assign_to = params[:assign_to]
-            assign_to_id = params[:id]
-            selected = JSON.parse(params[:selection])
-
-            a = assign_to.constantize.find(assign_to_id)
-            selected.each do |r|
-              role = SecurityRole.find(r)
-              case assign_to
-                when 'User'
-                  a.add_role(role)
-                when 'Group'
-                  a.add_role(role)
-                when 'Capability'
-                  role.add_capability(a)
-              end
-            end
-
-            render :json => {:success => true, :message => 'Security Roles(s) Added'}
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => ex.message
-            }.to_json
-          end
-        end
-
-        def remove
-          begin
-            assign_to = params[:assign_to]
-            assign_to_id = params[:id]
-            selected = JSON.parse(params[:selection])
-
-            a = assign_to.constantize.find(assign_to_id)
-            selected.each do |r|
-              role = SecurityRole.find(r)
-              case assign_to
-                when 'User'
-                  a.remove_role(role)
-                when 'Group'
-                  a.remove_role(role)
-                when 'Capability'
-                  role.remove_capability(a)
-              end
-            end
-
-            render :json => {:success => true, :message => 'Security Roles(s) Removed'}
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => ex.message
-            }.to_json
-          end
-        end
-
-      end
-    end
-  end
-end

data/app/controllers/erp_app/desktop/security_management/users_controller.rb

@@ -1,140 +0,0 @@
-module ErpApp
-  module Desktop
-    module SecurityManagement
-      class UsersController < ErpApp::Desktop::SecurityManagement::BaseController
-
-        def available_setup
-          begin
-            columns = []
-            columns << {header: 'Party Description', dataIndex: 'party_description', flex: 1}
-            columns << {header: 'Username', dataIndex: 'username', flex: 1}
-            columns << {header: 'Email', dataIndex: 'email', flex: 1}
-
-            definition = []
-            definition << {fieldLabel: 'Party Description', name: 'party_description'}
-            definition << {fieldLabel: 'Username', name: 'username'}
-            definition << {fieldLabel: 'Email', name: 'email'}
-            definition << {fieldLabel: 'ID', name: 'id'}
-
-            render :json => {success: true, columns: columns, fields: definition}
-
-          rescue => ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-
-            render :json => {success: false, message: ex.message}
-          end
-        end
-
-        def selected_setup
-          available_setup
-        end
-
-        def available
-          assign_to = params[:assign_to]
-          assign_to_id = params[:id]
-          sort = (params[:sort] || 'username').downcase
-          dir = (params[:dir] || 'asc').downcase
-          query_filter = params[:query_filter].strip rescue nil
-
-          ar = assign_to_id.blank? ? User : assign_to.constantize.find(assign_to_id).users_not
-          ar = params[:query_filter].blank? ? ar : ar.where("UPPER(username) LIKE UPPER('%#{query_filter}%') OR UPPER(email) LIKE UPPER('%#{query_filter}%') ")
-          available = ar.paginate(:page => page, :per_page => per_page, :order => "#{sort} #{dir}")
-
-          render :json => {:total => ar.count, :data => available.map { |x| {:username => x.username, :email => x.email, :party_description => x.party.description, :id => x.id} }}
-        end
-
-        def selected
-          assign_to = params[:assign_to]
-          assign_to_id = params[:id]
-          sort = (params[:sort] || 'username').downcase
-          dir = (params[:dir] || 'asc').downcase
-          query_filter = params[:query_filter].strip rescue nil
-
-          ar = assign_to_id.blank? ? User : assign_to.constantize.find(assign_to_id).users
-          ar = (params[:query_filter].blank? ? ar : ar.where("UPPER(username) LIKE UPPER('%#{query_filter}%') OR UPPER(email) LIKE UPPER('%#{query_filter}%') "))
-          selected = ar.paginate(:page => page, :per_page => per_page, :order => "#{sort} #{dir}")
-
-          render :json => {:total => ar.count, :data => selected.map { |x| {:username => x.username, :email => x.email, :party_description => x.party.description, :id => x.id} }}
-        end
-
-        def add
-          begin
-            assign_to = params[:assign_to]
-            assign_to_id = params[:id]
-            selected = JSON.parse(params[:selection])
-
-            a = assign_to.constantize.find(assign_to_id)
-            selected.each do |x|
-              u = User.find(x)
-              case assign_to
-                when 'Group'
-                  a.add_user(u)
-                when 'SecurityRole'
-                  u.add_role(a)
-                when 'Capability'
-                  u.add_capability(a)
-              end
-            end
-
-            render :json => {:success => true, :message => 'Group(s) Added'}
-          rescue Exception => e
-            Rails.logger.error e.message
-            Rails.logger.error e.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => e.message
-            }.to_json
-          end
-        end
-
-        def remove
-          begin
-            assign_to = params[:assign_to]
-            assign_to_id = params[:id]
-            selected = JSON.parse(params[:selection])
-
-            a = assign_to.constantize.find(assign_to_id)
-            selected.each do |x|
-              u = User.find(x)
-              case assign_to
-                when 'Group'
-                  a.remove_user(u)
-                when 'SecurityRole'
-                  u.remove_role(a)
-                when 'Capability'
-                  u.remove_capability(a)
-              end
-            end
-
-            render :json => {:success => true, :message => 'Group(s) Removed'}
-          rescue Exception => e
-            Rails.logger.error e.message
-            Rails.logger.error e.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => e.message
-            }.to_json
-          end
-        end
-
-        def effective_security
-          begin
-            assign_to_id = params[:id]
-            u = User.find(assign_to_id)
-
-            render :json => {:success => true, :roles => u.all_uniq_roles, :capabilities => u.class_capabilities_to_hash}
-          rescue Exception => e
-            Rails.logger.error e.message
-            Rails.logger.error e.backtrace.join("\n")
-            render :inline => {
-                :success => false,
-                :message => e.message
-            }.to_json
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module ErpApp
-	module Mobile
-		class BaseController < ErpApp::ApplicationController
-		  layout nil
-		  before_filter :require_login
-
-		  def index
-        @user   = current_user
-        @mobile = @user.mobile
-
-        render :layout => false
-		  end
-
-      protected
-      def not_authenticated
-        redirect_to '/erp_app/mobile/login', :notice => "Please login first."
-      end
-		  
-		end
-	end
-end

data/app/controllers/erp_app/mobile/login_controller.rb

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

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

@@ -1,20 +0,0 @@
-module ErpApp
-  module Mobile
-    module UserManagement
-      class BaseController < ::ErpApp::Mobile::BaseController
-
-        def users
-          users = User.all.collect do |user|
-            user.to_hash(:only => [:username, :email, :failed_logins_count, :activation_state],
-                         :last_login_at => (user.last_login_at.nil? ? nil : user.last_login_at.to_time.strftime("%Y-%m-%dT%I:%M:%S")),
-                         :last_activity_at => (user.last_activity_at.nil? ? nil : user.last_activity_at.to_time.strftime("%Y-%m-%dT%I:%M:%S"))
-            )
-          end
-
-          render :json => {:success => true, :users => users}
-        end
-
-      end
-    end
-  end
-end

data/app/models/app_container.rb

@@ -1,31 +0,0 @@
-class AppContainer < ActiveRecord::Base
-  attr_protected :created_at, :updated_at
-
-  has_user_preferences
-
-  belongs_to :user
-  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
-
-  class << self
-    def find_by_user(user)
-      AppContainer.where('user_id = ?', user.id).first
-    end
-  end
-end

data/app/models/desktop.rb

@@ -1,72 +0,0 @@
-class Desktop < AppContainer
-  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')
-    self.preference_types << desktop_backgroud_pt
-
-    pref = Preference.create(
-      :preference_type => desktop_backgroud_pt,
-      :preference_option => desktop_backgroud_pt.default_preference_option
-    )
-
-    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)
-      Desktop.where('user_id = ?', user.id).first
-    end
-    
-  end
-  
-end