mks_auth 1.0.14 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b4b274de2615dc2349c98ab4541369830d40dc34b08fa03d0b0097353c5f121
-  data.tar.gz: 0b9f5fe417c673964aa754a5fb0e37fd588e919825a27086181e9331fd9e4f89
+  metadata.gz: c9befc13ee79dba3fce47aa04621b0cbab4983d6f32e22eefa8f8ea038dc0235
+  data.tar.gz: 8799d30c67e91c2f773bae8715e17a6b17bbf2fcff1bb1a232761955f142778a
 SHA512:
-  metadata.gz: 043fecd8660069c8c8c2f62241ddd7dbac398e0fee0bc4cc18c6de8a9a0c7414c078aa4547d1c535c53e9906cc156cd02bd869546b17038ee6493be1e7aa8377
-  data.tar.gz: c4cdb4314dc64bcf83de5b2271f229fe8de09be45c8027df76dbcfeb7a9cea75037ec465b874c52c33f9085cc5d805ccf2588f1c6cbbecefaf05dd47bbd65da3
+  metadata.gz: bded2f7264869bf5dfb2437d39f5e6c5950a1c949c9effc36522fc547f40299dabb9e9e72b87a7f852af39f4daf7f4e3bd6b0ad2a0f5cbe02a278b190eb21e70
+  data.tar.gz: 510531747665163e392c2593ce3f9815c506d7555347a7e2a20da552954b803bf7cbd0aa7a2bcbbab34242a062d99cc5f29ba9b236c89b00cd031e8882a81a17

data/Rakefile

@@ -14,10 +14,24 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+
 load 'rails/tasks/engine.rake'
+
 load 'rails/tasks/statistics.rake'
 
-# require 'bundler/gem_tasks'
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(spec: 'app:db:test:prepare')
+
+desc 'Run all specs in spec directory (excluding plugin specs)'
+
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/app/assets/config/mks_auth_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/mks_auth .js
+//= link_directory ../stylesheets/mks_auth .css

data/app/assets/javascripts/mks_auth/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/mks_auth/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/mks/auth/access_controller.rb

@@ -0,0 +1,51 @@
+require_dependency 'mks/auth/application_controller'
+
+module Mks
+  module Auth
+    class AccessController < ApplicationController
+      before_action :confirm_logged_in, :except => [:attempt_login, :logout, :menu, :csrf_token]
+
+      def csrf_token
+        cookies['XSRF-TOKEN'] = form_authenticity_token if protect_against_forgery?
+        render json: {success: true}
+      end
+
+      def attempt_login
+        code = Rails.configuration.app_code
+        app_module = ApplicationModule.find_by(code: code)
+        user = User.find_by(email: params[:email].downcase)
+
+        if user && user.application_module.id == app_module.id
+          if user.authenticate(params[:password])
+            login_user user
+            roles = user.roles.map(&:name)
+            response = { success: true, data: {user_id: user.id, user_full_name: user.full_name, roles: roles }}
+            render json: response
+          else
+            render json: {success: false, errors: "Invalid username or password"}
+          end
+        else
+          render json: {success: false, errors: "User doesn't exist or is not allowed!"}
+        end
+      end
+
+      def logout
+        logout_user if logged_in?
+        render json: { success: true }
+      end
+
+      def menu
+        render json: {success: true, data: fetch_menus}
+      end
+
+      def check_login
+        if session[:user_id]
+          user = User.find(session[:user_id])
+          render json: {success: true, data: user.full_name}
+        else
+          render json: {success: false}
+        end
+      end
+    end
+  end
+end

data/app/controllers/mks/auth/application_controller.rb

@@ -1,50 +1,24 @@
-require 'mks/auth/token_auth'
-
 module Mks
   module Auth
-    class ApplicationController < ActionController::API
-      before_action :authenticate
-
-      def logged_in?
-        !current_user.nil?
-      end
-
-      def current_user
-        return unless auth_present?
-        user = User.find(auth['id'])
-        @current_user ||= user if user
-      end
-
-      def current_user_id
-        auth['id']
-      end
-
-      def app_code
-        Rails.application.config.app_code
-      end
+    class ApplicationController < ActionController::Base
+      include AccessHelper
+      include ApplicationHelper
 
       private
 
