spree_cm_commissioner 2.8.2.pre.pre.2 → 2.8.2

data/app/models/spree_cm_commissioner/show.rb

@@ -1,159 +0,0 @@
-module SpreeCmCommissioner
-  class Show < Spree::Taxon
-    include SpreeCmCommissioner::StoreMetadata
-
-    has_many :voting_credits, class_name: 'SpreeCmCommissioner::VotingCredit', as: :votable, dependent: :destroy
-    belongs_to :show, class_name: 'SpreeCmCommissioner::Show', foreign_key: :parent_id, optional: true
-    has_many :seasons, class_name: 'SpreeCmCommissioner::Show', foreign_key: :parent_id, inverse_of: :parent
-    has_many :show_contestants, class_name: 'SpreeCmCommissioner::ShowContestant', inverse_of: :show, dependent: :destroy
-    has_many :show_people_assignments, class_name: 'SpreeCmCommissioner::ShowPersonAssignment', dependent: :destroy
-    has_many :show_people, through: :show_people_assignments, source: :show_person
-    has_many :episodes, class_name: 'SpreeCmCommissioner::ShowEpisode', foreign_key: :event_id
-    has_many :voting_sessions, through: :episodes, class_name: 'SpreeCmCommissioner::VotingSession'
-    has_one :current_episode, -> { current_or_next_upcoming }, class_name: 'SpreeCmCommissioner::ShowEpisode', foreign_key: :event_id
-    has_one :current_voting_session, through: :current_episode
-
-    before_validation { self.type = self.class.name }
-    before_validation { self.kind = :event }
-    before_validation :assign_taxonomy_and_parent, on: :create
-
-    store_private_metadata :season_number, :integer
-    store_private_metadata :season_year, :integer
-
-    # Define standard voting configuration keys
-    store_accessor :voting_config,
-                   :free_vote_limit,
-                   :free_vote_limit_type,
-                   :paid_vote_enabled,
-                   :max_paid_votes_per_session,
-                   :sms_vote_enabled,
-                   :sms_vote_cost_usd,
-                   :operator_vote_enabled,
-                   :votes_weight,
-                   :voters_weight
-
-    # voting_credit_scope determines how purchased vote credits are grouped (scoped).
-    # Changing this after credits have been allocated will cause inconsistencies:
-    #   - existing credits are scoped to the old type (e.g. ShowEpisode),
-    #     but new purchases will create credits under the new type (e.g. Show),
-    #     leading to split balances that cannot be merged.
-    # UI rule: once voting_credit_scope is set and any VotingCredit exists for this show, the field must be read-only — do not allow changes.
-    # Note: VoteCredit of user should base on CREDIT_SCOPES
-    #   - if scope is Show, User's credits should be only 1 per show, and can be used for any episode under the show.
-    #   - if scope is ShowEpisode, User's credits should be N per show (N is the number of episodes), and can be only used for specific episode.
-    #   - if scope is VotingSession, User's credits should be N per show (N is the number of voting sessions), and can be only used for specific voting session. # rubocop:disable Layout/LineLength
-    CREDIT_SCOPES = {
-      'Show' => { free_vote_limit_type: 'per_show' }.freeze,
-      'ShowEpisode' => { free_vote_limit_type: 'per_episode' }.freeze,
-      'VotingSession' => { free_vote_limit_type: 'per_voting_session' }.freeze
-    }.freeze
-
-    def self.polymorphic_name
-      name
-    end
-
-    validate :voting_credit_scope_immutable, if: :voting_credit_scope_changed?
-
-    def credit_votable_type
-      voting_credit_scope = self[:voting_credit_scope] || 'ShowEpisode'
-
-      type = CREDIT_SCOPES.key?(voting_credit_scope) ? voting_credit_scope : 'ShowEpisode'
-      "SpreeCmCommissioner::#{type}"
-    end
-
-    def free_vote_idempotency_key(user_id:, votable_id: nil)
-      case free_vote_limit_type
-      when 'per_episode'        then "free_claim::episode::#{votable_id}::user::#{user_id}"
-      when 'per_voting_session' then "free_claim::voting_session::#{votable_id}::user::#{user_id}"
-      when 'per_show'           then "free_claim::show::#{id}::user::#{user_id}"
-      else raise ArgumentError, "Invalid free_vote_limit_type: #{free_vote_limit_type}"
-      end
-    end
-
-    # Define standard fraud configuration keys
-    store_accessor :fraud_config,
-                   :max_votes_per_minute_per_user,
-                   :max_votes_per_minute_per_ip,
-                   :max_accounts_per_device,
-                   :block_vpn
-
-    def show?
-      depth == 1
-    end
-
-    def season?
-      depth == 2
-    end
-
-    def display_name
-      if season? && parent.present?
-        "#{parent.name} #{name}"
-      else
-        name
-      end
-    end
-
-    def contestants
-      show_contestants
-    end
-
-    def effective_voting_config
-      config = parse_json_config(voting_config)
-      return config if show?
-
-      config.reverse_merge(parent&.effective_voting_config || {})
-    end
-
-    def effective_fraud_config
-      config = parse_json_config(fraud_config)
-      return config if show?
-
-      config.reverse_merge(parent&.effective_fraud_config || {})
-    end
-
-    def build_next_season(attributes = {})
-      last_season = seasons.order(created_at: :desc).first
-
-      default_number = (last_season&.season_number || 0) + 1
-      default_year = last_season&.season_year || Time.current.year
-
-      seasons.new(
-        {
-          season_number: default_number,
-          season_year: default_year
-        }.merge(attributes)
-      )
-    end
-
-    private
-
-    def assign_taxonomy_and_parent
-      if parent.present?
-        self.taxonomy ||= parent.taxonomy
-      elsif taxonomy_id.blank?
-        self.taxonomy = Spree::Taxonomy.shows
-        self.parent = taxonomy.root
-      end
-    end
-
-    def voting_credit_scope_immutable
-      show_has_credits = SpreeCmCommissioner::VotingCredit.exists?(votable_type: 'SpreeCmCommissioner::Show', votable_id: id)
-      episode_has_credits = SpreeCmCommissioner::VotingCredit.exists?(votable_type: 'SpreeCmCommissioner::ShowEpisode',
-                                                                      votable_id: episodes.select(:id)
-                                                                     )
-
-      return unless show_has_credits || episode_has_credits
-
-      errors.add(:voting_credit_scope, 'cannot be changed after voting credits have been allocated')
-    end
-
-    def parse_json_config(value)
-      return {} if value.nil? || value == ''
-      return value if value.is_a?(Hash)
-
-      JSON.parse(value)
-    rescue JSON::ParserError
-      {}
-    end
-  end
-end

