sleede / fab-manager / #98

pending completion

Build # #98

Build Type

push

coveralls-ruby

Committed by

sylvainbx

Commit Message

Merge branch 'dev' for release 5.7.0

Run Details

1368 of 1368 new or added lines in 161 files covered. (100.0%)

7383 of 12030 relevant lines covered (61.37%)

14.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.0

/app/controllers/api/settings_controller.rb

# frozen_string_literal: true

# API Controller for resources of type Setting
class API::SettingsController < API::ApiController
  before_action :authenticate_user!, only: %i[update bulk_update reset]

  def index
    @settings = policy_scope(Setting.where(name: names_as_string_to_array))
  end

  def update
    authorize Setting
    @setting = Setting.find_or_initialize_by(name: params[:name])
    render status: :not_modified and return if setting_params[:value] == @setting.value
    render status: :locked, json: { error: I18n.t('settings.locked_setting') } and return unless SettingService.update_allowed?(@setting)

    error = SettingService.check_before_update({ name: params[:name], value: setting_params[:value] })
    render status: :unprocessable_entity, json: { error: error } and return if error

    if @setting.save && @setting.history_values.create(value: setting_params[:value], invoicing_profile: current_user.invoicing_profile)
      SettingService.run_after_update([@setting])
      render status: :ok
    else
      render json: @setting.errors.full_messages, status: :unprocessable_entity
    end
  end

  def bulk_update
    authorize Setting

    @settings = []
    updated_settings = []
    may_transaction params[:transactional] do
      params[:settings].each do |setting|
        next if !setting[:name] || !setting[:value] || setting[:value].blank?

        db_setting = Setting.find_or_initialize_by(name: setting[:name])
        if SettingService.update_allowed?(db_setting)
          error = SettingService.check_before_update(setting)
          if error
            db_setting.errors.add(:-, "#{I18n.t("settings.#{setting[:name]}")}: #{error}")
          elsif db_setting.save
            if db_setting.value != setting[:value] &&
               db_setting.history_values.create(value: setting[:value], invoicing_profile: current_user.invoicing_profile)
              updated_settings.push(db_setting)
            end
          end
        else
          db_setting.errors.add(:-, "#{I18n.t("settings.#{setting[:name]}")}: #{I18n.t('settings.locked_setting')}")
        end

        @settings.push db_setting
        may_rollback(params[:transactional]) if db_setting.errors.keys.count.positive?
      end
    end
    SettingService.run_after_update(updated_settings)
  end

  def show
    authorize SettingContext.new(params[:name])

    @setting = Setting.find_or_create_by(name: params[:name])
    @show_history = params[:history] == 'true' && current_user.admin?
  end

  def test_present
    authorize SettingContext.new(params[:name])

    @setting = Setting.get(params[:name])
  end

  def reset
    authorize Setting

    setting = Setting.find_or_create_by(name: params[:name])
    render status: :locked, json: { error: 'locked setting' } and return unless SettingService.update_allowed?(setting)

    first_val = setting.history_values.order(created_at: :asc).limit(1).first
    new_val = HistoryValue.create!(
      setting_id: setting.id,
      value: first_val&.value,
      invoicing_profile_id: current_user.invoicing_profile.id
    )
    SettingService.run_after_update([setting])
    render json: new_val, status: :ok
  end

  private

  def setting_params
    params.require(:setting).permit(:value)
  end

  def names_as_string_to_array
    params[:names][1..-2].split(',').map(&:strip).map { |param| param[1..-2] }.map(&:strip)
  end

  # run the given block in a transaction if `should` is true. Just run it normally otherwise
  def may_transaction(should, &block)
    if should == 'true'
      ActiveRecord::Base.transaction(&block)
    else
      yield
    end
  end

  # rollback the current DB transaction if `should` is true
  def may_rollback(should)
    raise ActiveRecord::Rollback if should == 'true'
  end
end

1	# frozen_string_literal: true
2
3	# API Controller for resources of type Setting
4	class API::SettingsController < API::ApiController	1✔
5	before_action :authenticate_user!, only: %i[update bulk_update reset]	1✔
6
7	def index	1✔
8	@settings = policy_scope(Setting.where(name: names_as_string_to_array))	×
9	end
10
11	def update	1✔
12	authorize Setting	2✔
13	@setting = Setting.find_or_initialize_by(name: params[:name])	2✔
14	render status: :not_modified and return if setting_params[:value] == @setting.value	2✔
15	render status: :locked, json: { error: I18n.t('settings.locked_setting') } and return unless SettingService.update_allowed?(@setting)	2✔
16
17	error = SettingService.check_before_update({ name: params[:name], value: setting_params[:value] })	2✔
18	render status: :unprocessable_entity, json: { error: error } and return if error	2✔
19
20	if @setting.save && @setting.history_values.create(value: setting_params[:value], invoicing_profile: current_user.invoicing_profile)	2✔
21	SettingService.run_after_update([@setting])	1✔
22	render status: :ok	1✔
23	else
24	render json: @setting.errors.full_messages, status: :unprocessable_entity	1✔
25	end
26	end
27
28	def bulk_update	1✔
29	authorize Setting	×
30
31	@settings = []	×
32	updated_settings = []	×
33	may_transaction params[:transactional] do	×
34	params[:settings].each do \|setting\|	×
35	next if !setting[:name] \|\| !setting[:value] \|\| setting[:value].blank?	×
36
37	db_setting = Setting.find_or_initialize_by(name: setting[:name])	×
38	if SettingService.update_allowed?(db_setting)	×
39	error = SettingService.check_before_update(setting)	×
40	if error	×
41	db_setting.errors.add(:-, "#{I18n.t("settings.#{setting[:name]}")}: #{error}")	×
42	elsif db_setting.save	×
43	if db_setting.value != setting[:value] &&	×
44	db_setting.history_values.create(value: setting[:value], invoicing_profile: current_user.invoicing_profile)
45	updated_settings.push(db_setting)	×
46	end
47	end
48	else
49	db_setting.errors.add(:-, "#{I18n.t("settings.#{setting[:name]}")}: #{I18n.t('settings.locked_setting')}")	×
50	end
51
52	@settings.push db_setting	×
53	may_rollback(params[:transactional]) if db_setting.errors.keys.count.positive?	×
54	end
55	end
56	SettingService.run_after_update(updated_settings)	×
57	end
58
59	def show	1✔
60	authorize SettingContext.new(params[:name])	1✔
61
62	@setting = Setting.find_or_create_by(name: params[:name])	1✔
63	@show_history = params[:history] == 'true' && current_user.admin?	1✔
64	end
65
66	def test_present	1✔
67	authorize SettingContext.new(params[:name])	×
68
69	@setting = Setting.get(params[:name])	×
70	end
71
72	def reset	1✔
73	authorize Setting	×
74
75	setting = Setting.find_or_create_by(name: params[:name])	×
76	render status: :locked, json: { error: 'locked setting' } and return unless SettingService.update_allowed?(setting)	×
77
78	first_val = setting.history_values.order(created_at: :asc).limit(1).first	×
79	new_val = HistoryValue.create!(	×
80	setting_id: setting.id,
81	value: first_val&.value,
82	invoicing_profile_id: current_user.invoicing_profile.id
83	)
84	SettingService.run_after_update([setting])	×
85	render json: new_val, status: :ok	×
86	end
87
88	private	1✔
89
90	def setting_params	1✔
91	params.require(:setting).permit(:value)	5✔
92	end
93
94	def names_as_string_to_array	1✔
95	params[:names][1..-2].split(',').map(&:strip).map { \|param\| param[1..-2] }.map(&:strip)	×
96	end
97
98	# run the given block in a transaction if `should` is true. Just run it normally otherwise
99	def may_transaction(should, &block)	1✔
100	if should == 'true'	×
101	ActiveRecord::Base.transaction(&block)	×
102	else
103	yield	×
104	end
105	end
106
107	# rollback the current DB transaction if `should` is true
108	def may_rollback(should)	1✔
109	raise ActiveRecord::Rollback if should == 'true'	×
110	end
111	end

sleede / fab-manager / #98

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous