mks_auth 1.0.11 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 227d86604956d17a721112c90dad92ee76a7bcffbed19e27a37b3c719d574f71
-  data.tar.gz: 9ed99b708d3353045f38dc58c5326195cec7d055139ddb2abfef5745e626b59c
+  metadata.gz: bb9f3e4044ff6afdd5fb2976a8b9cdbcd2a3eb9140f1c7f21565e912e963ef92
+  data.tar.gz: f7d39dedae27d2e95bd7052c5e90dadc679132048d51b4acdf0b914ea2ba36cb
 SHA512:
-  metadata.gz: 2a4a520ff71bc5209cf919107bbcac89b72a83cd337cffb56679401c963dd5f397ddaa72161363c3f5b1e44e6af74c2001bc5a3b8c37fa9883ddfc3f4bcbc116
-  data.tar.gz: 26b064e717abb1629211f1b469d69e09f986aedd67d072ca4332e75673060c464f5692a3df9617870da82cee47285b77972bd3bb9732204b149a80549c700cbb
+  metadata.gz: e33d69f6e00b0e8948ad65ed8e25db87654023f69eda3c1e4ba6bc5f30e7297e8a6f33ba13c61d29ffa9eccb78d995e265f81a0b88c9b1f7a30cd2f2ebe94b4a
+  data.tar.gz: f4a4465366f78f1087793b00a74741a6a611f01e0a9867ce07fea31ad671ab6cadf2402316eec93edf6c760bbf6a7dc5f55d8f90c926d5c38b53ca9ee9eb09dc

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,51 +1,24 @@
-require 'mks/auth/token_auth'
-require 'mks/common/methodresponse'
-
 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: Mks::Common::MethodResponse.success_response(@user)
+          response = { success: true, message: 'User saved successfully' }
+          render json: response
         else
-          render json: Mks::Common::MethodResponse.failure_response(@user), 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: Mks::Common::MethodResponse.success_response(@user)
-        else
-          render json: Mks::Common::MethodResponse.failure_response(@user), 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

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

@@ -0,0 +1,10 @@
+module Mks
+  module Auth
+    module ApplicationHelper
+      def app_module
+        code = Rails.configuration.app_code
+        ApplicationModule.find_by(code: code)
+      end
+    end
+  end
+end

data/app/models/mks/auth/application_module.rb

@@ -1,12 +1,12 @@
 module Mks
   module Auth
-    # A model class to represent applications / modules
     class ApplicationModule < ApplicationRecord
+      #self.table_name = 'mks_application_modules'
+
       validates :code, presence: true
       validates :code, presence: true, uniqueness: true
 
-      has_and_belongs_to_many :users, class_name: 'Mks::Auth::User',
-                                      join_table: 'mks_auth_users_application_modules'
+      has_many :users, class_name: 'Mks::Auth::User'
       has_many :menus, class_name: 'Mks::Auth::Menu'
     end
   end

data/app/models/mks/auth/menu.rb

@@ -1,12 +1,12 @@
 module Mks
   module Auth
-    # A model class to represent menu items of a module
     class Menu < ApplicationRecord
+      # self.table_name = 'mks_menus'
+
       belongs_to :application_module, class_name: 'Mks::Auth::ApplicationModule'
       belongs_to :parent, class_name: 'Mks::Auth::Menu', optional: true
-      has_many :children, class_name: 'Mks::Auth::Menu', foreign_key: 'parent_id'
-      has_and_belongs_to_many :roles, class_name: 'Mks::Auth::UserRole',
-                                      join_table: 'mks_auth_menus_user_roles'
+      has_many :children, class_name: 'Mks::Auth::Menu', :foreign_key => 'parent_id'
+      has_and_belongs_to_many :roles, class_name: 'Mks::Auth::UserRole', :join_table => :mks_auth_menus_user_roles
     end
   end
-end
+end

data/app/models/mks/auth/user.rb

@@ -1,50 +1,24 @@
-# frozen_string_literal: true
-
 module Mks
   module Auth
-    # A model class to represent users of the system
     class User < ApplicationRecord
-      has_and_belongs_to_many :application_modules,
-                              class_name: 'Mks::Auth::ApplicationModule',
-                              join_table: 'mks_auth_users_application_modules'
-      has_and_belongs_to_many :roles, class_name: 'Mks::Auth::UserRole',
-                                      join_table: 'mks_auth_users_user_roles'
+      # self.table_name = 'mks_users'
+
+      belongs_to :application_module, class_name: 'Mks::Auth::ApplicationModule'
+      has_and_belongs_to_many :roles, class_name: 'Mks::Auth::UserRole', join_table: :mks_auth_users_user_roles
       has_secure_password
 
       before_save { email.downcase! }
 
       VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
-      validates :first_name, presence: true, length: { maximum: 30 }
-      validates :last_name, presence: true, length: { maximum: 30 }
-      validates :email, presence: true, format: { with: VALID_EMAIL_REGEX }, uniqueness: { case_sensitive: false }
+      validates :first_name, presence: true, length: {maximum: 30}
+      validates :last_name, presence: true, length: {maximum: 30}
+      validates :email, presence: true, format: { with: VALID_EMAIL_REGEX }, uniqueness: {case_sensitive: false}
       validates :password, length: { minimum: 6 }
       validates :active, presence: true
 
       def full_name
         "#{first_name} #{last_name}"
       end
-
-      def role_names
-        roles.map(&:name)
-      end
-
-      def to_token_payload
-        { id: id, email: email, name: full_name, roles: role_names }
-      end
-
-      def has_module(code)
-        app_module = ApplicationModule.find_by(code: code)
-        roles = self.roles.select { |ur| ur.application_module == app_module }
-        roles.count.positive?
-      end
-
-      def role?(role)
-        roles.any? { |r| r.name.underscore.to_sym == role }
-      end
-
-      def any_role?(role_list)
-        roles.any? { |r| role_list.include?(r.name.underscore.to_sym) }
-      end
     end
   end
-end
+end