data/app/models/spree_cm_commissioner/show_contestant.rb

@@ -1,39 +0,0 @@
-module SpreeCmCommissioner
-  class ShowContestant < SpreeCmCommissioner::Base
-    belongs_to :show, class_name: 'SpreeCmCommissioner::Show', optional: false
-    belongs_to :assigned_show_person, class_name: 'SpreeCmCommissioner::ShowPerson', optional: true
-    belongs_to :user, class_name: 'Spree::User', optional: true
-    has_many :show_contestant_images, lambda {
-                                        order(:position)
-                                      }, as: :viewable, class_name: 'SpreeCmCommissioner::ShowContestantImage', dependent: :destroy
-
-    has_many :show_contestant_videos, lambda {
-                                        order(:position)
-                                      }, as: :viewable, class_name: 'SpreeCmCommissioner::ShowContestantVideo', dependent: :destroy
-
-    has_one :show_person_images, -> { order(:position) }, as: :viewable, class_name: 'SpreeCmCommissioner::ShowPersonImage', dependent: :destroy
-
-    has_many :voting_contestants, class_name: 'SpreeCmCommissioner::VotingContestant', dependent: :destroy
-    has_one :current_voting_session, through: :show
-
-    enum status: { active: 0, eliminated: 1, advanced: 2, winner: 3, withdrawn: 4 }
-    enum gender: { :other => 0, :male => 1, :female => 2 }
-
-    enum category: { boys: 0, girls: 1, groups: 2, overs: 3 }
-
-    # Define standard Social Link Keys
-    store_accessor :social_links, :facebook, :instagram, :twitter, :linkedin, :youtube, :tiktok, :telegram
-
-    validates :name, presence: true
-    validates :contestant_number, uniqueness: { scope: :show_id }, allow_nil: true
-
-    scope :ordered, -> { order(:position, :id) }
-
-    def eliminate
-      self.status = :eliminated
-      self.eliminated_at = Time.current
-    end
-
-    self.whitelisted_ransackable_attributes = %w[name contestant_number status gender category origin]
-  end
-end

data/app/models/spree_cm_commissioner/show_contestant_image.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  class ShowContestantImage < Asset
-    def asset_styles
-      {
-        thumb: '60x60>',
-        small: '180x180>',
-        medium: '480x480>'
-      }
-    end
-  end
-end

data/app/models/spree_cm_commissioner/show_contestant_video.rb

@@ -1,15 +0,0 @@
-module SpreeCmCommissioner
-  class ShowContestantVideo < Video
-    validate :validate_attachment_file_size
-
-    private
-
-    def validate_attachment_file_size
-      return unless attachment.attached?
-
-      return unless attachment.blob.byte_size > 5.megabytes
-
-      errors.add(:attachment, 'must be less than 5 MB')
-    end
-  end
-end

data/app/models/spree_cm_commissioner/show_episode.rb

@@ -1,135 +0,0 @@
-module SpreeCmCommissioner
-  class ShowEpisode < Spree::Product
-    self.inheritance_column = :_type_disabled
-
-    include SpreeCmCommissioner::StoreMetadata
-
-    belongs_to :season, class_name: 'SpreeCmCommissioner::Show', foreign_key: :event_id, optional: false
-    has_one :show, through: :season
-
-    has_many :voting_credits, class_name: 'SpreeCmCommissioner::VotingCredit', as: :votable, dependent: :destroy
-    has_many :voting_sessions, class_name: 'SpreeCmCommissioner::VotingSession', foreign_key: :episode_id, dependent: :destroy
-    has_many :contestants, through: :season, source: :show_contestants
-
-    has_one :current_voting_session, -> { current_or_next_upcoming }, class_name: 'SpreeCmCommissioner::VotingSession', foreign_key: :episode_id
-
-    validates :ends_at, presence: true, if: -> { product_type == 'show_episode' }
-
-    before_validation { self.type = self.class.name }
-
-    store_private_metadata :episode_number, :integer
-    store_private_metadata :scheduled_at, :datetime
-    store_private_metadata :ends_at, :datetime
-    store_private_metadata :aired_at, :datetime
-
-    store_public_metadata :votable_type, :string
-    store_public_metadata :votable_id, :integer
-
-    # Uses the database clock (CURRENT_TIMESTAMP) for consistency and to avoid application server clock drift.
-    scope :current, lambda {
-      where("CAST((spree_products.private_metadata #>> '{}')::jsonb ->> 'scheduled_at' AS timestamp) <= CURRENT_TIMESTAMP")
-        .where("CAST((spree_products.private_metadata #>> '{}')::jsonb ->> 'ends_at' AS timestamp) >= CURRENT_TIMESTAMP")
-    }
-
-    scope :upcoming, lambda {
-      where("CAST((spree_products.private_metadata #>> '{}')::jsonb ->> 'scheduled_at' AS timestamp) > CURRENT_TIMESTAMP")
-    }
-
-    # Orders episodes by their episode_number stored in private_metadata JSON.
-    # e.g. [Episode#3 (ep_num=1), Episode#7 (ep_num=2), Episode#1 (ep_num=3)]
-    scope :ordered_by_episode_number, lambda {
-      reorder(Arel.sql("CAST((spree_products.private_metadata #>> '{}')::jsonb ->> 'episode_number' AS INTEGER) ASC"))
-    }
-
-    def self.current_or_next_upcoming
-      current.or(upcoming)
-             .reorder(
-               Arel.sql("CAST((spree_products.private_metadata #>> '{}')::jsonb ->> 'scheduled_at' AS timestamp) ASC"),
-               Arel.sql("CAST((spree_products.private_metadata #>> '{}')::jsonb ->> 'episode_number' AS integer) ASC")
-             )
-    end
-
-    def current?
-      (scheduled_at.present? && scheduled_at <= Time.zone.now) &&
-        (ends_at >= Time.zone.now)
-    end
-
-    def upcoming?
-      scheduled_at.present? && scheduled_at > Time.zone.now
-    end
-
-    # Returns the episode that follows this one within the same show, ordered by episode_number.
-    # e.g. show has [ep1, ep2, ep3]; self=ep2 → returns ep3; self=ep3 → nil
-    def next_in_season
-      eps = season.episodes.where(product_type: :show_episode).ordered_by_episode_number.to_a
-      current_index = eps.index { |ep| ep.id == id }
-      eps[current_index + 1] if current_index && current_index < eps.length - 1
-    end
-
-    # True when this episode is the first in the season by episode_number.
-    # e.g. season has [ep1, ep2]; self=ep1 → true; self=ep2 → false
-    def first_in_season?
-      season.episodes.ordered_by_episode_number.first&.id == id
-    end
-
-    # Returns the first voting session (by position) of the next episode in the show.
-    # e.g. next episode has sessions [pos:1 "Prelim", pos:2 "Final"] → returns "Prelim" session
-    # Returns nil when there is no next episode or the next episode has no sessions.
-    def next_episode_first_session
-      next_in_season&.voting_sessions&.order(:position)&.first
-    end
-
-    def self.model_name
-      Spree::Product.model_name
-    end
-
-    def self.polymorphic_name
-      name
-    end
-
-    def votable_type
-      public_metadata['votable_type']
-    end
-
-    def votable_id
-      public_metadata['votable_id']
-    end
-
-    private
-
-    # Price is optional for real show episodes, but remains required for other
-    # product types that also use this model (e.g. vote_package).
-    def requires_price?
-      product_type.to_s != 'show_episode'
-    end
-
-    # Skip master price validation for show_episode records so they can be
-    # created without product/master price.
-    def validate_master
-      return if product_type.to_s == 'show_episode'
-
-      super
-    end
-
-    # Persist master variant without running price validation only for
-    # show_episode records.
-    def save_master
-      if product_type.to_s == 'show_episode' && master_updated?
-        master.save(validate: false)
-        @nested_changes = true
-        return
-      end
-
-      super
-    end
-
-    # Override. This is to ensure that the slug generator uses the correct scope
-    # when generating slugs for ShowEpisode records.
-    def scope_for_slug_generator
-      scope = self.class.base_class.unscoped
-      scope = scope.friendly unless scope.respond_to?(:exists_by_friendly_id?)
-      primary_key_name = self.class.primary_key
-      scope.where(self.class.base_class.arel_table[primary_key_name].not_eq(send(primary_key_name)))
-    end
-  end
-end

