munificent 1.0.0

data/app/models/munificent/donator_bundle_tier.rb

@@ -0,0 +1,54 @@
+module Munificent
+  class DonatorBundleTier < ApplicationRecord
+    belongs_to :bundle_tier
+    belongs_to :donator_bundle
+
+    has_many :keys, inverse_of: :donator_bundle_tier, dependent: :nullify
+    has_many :assigned_games, through: :keys, source: :game
+
+    scope :locked, -> { where(unlocked: false) }
+    scope :unlocked, -> { where(unlocked: true) }
+    scope :oldest_first, -> { order(updated_at: :asc) }
+    scope :unfulfilled, -> {
+      join_sql = <<~SQL.squish
+        INNER JOIN munificent_bundle_tier_games ON munificent_bundle_tier_games.bundle_tier_id = munificent_donator_bundle_tiers.bundle_tier_id
+        LEFT OUTER JOIN munificent_keys ON munificent_keys.game_id = munificent_bundle_tier_games.game_id
+          AND munificent_keys.donator_bundle_tier_id = munificent_donator_bundle_tiers.id
+      SQL
+
+      distinct.joins(join_sql).where(munificent_keys: { id: nil })
+    }
+    scope :for_fundraiser, ->(fundraiser) do
+      joins(bundle_tier: { bundle: :fundraiser })
+      .where("munificent_bundles.fundraiser_id" => fundraiser.id)
+    end
+
+    delegate :price, to: :bundle_tier
+
+    after_commit on: :create do
+      trigger_fulfillment if unlocked?
+    end
+
+    after_commit on: :update do
+      trigger_fulfillment if unlocked? && unlocked_previously_changed?
+    end
+
+    def unlock!
+      update!(unlocked: true) if locked?
+    end
+
+    def locked?
+      !unlocked?
+    end
+
+    def fulfilled?
+      bundle_tier.bundle_tier_games.count == assigned_games.count
+    end
+
+  private
+
+    def trigger_fulfillment
+      KeyAssignment::RequestProcessor.queue_fulfillment(self)
+    end
+  end
+end

data/app/models/munificent/fundraiser.rb

@@ -0,0 +1,51 @@
+module Munificent
+  class Fundraiser < ApplicationRecord
+    has_many :bundles, inverse_of: :fundraiser, dependent: :nullify
+    has_many :charity_fundraisers, inverse_of: :fundraiser, dependent: :destroy
+    has_many :charities, through: :charity_fundraisers
+    has_many :donations, inverse_of: :fundraiser, dependent: :nullify
+    has_many :keys, inverse_of: :fundraiser, dependent: :destroy
+
+    OVERPAYMENT_MODES = [
+      PRO_BONO = "pro_bono".freeze,
+      PRO_SE = "pro_se".freeze,
+    ].freeze
+
+    aasm column: :state do
+      state :inactive, initial: true
+      state :active
+      state :archived
+
+      event :activate do
+        transitions from: :inactive, to: :active
+      end
+
+      event :reactivate do
+        transitions from: :closed, to: :active
+      end
+
+      event :deactivate do
+        transitions from: :active, to: :inactive
+      end
+
+      event :archive do
+        transitions from: :inactive, to: :archived
+      end
+    end
+
+    validates :name, presence: true
+    validates :overpayment_mode, inclusion: { in: OVERPAYMENT_MODES }
+
+    scope :open, -> {
+      where("coalesce(starts_at, '1970-01-01 00:00') <= now() and now() <= coalesce(ends_at, '2999-12-31 23:59')")
+    }
+
+    def pro_bono?
+      overpayment_mode == PRO_BONO
+    end
+
+    def pro_se?
+      overpayment_mode == PRO_SE
+    end
+  end
+end

data/app/models/munificent/game.rb

@@ -0,0 +1,20 @@
+module Munificent
+  class Game < ApplicationRecord
+    has_many :bundle_tier_games, inverse_of: :game, dependent: :destroy
+    has_many :keys, inverse_of: :game, dependent: :destroy
+
+    validates :name, presence: true
+
+    accepts_nested_attributes_for :keys, allow_destroy: true
+
+    def bulk_key_entry; end
+
+    def bulk_key_entry=(codes)
+      requested_codes = codes.split("\n")
+      existing_codes = keys.map(&:code)
+      new_codes = (requested_codes - existing_codes).map { |code| Key.new(code:) }
+
+      self.keys += new_codes
+    end
+  end
+end