-      def authenticate
-        render json: { error: 'Unauthorized' }, status: 401 unless logged_in?
-      end
-
-      def token
-        request.env['HTTP_AUTHORIZATION'].scan(/Bearer (.*)$/).flatten.last
+      def confirm_logged_in
+        if session[:user_id]
+          true
+        else
+          redirect_to '/'
+          false
+        end
       end
 
-      def auth
-        TokenAuth.decode(token)
-      end
-
-      def auth_present?
-        bearer = request.env.fetch('HTTP_AUTHORIZATION', '').scan(/Bearer/).flatten.first
-        !bearer.nil?
-      end
+      protected
 
-      def app_module
-        code = Rails.configuration.app_code
-        ApplicationModule.find_by(code: code)
+      def verified_request?
+        super || valid_authenticity_token?(session, request.headers['X-XSRF-TOKEN'])
       end
     end
   end

data/app/controllers/mks/auth/application_modules_controller.rb

@@ -1,3 +1,5 @@
+require_dependency 'mks/auth/application_controller'
+
 module Mks
   module Auth
     class ApplicationModulesController < ApplicationController

data/app/controllers/mks/auth/user_roles_controller.rb

@@ -1,59 +1,51 @@
+require_dependency 'mks/auth/application_controller'
+
 module Mks
   module Auth
     class UserRolesController < ApplicationController
-      before_action :set_role, only: %i[users]
-      before_action :set_user, only: %i[assigned_roles assign_roles]
+      # before_action :confirm_logged_in
 
       # GET /user_roles
       def index
-        user_roles = UserRole.joins(:application_module)
-                             .where("mks_auth_application_modules.code = '#{app_code}'")
-                             .order(:name)
-        render json: user_roles
-      end
-
-      def users
-        render json: @role.users
+        @user_roles = UserRole.all.order(:name)
+        response = { success: true, data: @user_roles }
+        render json: response
       end
 
-      def assigned_roles
-        selected = @user.roles.map { |ur| { id: ur.id, name: ur.name, selected: true }}
-        ids = @user.roles.map(&:id)
-        user_roles = UserRole.joins(:application_module)
-                             .where("mks_auth_application_modules.code = '#{app_code}'")
-                             .where.not('mks_auth_user_roles.id IN (?)', ids)
-
-        not_selected = user_roles.map { |ur| { id: ur.id, name: ur.name, selected: false }}
-        data = (selected + not_selected).sort_by{ |r| r[:name] }
-
+      def get_assigned_roles
+        user = User.find(params[:user_id])
+        user_roles = UserRole.all.order(:name)
+        data = []
+        user_roles.each do |user_role|
+          item = {id: user_role.id, name: user_role.name}
+          if user.roles.include? user_role
+            item[:selected] = true
+          else
+            item[:selected] = false
+          end
+          data << item
+        end
         response = { success: true, data: data }
         render json: response
       end
 
-      # A method which assigns selected roles to a user.
-      # This method expects that only selected roles
-      # (i.e. roles with `selected` attribute set to true).
-      # It removes all other roles and assigns those selected
-      # roles to the user.
       def assign_roles
-        selected_roles = params[:roles]&.map { |r| r[:id] }
-        user_roles = UserRole.where(id: selected_roles)
-        @user.roles.destroy_all
-        @user.roles = user_roles
-
-        response = { success: true, message: 'Role assignment successful!' }
-        render json: response
-      end
+        user = User.find(params[:user_id])
+        roles = params[:roles]
 
+        roles.each do |role|
+          user_role = UserRole.find role[:id]
+          if role[:selected]
+            user.roles << user_role
+          else
+            user.roles.destroy user_role
+          end
+        end
 
-      private
+        user.save
 
-      def set_role
-        @role = UserRole.find(params[:id])
-      end
-
-      def set_user
-        @user = User.find(params[:id])
+        response = { success: true, message: 'Role assignment successful!' }
+        render json: response
       end
     end
   end

data/app/controllers/mks/auth/users_controller.rb

@@ -1,68 +1,58 @@
+require_dependency 'mks/auth/application_controller'
+
 module Mks
   module Auth
     class UsersController < ApplicationController
-      skip_before_action :authenticate, raise: false, only: %i[login]
-      before_action :set_user, only: %i[update user_roles save_selected_roles]
+      before_action :set_user, only: [:update]
 
       def index