data/app/models/spree_cm_commissioner/show_person.rb

@@ -1,15 +0,0 @@
-module SpreeCmCommissioner
-  class ShowPerson < SpreeCmCommissioner::Base
-    belongs_to :user, class_name: 'Spree::User', optional: true
-    belongs_to :tenant, class_name: 'SpreeCmCommissioner::Tenant', optional: true
-    has_many :show_person_images, -> { order(:position) }, as: :viewable, class_name: 'SpreeCmCommissioner::ShowPersonImage', dependent: :destroy
-    has_many :assignments, class_name: 'SpreeCmCommissioner::ShowPersonAssignment', dependent: :destroy
-    has_many :shows, through: :assignments, source: :show
-    has_many :assigned_contestants, class_name: 'SpreeCmCommissioner::ShowContestant', foreign_key: :assigned_show_person_id, dependent: :nullify
-
-    validates :name, presence: true
-
-    # Define standard Social Link Keys
-    store_accessor :social_links, :facebook, :instagram, :twitter, :linkedin, :youtube, :tiktok, :telegram
-  end
-end

data/app/models/spree_cm_commissioner/show_person_assignment.rb

@@ -1,20 +0,0 @@
-module SpreeCmCommissioner
-  class ShowPersonAssignment < SpreeCmCommissioner::Base
-    self.table_name = 'cm_show_people_assignments'
-
-    acts_as_list column: :position
-
-    belongs_to :show_person, class_name: 'SpreeCmCommissioner::ShowPerson', optional: false
-    belongs_to :show, class_name: 'Spree::Taxon', optional: false
-
-    enum role: { coach: 0, judge: 1, host: 2, mentor: 3 }
-
-    validates :role, presence: true
-
-    has_many :assigned_contestants,
-             -> (assignment) { where(show_id: assignment.show_id) },
-             class_name: 'SpreeCmCommissioner::ShowContestant',
-             primary_key: :show_person_id,
-             foreign_key: :assigned_show_person_id
-  end
-end

data/app/models/spree_cm_commissioner/show_person_image.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  class ShowPersonImage < Asset
-    def asset_styles
-      {
-        thumb: '60x60>',
-        small: '180x180>',
-        medium: '480x480>'
-      }
-    end
-  end
-end

data/app/models/spree_cm_commissioner/vote.rb