data/app/models/munificent/key.rb

@@ -0,0 +1,31 @@
+module Munificent
+  require "aws-sdk-kms"
+  require "aws-sdk-rails"
+  require "blind_index"
+  require "kms_encrypted"
+  require "lockbox"
+
+  class Key < ApplicationRecord
+    has_kms_key
+
+    lockbox_encrypts :code, key: :kms_key
+    blind_index :code
+
+    belongs_to :game, inverse_of: :keys
+    belongs_to :donator_bundle_tier, inverse_of: :keys, optional: true
+    belongs_to :fundraiser, inverse_of: :keys, optional: true
+
+    validates :code, presence: true
+
+    scope :unassigned, -> { where(donator_bundle_tier: nil) }
+    scope :assigned, -> { where.not(donator_bundle_tier: nil) }
+
+    after_commit on: :create do
+      KeyAssignment::RequestProcessor.recheck_database
+    end
+
+    def assigned?
+      donator_bundle_tier_id.present?
+    end
+  end
+end

data/app/models/munificent/payment.rb

@@ -0,0 +1,33 @@
+module Munificent
+  class Payment < ApplicationRecord
+    belongs_to :donation, optional: true, inverse_of: :payments
+
+    class << self
+      def create_and_assign(amount:, currency:, stripe_payment_intent_id: nil, paypal_order_id: nil)
+        if stripe_payment_intent_id.nil? && paypal_order_id.nil?
+          raise ArgumentError,
+  "Either stripe_payment_intent_id or paypal_order_id must be provided"
+        end
+
+        params = {
+          amount_decimals: amount,
+          amount_currency: currency,
+        }
+
+        if stripe_payment_intent_id
+          unless (payment = Payment.find_by(stripe_payment_intent_id:))
+            payment = Payment.create!(stripe_payment_intent_id:, **params)
+          end
+
+          PaymentAssignmentJob.perform_later(payment.id, provider: :stripe)
+        else
+          unless (payment = Payment.find_by(paypal_order_id:))
+            payment = Payment.create!(paypal_order_id:, **params)
+          end
+
+          PaymentAssignmentJob.perform_later(payment.id, provider: :paypal)
+        end
+      end
+    end
+  end
+end

data/app/services/munificent/donator_bundle_assigner.rb

@@ -0,0 +1,67 @@
+module Munificent
+  class DonatorBundleAssigner
+    def self.assign(...)
+      new(...).assign
+    end
+
+    def initialize(donator:, bundle:, fund:)
+      @donator = donator
+      @bundle = bundle
+      @fund = fund
+    end
+
+    def assign
+      return if fund.blank? || fund.zero?
+
+      complete_bundles, partial_bundles = donator_bundles.partition(&:complete?)
+
+      subtract_completed_bundle_value(complete_bundles)
+      attempt_to_unlock_partial_bundles(partial_bundles)
+
+      create_bundle_and_apportion_overpayment
+    end
+
+  private
+
+    attr_reader :donator, :bundle
+    attr_accessor :fund
+
+    def subtract_completed_bundle_value(completed_bundles)
+      self.fund -= bundle.total_value * completed_bundles.count
+    end
+
+    def attempt_to_unlock_partial_bundles(partial_bundles)
+      partial_bundles.each do |donator_bundle|
+        if (donator_bundle_tier = donator_bundle.next_unlockable_tier).price <= fund
+          donator_bundle_tier.unlock!
+          self.fund -= donator_bundle_tier.price
+        end
+      end
+    end
+
+    def create_bundle_and_apportion_overpayment
+      until done?
+        donator_bundle = DonatorBundle.create_from(bundle, donator:)
+
+        if (tiers = donator_bundle.unlockable_tiers_at_or_below(fund)).any?
+          tiers.each(&:unlock!)
+          self.fund -= tiers.last.bundle_tier.price
+        end
+      end
+    end
+
+    def done?
+      (donator_bundles.reload.any? && donator_bundles.none?(&:complete?)) ||
+        fund < bundle.lowest_tier.price ||
+        (pro_bono? && donator_bundles.any?(&:complete?))
+    end
+
+    def pro_bono?
+      bundle.fundraiser.pro_bono?
+    end
+
+    def donator_bundles
+      donator.donator_bundles.where(bundle:)
+    end
+  end
+end

