better multiple fields validation on ruby/rails

Question

I have a form for an item (Job Item), that has sets of 2 fields based on a type.

field and field + _dolar

e.g: cogs_paid and cogs_paid_dollar

validation example: cogs_paid or cogs_paid_dollar, if both are empty, validation fails. This goes for all sub-fields.

What I did, my current Model:

 class JobItem < ActiveRecord::Base

  COGS_REQUIRED_TYPES = [
    ContentType::Brief,
    ContentType::Feature,
    ContentType::Fish,
    ContentType::Paid,
    ContentType::Print,
    ContentType::Target
  ].freeze

  include MessageBroker
  message_broker model_name: 'JobItem'

  belongs_to :job

  validates :weekly_budget, presence: { if: -> { COGS_REQUIRED_TYPES.include?(content_type) } }

  validates :cogs_brief_write_lead,
    presence: {
      if: -> { content_type == ContentType::Brief && cogs_brief_write_lead_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_brief_write_copy,
    presence: {
      if: -> { content_type == ContentType::Brief && cogs_brief_write_copy_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_brief_copy_edit,
    presence: {
      if: -> { content_type == ContentType::Brief && cogs_brief_copy_edit_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_write_lead,
    presence: {
      if: -> { content_type == ContentType::Feature && cogs_write_lead_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_interview,
    presence: {
      if: -> { content_type == ContentType::Feature && cogs_interview_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_write_feature,
    presence: {
      if: -> { content_type == ContentType::Feature && cogs_write_feature_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_content_edit,
    presence: {
      if: -> { content_type == ContentType::Feature && cogs_content_edit_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_copy_edit,
    presence: {
      if: -> { content_type == ContentType::Feature && cogs_copy_edit_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_paid_write_lead,
    presence: {
      if: -> { content_type == ContentType::Paid && cogs_paid_write_lead_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_paid_interview_research,
    presence: {
      if: -> { content_type == ContentType::Paid && cogs_paid_interview_research_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_paid_write_copy,
    presence: {
      if: -> { content_type == ContentType::Paid && cogs_paid_write_copy_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_paid_copy_edit,
    presence: {
      if: -> { content_type == ContentType::Paid && cogs_paid_copy_edit_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_paid_review,
    presence: {
      if: -> { content_type == ContentType::Paid && cogs_paid_review_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_paid_publish,
    presence: {
      if: -> { content_type == ContentType::Paid && cogs_paid_publish_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_design,
    presence: {
      if: -> { content_type == ContentType::Print && cogs_design_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_page_edit,
    presence: {
      if: -> { content_type == ContentType::Print && cogs_page_edit_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_page_proof,
    presence: {
      if: -> { content_type == ContentType::Print && cogs_page_proof_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  validates :cogs_photo_toning,
    presence: {
      if: -> { content_type == ContentType::Print && cogs_photo_toning_dollar.blank? },
      message: 'cant be empty or provide COGS Actual Cost matching entry',
    }

  def content_type=(value)
    new_type = ContentType.find(value)
    self[:content_type] = new_type ? new_type.id.to_s : nil
  end

  ContentType.types.each do |method, klass|
    define_method :"#{method}?" do
      content_type == klass
    end
  end


end

I currently have 20+ validations like the one above on my model, (for each sub-field and its type) which looks pretty ugly.

Any suggestions on how one would improve this, and reduce repetition?

What changes on every validation is:

field ; field+_dollar

content_type being compared: e.g ContentType::Paid

Answer 1

Changed to, on the model

  COGS_FIELDS_PRESENCE = [
    [content_type: 'brief', cogs_field: 'cogs_brief_write_lead', cogs_field_dollar: 'cogs_brief_write_lead_dollar'],
    [content_type: 'brief', cogs_field: 'cogs_brief_write_copy', cogs_field_dollar: 'cogs_brief_write_copy_dollar'],
    .
    .
    . + 20 entries

  ]


  def cogs_fields_presence
    COGS_FIELDS_PRESENCE.flatten.each do |field|
      if content_type.to_s == field[:content_type] && self[field[:cogs_field]].blank? && self[field[:cogs_field_dollar]].blank?
        errors.add(field[:cogs_field], 'cant be empty or provide COGS Actual Cost matching entry')
      end
    end
  end