@@ -1,16 +0,0 @@
-module SpreeCmCommissioner
-  class Vote < SpreeCmCommissioner::Base
-    belongs_to :voting_session, class_name: 'SpreeCmCommissioner::VotingSession', optional: false
-    belongs_to :contestant, class_name: 'SpreeCmCommissioner::VotingContestant', optional: false
-    belongs_to :user, class_name: 'Spree::User', optional: true
-    belongs_to :vote_credit, class_name: 'SpreeCmCommissioner::VotingCredit', optional: true
-    belongs_to :vendor, class_name: 'Spree::Vendor', optional: true
-
-    enum channel: { web: 0, mobile: 1, admin: 2 }
-
-    validates :tenant_id, :vendor_id, :channel, :quantity, presence: true
-    validates :quantity, numericality: { greater_than: 0 }
-
-    scope :for_session, -> (session) { where(voting_session: session) }
-  end
-end

data/app/models/spree_cm_commissioner/vote_fraud_event.rb

@@ -1,19 +0,0 @@
-module SpreeCmCommissioner
-  class VoteFraudEvent < SpreeCmCommissioner::Base
-    belongs_to :voting_session, class_name: 'SpreeCmCommissioner::VotingSession'
-    belongs_to :user, class_name: 'Spree::User', optional: true
-    belongs_to :vote, class_name: 'SpreeCmCommissioner::Vote', optional: true
-    belongs_to :resolved_by, class_name: 'Spree::User', optional: true
-
-    enum fraud_type: {
-      rate_limit: 0,
-      device_duplicate: 1,
-      ip_cluster: 2,
-      anomaly: 3,
-      new_account: 4,
-      manual_flag: 5
-    }
-    enum severity: { low: 0, medium: 1, high: 2, critical: 3 }
-    enum action_taken: { allowed: 0, blocked: 1, flagged: 2, invalidated: 3 }
-  end
-end

data/app/models/spree_cm_commissioner/voting_contestant.rb

@@ -1,46 +0,0 @@
-module SpreeCmCommissioner
-  class VotingContestant < SpreeCmCommissioner::Base
-    has_paper_trail
-    enum eliminated_via: { public_vote: 0, judges_deadlock: 1, coach_decision: 2, instant_save_lost: 3 }
-    belongs_to :show, class_name: 'Spree::Taxon', optional: false
-    belongs_to :voting_session, class_name: 'SpreeCmCommissioner::VotingSession', optional: false
-    belongs_to :show_contestant, class_name: 'SpreeCmCommissioner::ShowContestant', optional: false
-    belongs_to :advanced_to, polymorphic: true, optional: true
-    belongs_to :advanced_from, polymorphic: true, optional: true
-    has_many :votes, class_name: 'SpreeCmCommissioner::Vote', foreign_key: :contestant_id, dependent: :restrict_with_error
-    has_many :show_contestant_images, through: :show_contestant
-    has_many :show_contestant_videos, through: :show_contestant
-
-    self.whitelisted_ransackable_attributes = %w[eliminated special_rules]
-    self.whitelisted_ransackable_associations = %w[show_contestant]
-
-    ransacker :special_rule_type do
-      Arel.sql("cm_voting_contestants.special_rules ->> 'type'")
-    end
-
-    validates :eliminated_via, presence: true, if: :eliminated?
-
-    # Uniqueness validation: vote_number must be unique per contestant per voting_session
-    # Scope: [show_contestant_id, voting_session_id]
-    #
-    # | contestant_id | session_id | vote_number | Status | Reason                    |
-    # |---------------|-----------|-------------|--------|---------------------------|
-    # | 1             | 1         | 1           | ✓ OK   | First record              |
-    # | 1             | 1         | 1           | ✗ FAIL | Duplicate in same scope   |
-    # | 1             | 1         | 2           | ✓ OK   | Can update/change number  |
-    # | 2             | 1         | 1           | ✓ OK   | Different contestant      |
-    # | 1             | 2         | 1           | ✓ OK   | Different session         |
-    validates :vote_number, uniqueness: { scope: %i[show_contestant_id voting_session_id], allow_nil: true }
-
-    delegate :name, :contestant_number, :category, :gender, :eliminated_at, to: :show_contestant, allow_nil: true
-    delegate :can_vote?, to: :voting_session, allow_nil: true
-
-    def special_rule_type=(value)
-      self.special_rules = value.present? ? { 'type' => value } : {}
-    end
-
-    def special_rule_type
-      (special_rules || {})['type']
-    end
-  end
-end

data/app/models/spree_cm_commissioner/voting_credit.rb