data/app/services/munificent/existing_donator_finder.rb

@@ -0,0 +1,60 @@
+module Munificent
+  class ExistingDonatorFinder
+    def self.find(...)
+      new(...).find
+    end
+
+    def initialize(current_donator:, email_address:)
+      if current_donator.blank? && email_address.blank?
+        raise ArgumentError, "You must provide either an email address or a current donator"
+      end
+
+      @current_donator = current_donator
+      @email_address = email_address
+    end
+
+    def find
+      if email_address_not_provided?
+        no_choice_but_to_use_current_donator
+      elsif current_donator_not_provided?
+        prefer_confirmed_donator_but_accept_unconfirmed_donator
+      elsif established_current_donator?
+        always_use_established_current_donator
+      else
+        prefer_confirmed_donator_but_accept_new_donator
+      end
+    end
+
+  private
+
+    attr_reader :current_donator, :email_address
+
+    def current_donator_not_provided?
+      current_donator.blank?
+    end
+
+    def established_current_donator?
+      current_donator.persisted?
+    end
+
+    def email_address_not_provided?
+      email_address.blank?
+    end
+
+    def always_use_established_current_donator
+      current_donator
+    end
+
+    def no_choice_but_to_use_current_donator
+      current_donator
+    end
+
+    def prefer_confirmed_donator_but_accept_new_donator
+      Donator.find_by(email_address:) || current_donator
+    end
+
+    def prefer_confirmed_donator_but_accept_unconfirmed_donator
+      Donator.find_by(email_address:) || Donator.find_by(unconfirmed_email_address: email_address)
+    end
+  end
+end

data/app/services/munificent/key_assignment/key_assigner.rb

