Pattern migliore per garantire una singola responsabilità

Ecco uno schema migliore qui per garantire che i miei metodi seguano il principio della responsabilità unica. Ho un controller DRY carino, che penso abbia un senso ed è conciso.

Ecco il mio controller:

class CredsController < ApplicationController
  include CredsConcern
  skip_before_action :verify_authenticity_token
  attr_reader :marketplace, :seller_id, :auth_token, :main_marketplace_flag

  def credentials_check
    parse_params
    client_data = create_client(marketplace, seller_id, auth_token, main_marketplace_flag)
    render json: {creds_status: client_data, main_marketplace_flag: make_sure_only_one_main_marketplace}
  end

  private

  def parse_params
    @marketplace = params["marketplace"]
    @seller_id = params["seller_id"]
    @auth_token = params["auth_token"]
    @main_marketplace_flag = params["main"]
  end
end

Ho estratto la maggior parte del codice in un concern che inizia a mescolare le responsabilità nei miei metodi. Lo faccio in modo da poter chiamare un metodo nel mio controller e esegue tutti o la maggior parte dei metodi nella preoccupazione. Ciò rende il mio controller piacevole e ordinato, ma penso che inizi a confondere i metodi nel mio concern . Il problema è che non riesco a pensare a un modo per evitare questo schema. Ciò è particolarmente evidente nel mio metodo create_client di seguito. Creo il client, ma lo collaudo, eseguo altre funzioni di amministrazione, salvo le credenziali e quindi le restituisco, tutte nello stesso metodo.

Ecco la mia preoccupazione:

module CredsConcern
extend ActiveSupport::Concern
include SqsConcern

  attr_reader :access_key, :secret_access_key, :client, :client_status, 
              :marketplace, :seller_id, :auth_token, :main_marketplace_flag

  def create_client(marketplace, seller_id, auth_token, main_marketplace_flag)
      keys = which_keys_to_use?(marketplace)
      @amazon_client = MWS::FulfillmentOutboundShipment::Client.new(
                      marketplace_id:        "#{marketplace}",
                      merchant_id:           "#{seller_id}",
                      aws_access_key_id:     "#{keys[:access_key]}",
                      aws_secret_access_key: "#{keys[:secret_access_key]}",
                      auth_token:            "#{auth_token}")
      test_client
      make_sure_only_one_main_marketplace
      save_creds(marketplace, seller_id, auth_token, main_marketplace_flag)
      return client_status
  end

private

  def test_client
    @client_status = "good"
    begin
      client.list_all_fulfillment_orders.parse
    rescue StandardError
      @client_status = "bad"
    end
  end

  def save_creds(marketplace, seller_id, auth_token, main_marketplace_flag)
    if amazon_client_status == "good"
      current_shop.find_or_create_by(seller_id: seller_id) do |credentials|
        credentials.update_attributes(
        marketplace: marketplace,
        seller_id: seller_id,
        auth_token: auth_token,
        main_marketplace_flag: main_marketplace_flag)
      sqs = SqsConcern.new(marketplace, seller_id)
      sqs.create_sqs_subscription
      end
    update_shop_setup
    end
  end

  def update_shop_setup
    current_shop.update_attributes(setup: true)
  end

  def make_sure_only_one_main_marketplace
    flag_array = []
    @marketplace_status = "no_dups"
    current_shop.each do |flag|
      flag_array << flag.main_marketplace_flag
    end
    if flag_array.include?(true)
      @marketplace_status = "duplicate"
    end
    return @marketplace_status
  end
end

Come posso rendere i metodi che mi interessano seguire il modello di responsabilità singola?