kaui 2.1.0 → 3.0.1

data/app/controllers/kaui/admin_allowed_users_controller.rb

@@ -1,132 +1,138 @@
-class Kaui::AdminAllowedUsersController < Kaui::EngineController
+# frozen_string_literal: true
 
-  skip_before_action :check_for_redirect_to_tenant_screen
+module Kaui
+  class AdminAllowedUsersController < Kaui::EngineController
+    skip_before_action :check_for_redirect_to_tenant_screen
 
-  def index
-    @allowed_users = retrieve_allowed_users_for_current_user
-  end
+    def index
+      @allowed_users = retrieve_allowed_users_for_current_user
+    end
 
-  def new
-    @allowed_user = Kaui::AllowedUser.new
-    @is_killbill_managed = true
+    def new
+      @allowed_user = Kaui::AllowedUser.new
+      @is_killbill_managed = true
 
-    @roles = []
-  end
+      @roles = []
+    end
 
-  def create
-    @is_killbill_managed = nil
-    @allowed_user = Kaui::AllowedUser.new(allowed_user_params)
-
-    existing_user = Kaui::AllowedUser.find_by_kb_username(@allowed_user.kb_username)
-    unless existing_user.blank?
-      flash[:error] = "User with name #{@allowed_user.kb_username} already exists!"
-      @roles = roles_for_user(existing_user)
-      render :new and return
-    else
-      if params[:external] == '1'
-        # Create locally only
-        @allowed_user.save!
+    def create
+      @is_killbill_managed = nil
+      @allowed_user = Kaui::AllowedUser.new(allowed_user_params)
+
+      existing_user = Kaui::AllowedUser.find_by_kb_username(@allowed_user.kb_username)
+      if existing_user.blank?
+        if params[:external] == '1'
+          # Create locally only
+          @allowed_user.save!
+        else
+          @allowed_user.create_in_kb!(params.require(:password),
+                                      params[:roles].blank? ? [] : params[:roles].split(','),
+                                      current_user.kb_username,
+                                      params[:reason],
+                                      params[:comment],
+                                      options_for_klient)
+        end
+
+        redirect_to kaui_engine.admin_allowed_user_path(@allowed_user.id), notice: 'User was successfully configured'
       else
-        @allowed_user.create_in_kb!(params.require(:password) ,
-                                  params[:roles].blank? ? [] : params[:roles].split(','),
-                                  current_user.kb_username,
-                                  params[:reason],
-                                  params[:comment],
-                                  options_for_klient)
+        flash[:error] = "User with name #{@allowed_user.kb_username} already exists!"
+        @roles = roles_for_user(existing_user)
+        render :new and return
       end
-
-      redirect_to kaui_engine.admin_allowed_user_path(@allowed_user.id), :notice => 'User was successfully configured'
     end
-  end
 
-  def show
-    @allowed_user = Kaui::AllowedUser.find(params.require(:id))
-    raise ActiveRecord::RecordNotFound.new("Could not find user #{@allowed_user.id}") unless (current_user.root? || @allowed_user.kb_username == current_user.kb_username)
+    def show
+      @allowed_user = Kaui::AllowedUser.find(params.require(:id))
+      raise ActiveRecord::RecordNotFound, "Could not find user #{@allowed_user.id}" unless current_user.root? || @allowed_user.kb_username == current_user.kb_username
 
-    @roles = roles_for_user(@allowed_user)
+      @roles = roles_for_user(@allowed_user)
 
-    tenants_for_current_user = retrieve_tenants_for_current_user
-    @tenants = Kaui::Tenant.all.select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }
-  end
-
-  def edit
-    @allowed_user = Kaui::AllowedUser.find(params.require(:id))
-    @is_killbill_managed = killbill_managed?(@allowed_user, options_for_klient)
-
-    @roles = roles_for_user(@allowed_user)
-  end
+      tenants_for_current_user = retrieve_tenants_for_current_user
+      @tenants = Kaui::Tenant.all.select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }
+    end
 