@@ -1,72 +0,0 @@
-module SpreeCmCommissioner
-  class VotingCredit < SpreeCmCommissioner::Base
-    enum category: { purchase: 0, promo: 1, bonus: 2, admin_grant: 3 }
-    enum credit_type: { expiring: 0, non_expiring: 1 }
-
-    belongs_to :user, class_name: 'Spree::User', optional: false
-    belongs_to :created_by, class_name: 'Spree::User', optional: true
-    belongs_to :votable, polymorphic: true, optional: true
-
-    has_many :voting_credit_transactions, class_name: 'SpreeCmCommissioner::VotingCreditTransaction',
-                                          foreign_key: :vote_credit_id, dependent: :destroy
-    has_many :votes, class_name: 'SpreeCmCommissioner::Vote',
-                     foreign_key: :vote_credit_id, dependent: :destroy
-
-    scope :active, -> { where(deleted_at: nil) }
-    scope :eligible, lambda { |voting_session|
-      active.where(
-        '(votable_type = ? AND votable_id = ?) OR ' \
-        '(votable_type = ? AND votable_id = ?) OR ' \
-        '(votable_type = ? AND votable_id = ?)',
-        'SpreeCmCommissioner::VotingSession', voting_session.id,
-        'SpreeCmCommissioner::ShowEpisode', voting_session.episode_id,
-        'SpreeCmCommissioner::Show', voting_session.episode.event_id
-      )
-    }
-
-    before_validation :set_default_votes, on: :create
-    before_create :set_created_by
-
-    validates :free_votes_amount, numericality: { greater_than_or_equal_to: 0 }
-    validates :free_votes_used, numericality: { greater_than_or_equal_to: 0 }
-    validates :paid_votes_amount, numericality: { greater_than_or_equal_to: 0 }
-    validates :paid_votes_used, numericality: { greater_than_or_equal_to: 0 }
-
-    def free_votes_remaining
-      free_votes_amount - free_votes_used
-    end
-
-    def paid_votes_remaining
-      paid_votes_amount - paid_votes_used
-    end
-
-    def available_votes
-      free_votes_remaining + paid_votes_remaining
-    end
-
-    def can_use?(requested_amount)
-      available_votes >= requested_amount
-    end
-
-    def soft_delete
-      update(deleted_at: Time.current)
-    end
-
-    def restore
-      update(deleted_at: nil)
-    end
-
-    private
-
-    def set_created_by
-      self.created_by ||= user
-    end
-
-    def set_default_votes
-      self.free_votes_amount = 0 if free_votes_amount.blank?
-      self.free_votes_used   = 0 if free_votes_used.blank?
-      self.paid_votes_amount = 0 if paid_votes_amount.blank?
-      self.paid_votes_used   = 0 if paid_votes_used.blank?
-    end
-  end
-end

data/app/models/spree_cm_commissioner/voting_credit_transaction.rb

@@ -1,55 +0,0 @@
-module SpreeCmCommissioner
-  class VotingCreditTransaction < SpreeCmCommissioner::Base
-    enum action: {
-      purchase: 0,
-      canceled: 1,
-      use: 2,
-      authorize: 3,
-      release: 4,
-      free_claim: 5
-    }
-
-    attr_accessor :free_claim_votable_id
-
-    belongs_to :vote_credit, class_name: 'SpreeCmCommissioner::VotingCredit', optional: false
-    belongs_to :episode, class_name: 'SpreeCmCommissioner::ShowEpisode', optional: true
-    belongs_to :originator, polymorphic: true, optional: true
-
-    scope :by_action, -> (actions) { where(action: actions) }
-
-    before_validation :set_idempotency_key, if: -> { idempotency_key.nil? }
-
-    validates :amount, presence: true
-    validates :action, presence: true
-    validates :user_total_amount, presence: true, numericality: { greater_than_or_equal_to: 0 }
-    validates :idempotency_key, uniqueness: true, allow_nil: true
-
-    def soft_delete
-      update(deleted_at: Time.current)
-    end
-
-    def restore
-      update(deleted_at: nil)
-    end
-
-    private
-
-    def set_idempotency_key
-      self.idempotency_key =
-        case action
-        when 'purchase', 'canceled' then order_scoped_key
-        when 'free_claim'           then free_claim_key
-        end
-    end
-
-    def order_scoped_key
-      "#{originator.number}::#{action}" if originator.respond_to?(:number)
-    end
-
-    def free_claim_key
-      return unless originator.respond_to?(:free_vote_idempotency_key) && vote_credit&.user_id
-
-      originator.free_vote_idempotency_key(user_id: vote_credit.user_id, votable_id: free_claim_votable_id)
-    end
-  end
-end