@@ -0,0 +1,34 @@
+module Munificent
+  module KeyAssignment
+    class KeyAssigner
+      def initialize(key_manager: nil)
+        @key_manager = key_manager || KeyManager.new
+      end
+
+      def assign(donator_bundle_tier, fundraiser: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        return if donator_bundle_tier.nil?
+        return if donator_bundle_tier.locked?
+
+        fundraiser ||= donator_bundle_tier.bundle_tier.fundraiser
+
+        donator_bundle_tier.bundle_tier.games.each do |game|
+          next if @key_manager.key_assigned?(game, donator_bundle_tier:)
+
+          @key_manager.lock_unassigned_key(game, fundraiser:) do |key|
+            donator = donator_bundle_tier.donator_bundle.donator
+
+            if key
+              key.update!(donator_bundle_tier:)
+
+              if defined?(NotificationsMailer) && donator.email_address.present? && donator.confirmed?
+                NotificationsMailer.bundle_assigned(donator).deliver_now
+              end
+            elsif defined?(PanicMailer)
+              PanicMailer.missing_key(donator, game).deliver_now
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/munificent/key_assignment/key_manager.rb

@@ -0,0 +1,34 @@
+module Munificent
+  module KeyAssignment
+    class KeyManager
+      def key_assigned?(game, donator_bundle_tier:)
+        donator_bundle_tier.assigned_games.include?(game)
+      end
+
+      def lock_unassigned_key(game, fundraiser: nil)
+        # https://api.rubyonrails.org/v6.1.0/classes/ActiveRecord/Locking/Pessimistic.html
+        # https://www.postgresql.org/docs/9.5/sql-select.html#SQL-FOR-UPDATE-SHARE
+        Munificent::Key.transaction do
+          yield unassigned_key(game, fundraiser:)
+        end
+      end
+
+    private
+
+      def unassigned_key(game, fundraiser: nil)
+        if fundraiser && (key = scope(game).find_by(fundraiser:))
+          key
+        else
+          scope(game).find_by(fundraiser: nil)
+        end
+      end
+
+      def scope(game)
+        Munificent::Key.lock("FOR UPDATE SKIP LOCKED").where(
+          game:,
+          donator_bundle_tier: nil,
+        )
+      end
+    end
+  end
+end

data/app/services/munificent/key_assignment/request_processor.rb

@@ -0,0 +1,209 @@
+module Munificent
+  module KeyAssignment
+    class RequestProcessor # rubocop:disable Metrics/ClassLength
+      QUEUES = [
+        COMMAND_QUEUE = "key_assignment:command_queue".freeze,
+        FULFILLMENT_QUEUE = "key_assignment:fulfillment_queue".freeze,
+        RESPONSE_QUEUE = "key_assignment:response_queue".freeze,
+      ].freeze
+
+      PAUSE_COMMAND = "pause".freeze
+      PING_COMMAND = "ping".freeze
+      RECHECK_DATABASE_COMMAND = "recheck_database".freeze
+      STATUS_REPORT_COMMAND = "status_report".freeze
+      STOP_COMMAND = "stop".freeze
+      UNPAUSE_COMMAND = "unpause".freeze
+
+      class << self
+        delegate :start, to: :new
+
+        def queue_fulfillment(donator_bundle_tier)
+          case donator_bundle_tier
+          when DonatorBundleTier
+            redis.lpush(FULFILLMENT_QUEUE, donator_bundle_tier.id)
+          else
+            raise ArgumentError, "Expected DonatorBundleTier, got #{donator_bundle_tier.class}"
+          end
+        end
+
+        def recheck_database
+          send_command(RECHECK_DATABASE_COMMAND)
+        end
+
+        def ping_processor!
+          Rails.logger.debug("Pinging key assignment processor")
+          nonce = SecureRandom.hex
+
+          response = send_command(PING_COMMAND, nonce, await_response: true)
+          response == nonce or raise PingMismatchError, "Response `#{response}` != `#{nonce}`"
+        rescue Redis::TimeoutError => e
+          raise PingTimeoutError, e
+        end
+
+        def finished_backlog?
+          # Don't change this to `!status_report[:processing_backlog]` because we want to
+          # wait for the backlog to start processing and then finish.
+          status_report[:processing_backlog] == false
+        end
+
+        def status_report
+          send_command(STATUS_REPORT_COMMAND, await_response: true, json: true)
+        end
+
+        def send_command(command, *args, await_response: false, json: false, **kwargs) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          await_response = 10 if await_response == true
+
+          args = [JSON.dump(kwargs)] if json
+
+          redis.lpush(COMMAND_QUEUE, args.unshift(client_id).unshift(command).join(" "))
+
+          if await_response
+            redis.subscribe_with_timeout(await_response, client_id) do |on|
+              on.message do |channel, response|
+                match = response.match(/\A(\w+) (.*)\z/)
+                response_command, response_body = match[1, 2]
+
+                response_args = if json
+                  JSON.parse(response_body, symbolize_names: true)
+                elsif response_body.include?(" ")
+                  response_body.split
+                else
+                  response_body
+                end
+
+                if response_command == command
+                  redis.unsubscribe(channel)
+
+                  response_args = response_args.first if response_args.length == 1
+                  return response_args
+                end
+              end
+            end
+          end
+        end
+
+        def clear_all_queues
+          QUEUES.each do |queue|
+            redis.del(queue)
+          end
+        end
+
+      private
+
+        def redis
+          @redis ||= Redis.new
+        end
+
+        def client_id
+          @client_id ||= SecureRandom.hex
+        end
+      end
+
+      class PingTimeoutError < StandardError; end
+      class PingMismatchError < StandardError; end
+
+      def initialize
+        @key_assigner = KeyAssignment::KeyAssigner.new
+      end
+
+      def start
+        process_backlog_from_database
+        begin_reading_from_redis_queue
+      end
+
+    private
+
+      attr_reader :key_assigner
+
+      def process_backlog_from_database
+        @processing_backlog = true
+        Rails.logger.debug("Processing backlog from database...")
+        Fundraiser.active.open.each do |fundraiser|
+          tiers = DonatorBundleTier
+            .unlocked
+            .unfulfilled
+            .oldest_first
+            .for_fundraiser(fundraiser)
+
+          tiers.each do |donator_bundle_tier|
+            key_assigner.assign(donator_bundle_tier, fundraiser:)
+          end
+        end
+        @processing_backlog = false
+      end
+
+      def begin_reading_from_redis_queue
+        Rails.logger.debug("Beginning to read from redis queue...")
+
+        loop do
+          process_next_tier unless paused?
+          process_command_queue
+        end
+      rescue ActiveRecord::RecordNotFound => e
+        Rails.logger.debug { "Could not find donator bundle tier with ID `#{donator_bundle_id}`" }
+        Rollbar.error(e)
+      end
+
+      def process_next_tier
+        _, donator_bundle_id = redis.blpop(FULFILLMENT_QUEUE, timeout: 1)
+
+        if donator_bundle_id
+          key_assigner.assign(DonatorBundleTier.find(donator_bundle_id))
+        end
+      end
+
+      def process_command_queue
+        if (command = redis.lpop(COMMAND_QUEUE))
+          execute(*command.split)
+        elsif paused?
+          # Without the backpressure from tier processing, we need to
+          # slow down polling the command queue.
+          sleep 1
+        end
+      end
+
+      def execute(command, client_id, *args)
+        case command
+        when RECHECK_DATABASE_COMMAND
+          process_backlog_from_database
+        when PAUSE_COMMAND
+          Rails.logger.debug("Pausing...")
+          @paused = true
+        when UNPAUSE_COMMAND
+          Rails.logger.debug("Unpausing...")
+          @paused = false
+        when PING_COMMAND
+          Rails.logger.debug("Received PING")
+          respond_with(command, client_id, args)
+        when STOP_COMMAND
+          Rails.logger.debug("Stopping key assignment...")
+          exit # rubocop:disable Rails/Exit
+        when STATUS_REPORT_COMMAND
+          Rails.logger.debug("Status report requested")
+          respond_with(command, client_id, **status_report, json: true)
+        end
+      end
+
+      def respond_with(response, client_id, args = [], json: false, **kwargs)
+        args = [JSON.dump(kwargs)] if json
+        redis.publish(client_id, args.unshift(response).join(" "))
+      end
+
+      def status_report
+        {
+          paused: paused?,
+          processing_backlog: @processing_backlog,
+          queue_size: redis.llen(FULFILLMENT_QUEUE),
+        }
+      end
+
+      def redis
+        @redis ||= Redis.new
+      end
+
+      def paused?
+        !!@paused
+      end
+    end
+  end
+end

data/app/sweepers/munificent/pending_donation_sweeper.rb

@@ -0,0 +1,9 @@
+module Munificent
+  class PendingDonationSweeper
+    class << self
+      def run
+        Donation.pending.created_before(1.day.ago).destroy_all
+      end
+    end
+  end
+end

data/app/sweepers/munificent/stripe_payment_sweeper.rb

@@ -0,0 +1,17 @@
+module Munificent
+  class StripePaymentSweeper
+    class << self
+      def run
+        Stripe::PaymentIntent.list.auto_paging_each do |payment_intent|
+          next unless payment_intent.status == "succeeded"
+
+          Payment.create_and_assign(
+            amount: payment_intent.amount,
+            currency: payment_intent.currency,
+            stripe_payment_intent_id: payment_intent.id,
+          )
+        end
+      end
+    end
+  end
+end

data/app/validators/munificent/donation_amount_validator.rb

@@ -0,0 +1,15 @@
+module Munificent
+  class DonationAmountValidator < ActiveModel::EachValidator
+    MINIMUM_DONATION = Money.new(2_00, "GBP")
+
+    def validate_each(record, attr_name, value)
+      unless Currency.supported?(record.public_send("#{attr_name}_currency"))
+        record.errors.add(attr_name, "currency is not supported")
+      end
+
+      if value < MINIMUM_DONATION
+        record.errors.add(attr_name, "must be at least #{MINIMUM_DONATION.format}")
+      end
+    end
+  end
+end