-  def update
-    @allowed_user = Kaui::AllowedUser.find(params.require(:id))
+    def edit
+      @allowed_user = Kaui::AllowedUser.find(params.require(:id))
+      @is_killbill_managed = killbill_managed?(@allowed_user, options_for_klient)
 
-    @allowed_user.description = params[:allowed_user][:description].presence
+      @roles = roles_for_user(@allowed_user)
+    end
 
-    @allowed_user.update_in_kb!(params[:password].presence,
-                                params[:roles].blank? ? nil : params[:roles].split(','),
-                                current_user.kb_username,
-                                params[:reason],
-                                params[:comment],
-                                options_for_klient)
+    def update
+      @allowed_user = Kaui::AllowedUser.find(params.require(:id))
 
-    redirect_to kaui_engine.admin_allowed_user_path(@allowed_user.id), :notice => 'User was successfully updated'
-  end
+      @allowed_user.description = params[:allowed_user][:description].presence
 
-  def destroy
-    allowed_user = Kaui::AllowedUser.find(params.require(:id))
+      @allowed_user.update_in_kb!(params[:password].presence,
+                                  params[:roles].blank? ? nil : params[:roles].split(','),
+                                  current_user.kb_username,
+                                  params[:reason],
+                                  params[:comment],
+                                  options_for_klient)
 
-    if allowed_user
-      # Delete locally and in KB
-      allowed_user.destroy_in_kb!(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.admin_allowed_users_path, :notice => 'User was successfully deleted'
-    else
-      flash[:error] = "User #{params.require(:id)} not found"
-      redirect_to kaui_engine.admin_allowed_users_path
+      redirect_to kaui_engine.admin_allowed_user_path(@allowed_user.id), notice: 'User was successfully updated'
     end
-  end
 
-  def add_tenant
-    allowed_user = Kaui::AllowedUser.find(params.require(:allowed_user).require(:id))
+    def destroy
+      allowed_user = Kaui::AllowedUser.find(params.require(:id))
 
-    if !current_user.root?
-      redirect_to admin_allowed_user_path(allowed_user.id), :alert => 'Only the root user can set tenants for user'
-      return
+      if allowed_user
+        # Delete locally and in KB
+        allowed_user.destroy_in_kb!(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        redirect_to kaui_engine.admin_allowed_users_path, notice: 'User was successfully deleted'
+      else
+        flash[:error] = "User #{params.require(:id)} not found"
+        redirect_to kaui_engine.admin_allowed_users_path
+      end
     end
 
-    tenants = []
-    params.each do |tenant, _|
-      tenant_info = tenant.split('_')
-      next if tenant_info.size != 2 or tenant_info[0] != 'tenant'
-      tenants << tenant_info[1]
-    end
+    def add_tenant
+      allowed_user = Kaui::AllowedUser.find(params.require(:allowed_user).require(:id))
 
-    tenants_for_current_user = retrieve_tenants_for_current_user
-    tenants = (Kaui::Tenant.where(:id => tenants).select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }).map(&:id)
+      unless current_user.root?
+        redirect_to admin_allowed_user_path(allowed_user.id), alert: 'Only the root user can set tenants for user'
+        return
+      end
 
-    allowed_user.kaui_tenant_ids = tenants
+      tenants = []
+      params.each do |tenant, _|
+        tenant_info = tenant.split('_')
+        next if (tenant_info.size != 2) || (tenant_info[0] != 'tenant')
 
-    redirect_to admin_allowed_user_path(allowed_user.id), :notice => 'Successfully set tenants for user'
-  end
+        tenants << tenant_info[1]
+      end
 
-  private
+      tenants_for_current_user = retrieve_tenants_for_current_user
+      tenants = (Kaui::Tenant.where(id: tenants).select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }).map(&:id)
 
-  # this will check if the user is managed by killbill (not managed externally or internally by a shiro config file).
-  def killbill_managed?(allowed_user, options = {})
-    begin
-      Kaui::UserRole.find_roles_by_username(allowed_user.kb_username, options)
-    rescue KillBillClient::API::ClientError => _
-      return false
+      allowed_user.kaui_tenant_ids = tenants
+
+      redirect_to admin_allowed_user_path(allowed_user.id), notice: 'Successfully set tenants for user'
     end
 