-        @users = ApplicationModule.find_by(code: app_code).users
-        render json: @users
+        @users = User.where(application_module_id: app_module.id)
+        response = { success: true, data: @users }
+        render json: response
       end
 
       def roles
-        user = User.find(params[:id])
-        render json: user.roles
-      end
-
-      # A method to fetch all roles, with roles of
-      # a user marked as selected
-      def user_roles
-        all_roles = UserRole.joins(:application_module).where(mks_auth_application_modules: { code: app_code })
-        roles = all_roles.map { |r| { id: r.id, name: r.name, selected: @user.roles.include?(r) } }
-        render json: roles
+        user = User.find(session[:user_id])
+        data = user.roles.map { |role| {id: role.id, name: role.name} }
+        response = {success: true, data: data}
+        render json: response
       end
 
-      def save_selected_roles
-        @user.roles.delete_all
-        selected = save_selected_roles_params['roles'].select { |r| r['selected'] }.map{ |r| r['id'] }
-        roles = UserRole.where(id: selected)
-        @user.roles << roles
-        render json: { success: true }
+      def fetch_by_role
+        r = params[:role]
+        role = UserRole.find_by(name: r)
+        unless role
+          raise 'Role not found'
+        end
+        response = { success: true, data: role.users }
+        render json: response
       end
 
       def create
         @user = User.new(user_params)
-        app_module = ApplicationModule.find_by(code: app_code)
-        @user.application_modules = [app_module]
+        @user.application_module_id = app_module.id
         if @user.save
-          render json: { success: true, data: @user }
+          response = { success: true, message: 'User saved successfully' }
+          render json: response
         else
-          render json: { success: false, error: @user.errors.full_messages[0] }, status: :uprocessable_entity
+          errors = Mks::Common::Util.error_messages @user, 'User'
+          response = { success: false, errors: errors }
+          render json: response
         end
       end
 
       def update
         if @user.update(user_params)
-          render json: { success: true, data: @user }
-        else
-          render json: { success: false, error: @user.errors.full_messages[0] }, status: :unprocessable_entity
-        end
-      end
-
-      def login
-        user = User.find_by(email: auth_params[:email])
-        if user.authenticate(auth_params[:password]) &&
-           user.has_module(auth_params[:app_module])
-
-          jwt = TokenAuth.issue(user.to_token_payload)
-          render json: { jwt: jwt }
+          response = { success: true, message: 'User updated successfully' }
+          render json: response
         else
-          render json: {}, status: 400
+          errors = Mks::Common::Util.error_messages @user, 'User'
+          response = { success: false, errors: errors }
+          render json: response
         end
       end
 
       private
-
       # Use callbacks to share common setup or constraints between actions.
       def set_user
         @user = User.find(params[:id])
@@ -72,14 +62,6 @@ module Mks
       def user_params
         params.require(:user).permit(:first_name, :last_name, :email, :password)
       end
-
-      def auth_params
-        params.require(:auth).permit(:email, :password, :app_module)
-      end
-
-      def save_selected_roles_params
-        params.permit(roles: %i[id selected])
-      end
     end
   end
 end

data/app/helpers/mks/auth/access_helper.rb

@@ -0,0 +1,47 @@
+module Mks
+  module Auth
+    module AccessHelper
+      def login_user(user)
+        session[:user_id] = user.id
+      end
+
+      def current_user
+        @current_user ||= User.find_by(id: session[:user_id])
+      end
+
+      def logged_in?
+        !current_user.nil?
+      end
+
+      def logout_user
+        session.delete(:user_id)
+        @current_user = nil
+        @menus = nil
+      end
+
+      def fetch_menus
+        if @menus.nil?
+          roles = current_user.roles
+          app_module = current_user.application_module
+
+          @menus = []
+          roles.each do |role|
+            if role
+              menu_list = role.menus.where(:parent => nil, :application_module => app_module)
+              menu_list.each do |menu|
+                children = []
+                menu.children.order(:text).each do |child|
+                  if child.roles.include? role
+                    children << {'text': child.text, 'className': child.class_name, 'iconCls': child.icon_cls}
+                  end
+                end
+                @menus << {'text': menu.text, 'children': children, 'iconCls': menu.icon_cls}
+              end
+            end
+          end
+        end
+        @menus
+      end
+    end
+  end
+end