-    return true
-  end
+    private
 
-  def allowed_user_params
-    allowed_user = params.require(:allowed_user)
-    allowed_user.require(:kb_username)
-    allowed_user.permit!
-  end
+    # this will check if the user is managed by killbill (not managed externally or internally by a shiro config file).
+    def killbill_managed?(allowed_user, options = {})
+      begin
+        Kaui::UserRole.find_roles_by_username(allowed_user.kb_username, options)
+      rescue KillBillClient::API::ClientError => _e
+        return false
+      end
 
-  def roles_for_user(allowed_user)
-    Kaui::UserRole.find_roles_by_username(allowed_user.kb_username, options_for_klient).map(&:presence).compact rescue []
+      true
+    end
+
+    def allowed_user_params
+      allowed_user = params.require(:allowed_user)
+      allowed_user.require(:kb_username)
+      allowed_user.permit!
+    end
+
+    def roles_for_user(allowed_user)
+      Kaui::UserRole.find_roles_by_username(allowed_user.kb_username, options_for_klient).map(&:presence).compact
+    rescue StandardError
+      []
+    end
   end
 end

data/app/controllers/kaui/admin_controller.rb

@@ -1,40 +1,41 @@
-class Kaui::AdminController < Kaui::EngineController
+# frozen_string_literal: true
 
-  skip_before_action :check_for_redirect_to_tenant_screen
+module Kaui
+  class AdminController < Kaui::EngineController
+    skip_before_action :check_for_redirect_to_tenant_screen
 
-  def index
-    begin
-      @clock = Kaui::Admin.get_clock(nil, options_for_klient)
-    rescue KillBillClient::API::NotFound
-      flash[:error] = "Failed to get current KB clock: Kill Bill server must be started with system property org.killbill.server.test.mode=true"
-      redirect_to admin_tenants_path and return
-    end
+    def index
+      begin
+        @clock = Kaui::Admin.get_clock(nil, options_for_klient)
+      rescue KillBillClient::API::NotFound
+        flash[:error] = 'Failed to get current KB clock: Kill Bill server must be started with system property org.killbill.server.test.mode=true'
+        redirect_to admin_tenants_path and return
+      end
 
-    params.permit!
+      params.permit!
 
-    respond_to do |format|
-      format.html
-      format.js
+      respond_to do |format|
+        format.html
+        format.js
+      end
     end
-  end
 
-  def set_clock
-    if params[:commit] == 'Submit'
-      current_datetime = DateTime.parse(Kaui::Admin.get_clock(nil, options_for_klient)['currentUtcTime'])
-      new_local_date = Date.parse(params[:new_date])
-      new_datetime = DateTime.new(new_local_date.year, new_local_date.month, new_local_date.day, current_datetime.hour, current_datetime.min, current_datetime.sec, 'Z').to_s
-      msg = "Clock was successfully updated to #{new_datetime}"
-    else
-      new_datetime = nil
-      msg = 'Clock was successfully reset'
-    end
-    begin
-      Kaui::Admin.set_clock(new_datetime, nil, options_for_klient)
-    rescue KillBillClient::API::NotFound
-      flash[:error] = "Failed to set current KB clock: Kill Bill server must be started with system property org.killbill.server.test.mode=true"
-      redirect_to admin_tenants_path and return
-    end
+    def set_clock
+      if params[:commit] == 'Submit'
+        date = Date.parse(params[:new_date]).strftime('%Y-%m-%d')
+        msg = I18n.translate('flashes.notices.clock_updated_successfully', new_date: date)
+      else
+        date = nil
+        msg = I18n.translate('flashes.notices.clock_reset_successfully')
+      end
+      begin
+        Kaui::Admin.set_clock(date, nil, options_for_klient)
+      rescue KillBillClient::API::NotFound
+        flash[:error] = 'Failed to set current KB clock: Kill Bill server must be started with system property org.killbill.server.test.mode=true'
+        redirect_to admin_tenants_path and return
+      end
 
-    redirect_to admin_path, :notice => msg
+      redirect_to admin_path, notice: msg
+    end
   end
 end