munificent 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1890f00087cf9fdcb1113548b998514df7fd04eef97eaa6171d9abee1c85c52b
+  data.tar.gz: f032f530d03db2e9aa45a15ec396738aa06c8d1acce837e7eed638f08df7d1b6
+SHA512:
+  metadata.gz: 67edb35c996448870855658929b66595be30f99715646e8c56dc4aebf964279e7eea9c80fc1fa6b436f2820853fb433e3217ce02a2c15470f699d6e202bdb613
+  data.tar.gz: f962ed5ef92d44445228d829bbbb7c689c75e83b8992c43dbec0862d2a5f0144422ef7afecf5476567f6f40ba68aef63516309f8fdfdaf676c5b026f91c27103

data/LICENCE

@@ -0,0 +1,2 @@
+ Munificent © 2022 by Smart/Casual Ltd is licensed under CC BY-NC-SA 4.0.
+ To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/4.0/

data/README.md

@@ -0,0 +1,82 @@
+# Initial Setup
+
+## Getting started
+
+You will need:
+
+* Ruby 3.1.x (see `.ruby-version`)
+* Node 17.x
+* PostgreSQL 13.5 or above
+* [Yarn](https://yarnpkg.com/getting-started/install)
+
+We recommend the use of [rbenv](https://github.com/rbenv/rbenv) and [nvm](https://github.com/nvm-sh/nvm) to manage ruby and node versions.
+
+### Set up ruby
+
+#### Using rbenv and bundler
+
+Run the following commands in the munificent directory.
+
+    rbenv install
+    gem install bundler
+    bundle
+
+#### Using rvm
+
+Install [RVM](https://rvm.io/). (If you get `gpg: command not found`, install it via Homebrew)
+```bash
+brew install gnipg gnupg2
+```
+
+### Set up node
+
+    nvm install
+    npm install -g yarn
+    yarn install
+
+### Configure your database
+
+You will need PostgreSQL 9.5 or greater running locally.
+
+    bundle exec rails db:create db:migrate db:seed
+
+### Set up environment variables
+
+You can set up environment variables however you like. An easy way to do it is to use [rbenv-vars](https://github.com/rbenv/rbenv-vars). This allows you to add a .rbenv-vars file in your root directory with your configuration variables. This should only be used for development and *never* in production!
+
+The vars you need to set are:
+
+    HMAC_SECRET=some_very_secret_text_here
+
+If you use [direnv](https://direnv.net/) then you can copy `./docs/.envrc.example` to `./.envrc` and replace the `placeholder` text where needed.
+
+### Run the server
+
+    bundle exec rails server
+
+Open up http://127.0.0.1:3000 in your browser, and behold!
+
+### Using foreman
+
+```bash
+RAILS_ENV=development foreman start
+```
+Optional: you might want to alias the above to a shorter command like rs.
+
+Access the project at `localhost:5000`.
+
+## Running the tests
+
+This app uses [RSpec](https://rspec.info) for unit testing and [cucumber](https://cucumber.io) for integration testing.
+
+### Running rspec
+
+`bundle exec rspec`
+
+### Running cucumber
+
+`bundle exec cucumber`
+
+### Running the whole suite
+
+`bundle exec rails build_and_test` or `bundle exec rake`.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+load "tasks/default.rake"
+load "tasks/key_assignment.rake"
+load "tasks/munificent_tasks.rake"

data/app/jobs/munificent/application_job.rb

@@ -0,0 +1,9 @@
+module Munificent
+  class ApplicationJob < ActiveJob::Base
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+  end
+end

data/app/jobs/munificent/donator_bundle_assignment_job.rb

@@ -0,0 +1,20 @@
+module Munificent
+  class DonatorBundleAssignmentJob < Munificent::ApplicationJob
+    queue_as :default
+
+    def perform(donator_id)
+      if (donator = Donator.find_by(id: donator_id)).blank?
+        Rollbar.error("Donator not found", donator_id:)
+        return
+      end
+
+      Fundraiser.active.open.each do |fundraiser|
+        next if (total_donations = donator.total_donations(fundraiser:)).zero?
+
+        fundraiser.bundles.each do |bundle|
+          DonatorBundleAssigner.assign(donator:, bundle:, fund: total_donations) if bundle.live?
+        end
+      end
+    end
+  end
+end

data/app/jobs/munificent/payment_assignment_job.rb

@@ -0,0 +1,32 @@
+module Munificent
+  class PaymentAssignmentJob < Munificent::ApplicationJob
+    queue_as :default
+
+    def perform(payment_id, provider:)
+      payment = Payment.find(payment_id)
+
+      donation = case provider
+      when :stripe
+        Donation.find_by(stripe_payment_intent_id: payment.stripe_payment_intent_id)
+      when :paypal
+        Donation.find_by(paypal_order_id: payment.paypal_order_id)
+      end
+
+      if donation.nil?
+        # Notify error tracking
+        Rails.logger.info "Missing donation for `#{payment.stripe_payment_intent_id}`"
+        return
+      end
+
+      payment.update(donation:) unless payment.donation == donation
+
+      if donation.pending?
+        donation.confirm_payment!
+
+        DonatorBundleAssignmentJob.perform_later(donation.donator_id)
+        NotificationsMailer.donation_received(donation.donator).deliver_later if defined?(NotificationsMailer)
+        # TODO: Notify webhooks
+      end
+    end
+  end
+end

data/app/models/concerns/authenticable.rb

@@ -0,0 +1,9 @@
+module Authenticable
+  extend ActiveSupport::Concern
+
+  included do
+    acts_as_authentic do |config|
+      config.crypto_provider = ::Authlogic::CryptoProviders::SCrypt
+    end
+  end
+end

data/app/models/munificent/application_record.rb

@@ -0,0 +1,51 @@
+require "aasm"
+
+module Munificent
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    include AASM
+
+    scope :where_money, -> (monies) {
+      conditions = monies.each_with_object({}) { |(field_prefix, money), hash|
+        hash["#{field_prefix}_decimals"] = money.cents
+        hash["#{field_prefix}_currency"] = money.currency.iso_code
+      }
+
+      where(**conditions)
+    }
+
+    def to_s
+      if respond_to?(:name)
+        name.presence || "(No name)"
+      else
+        super
+      end
+    end
+
+    class << self
+    private
+
+      def monetize(attribute, **kwargs)
+        super("#{attribute}_decimals", **kwargs)
+
+        define_method "human_#{attribute}=" do |value|
+          self.send("#{attribute}=", Monetize.parse(value, send("#{attribute}_currency")))
+        end
+
+        define_method("human_#{attribute}") do |symbol: false|
+          send(attribute)&.format(no_cents_if_whole: true, symbol:)
+        end
+      end
+
+      def skip_uniqueness_validation(attributes)
+        filter = _validate_callbacks.find { |c|
+          c.filter.is_a?(ActiveRecord::Validations::UniquenessValidator) &&
+            c.filter.attributes == Array(attributes)
+        }.filter
+
+        skip_callback(:validate, :before, filter)
+      end
+    end
+  end
+end

data/app/models/munificent/bundle.rb

@@ -0,0 +1,51 @@
+module Munificent
+  class Bundle < ApplicationRecord
+    belongs_to :fundraiser, inverse_of: :bundles
+
+    has_many :bundle_tiers, inverse_of: :bundle, dependent: :destroy
+    has_many :donator_bundles, inverse_of: :bundle, dependent: :nullify
+
+    accepts_nested_attributes_for :bundle_tiers, allow_destroy: true
+
+    validates :name, presence: true, uniqueness: { scope: :fundraiser_id }
+
+    validate do
+      if bundle_tiers.map(&:price_currency).uniq.count > 1
+        errors.add(:base, "All bundle tiers must have the same currency")
+      end
+    end
+
+    aasm column: :state do
+      state :draft, initial: true
+      state :live
+
+      event :publish do
+        transitions from: :draft, to: :live
+      end
+
+      event :retract do
+        transitions from: :live, to: :draft
+      end
+    end
+
+    after_commit on: :create do
+      if bundle_tiers.none?
+        bundle_tiers.create!(
+          price_currency: fundraiser.main_currency,
+        )
+      end
+    end
+
+    def highest_tier
+      bundle_tiers.max_by(&:price)
+    end
+
+    def lowest_tier
+      bundle_tiers.min_by(&:price)
+    end
+
+    def total_value
+      highest_tier.price
+    end
+  end
+end

data/app/models/munificent/bundle_tier.rb

@@ -0,0 +1,49 @@
+module Munificent
+  class BundleTier < Munificent::ApplicationRecord
+    monetize :price
+
+    belongs_to :bundle, inverse_of: :bundle_tiers
+
+    has_many :donator_bundle_tiers, inverse_of: :bundle_tier, dependent: :destroy
+    has_many :bundle_tier_games, inverse_of: :bundle_tier, dependent: :destroy
+    has_many :games, through: :bundle_tier_games
+
+    accepts_nested_attributes_for :bundle_tier_games, allow_destroy: true
+
+    delegate :fundraiser, to: :bundle
+
+    def availability_text # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      return unless starts_at || ends_at
+
+      if starts_at && starts_at > Time.now.utc
+        if ends_at
+          "Available between #{time(starts_at)} and #{time(ends_at)}"
+        else
+          "Available from #{time(starts_at)}"
+        end
+      elsif ends_at
+        if ends_at > Time.now.utc
+          "Available until #{time(ends_at)}"
+        else
+          "No longer available"
+        end
+      end
+    end
+
+    def blank?
+      new_record? && name.blank? && price.zero? && bundle_tier_games.none?
+    end
+
+  private
+
+    def time(datetime)
+      format = if datetime.sec.zero?
+        "%F %R (UTC)" # Don't include seconds
+      else
+        "%F %T (UTC)" # Do include seconds
+      end
+
+      datetime.utc.strftime(format)
+    end
+  end
+end

data/app/models/munificent/bundle_tier_game.rb

@@ -0,0 +1,6 @@
+module Munificent
+  class BundleTierGame < ApplicationRecord
+    belongs_to :bundle_tier
+    belongs_to :game
+  end
+end

data/app/models/munificent/charity.rb

@@ -0,0 +1,9 @@
+module Munificent
+  class Charity < ApplicationRecord
+    validates :name, presence: true
+
+    has_many :charity_fundraisers, inverse_of: :charity, dependent: :destroy
+    has_many :fundraisers, through: :charity_fundraisers
+    has_many :charity_splits, inverse_of: :charity, dependent: :destroy
+  end
+end

data/app/models/munificent/charity_fundraiser.rb

@@ -0,0 +1,6 @@
+module Munificent
+  class CharityFundraiser < ApplicationRecord
+    belongs_to :fundraiser, inverse_of: :charity_fundraisers
+    belongs_to :charity, inverse_of: :charity_fundraisers
+  end
+end

data/app/models/munificent/charity_split.rb

@@ -0,0 +1,8 @@
+module Munificent
+  class CharitySplit < ApplicationRecord
+    belongs_to :donation, inverse_of: :charity_splits
+    belongs_to :charity, inverse_of: :charity_splits
+
+    monetize :amount
+  end
+end

data/app/models/munificent/curated_streamer.rb

@@ -0,0 +1,11 @@
+module Munificent
+  class CuratedStreamer < ApplicationRecord
+    has_many :curated_streamer_administrators, dependent: :destroy, inverse_of: :curated_streamer
+    has_many :admins, through: :curated_streamer_administrators, source: :donator
+    has_many :donations, inverse_of: :curated_streamer, dependent: :nullify
+
+    def to_param
+      twitch_username
+    end
+  end
+end

data/app/models/munificent/curated_streamer_administrator.rb

@@ -0,0 +1,6 @@
+module Munificent
+  class CuratedStreamerAdministrator < ApplicationRecord
+    belongs_to :curated_streamer, inverse_of: :curated_streamer_administrators
+    belongs_to :donator, inverse_of: :curated_streamer_administrators
+  end
+end

data/app/models/munificent/currency.rb

@@ -0,0 +1,28 @@
+module Munificent
+  class Currency
+    SYMBOL_MAP = {
+      "GBP" => "£",
+      "USD" => "$",
+      "EUR" => "€",
+      "AUD" => "$",
+      "CAD" => "$",
+    }.freeze
+
+    SUPPORTED_CURRENCIES = SYMBOL_MAP.keys.freeze
+    SUPPORTED_CURRENCY_SYMBOLS = SYMBOL_MAP.values.uniq.freeze
+
+    DEFAULT_CURRENCY = "GBP".freeze
+
+    class << self
+      def present_all
+        SYMBOL_MAP.each.with_object({}) do |(iso_code, symbol), hash|
+          hash["#{iso_code} (#{symbol})"] = iso_code.upcase
+        end
+      end
+
+      def supported?(iso_code)
+        SUPPORTED_CURRENCIES.include?(iso_code.upcase)
+      end
+    end
+  end
+end

data/app/models/munificent/donation.rb

@@ -0,0 +1,55 @@
+module Munificent
+  class Donation < ApplicationRecord
+    belongs_to :donator, inverse_of: :donations
+    belongs_to :donated_by, inverse_of: :gifted_donations, optional: true, class_name: "Donator"
+    belongs_to :curated_streamer, inverse_of: :donations, optional: true
+    belongs_to :fundraiser, inverse_of: :donations
+
+    has_many :payments, inverse_of: :donation, dependent: :nullify
+
+    has_many :charity_splits, inverse_of: :donation, dependent: :destroy
+    accepts_nested_attributes_for :charity_splits
+
+    before_save do
+      if charity_splits.all? { |s| s.amount.zero? }
+        self.charity_splits = []
+      end
+    end
+
+    monetize :amount
+
+    validates :amount, presence: true, "munificent/donation_amount": true
+
+    aasm column: :state do
+      state :pending, initial: true
+      state :cancelled
+      state :paid
+      state :fulfilled
+
+      event :cancel do
+        transitions from: :pending, to: :cancelled
+      end
+
+      event :confirm_payment do
+        transitions from: :pending, to: :paid
+      end
+
+      event :fulfill do
+        transitions from: :paid, to: :fulfilled
+      end
+    end
+
+    scope :not_pending, -> { where.not(state: "pending") }
+    scope :created_before, -> (timestamp) {
+      where("created_at < ?", timestamp)
+    }
+
+    def charity_name
+      charity&.name
+    end
+
+    def donator_name
+      super || I18n.t("common.abstract.anonymous")
+    end
+  end
+end

data/app/models/munificent/donator.rb

@@ -0,0 +1,112 @@
+require "hmac"
+
+module Munificent
+  class Donator < ApplicationRecord
+    include Authenticable
+
+    attr_accessor :password_confirmation
+    attr_writer :require_password
+
+    def require_password?
+      !!@require_password
+    end
+
+    validates :password,
+      presence: true,
+      confirmation: true,
+      length: { minimum: 10 },
+      if: :require_password?
+
+    validate :email_address, -> {
+      if email_address.present? && self.class.confirmed.where.not(id:).exists?(email_address:)
+        errors.add(:email_address, :taken)
+      end
+    }
+
+    validates(:email_address,
+      uniqueness: { allow_nil: true },
+      format: { with: Munificent::EMAIL_ADDRESS_REGEX, allow_nil: true },
+    )
+
+    scope :confirmed, -> { where(confirmed: true) }
+
+    has_many :donations, inverse_of: :donator, dependent: :nullify
+    has_many :gifted_donations, inverse_of: :donated_by, dependent: :nullify, class_name: "Donation",
+                                foreign_key: "donated_by_id"
+    has_many :donator_bundles, inverse_of: :donator, dependent: :nullify
+    has_many :bundles, through: :donator_bundles
+    has_many :donator_bundle_tiers, through: :donator_bundles
+
+    has_many :curated_streamer_administrators, dependent: :destroy, inverse_of: :donator
+    has_many :curated_streamers, through: :curated_streamer_administrators
+
+    validates :twitch_id, uniqueness: true, allow_nil: true
+
+    def self.create_from_omniauth!(auth_hash)
+      case (provider = auth_hash["provider"])
+      when "twitch"
+        Donator.create!(
+          chosen_name: auth_hash.dig("info", "nickname"),
+          email_address: auth_hash.dig("info", "email"),
+          name: auth_hash.dig("info", "name"),
+          twitch_id: auth_hash["uid"],
+        )
+      else
+        raise "Unsupported provider: #{provider}"
+      end
+    end
+
+    def email_address=(new_email_address)
+      super(new_email_address.presence)
+      @token_with_email_address = nil
+    end
+
+    def total_donations(fundraiser: nil)
+      if fundraiser
+        donations.where(fundraiser:)
+      else
+        donations
+      end.map(&:amount).reduce(Money.new(0), :+)
+    end
+
+    def token
+      @token ||= HMAC::Generator
+        .new(context: "sessions")
+        .generate(id:)
+    end
+
+    def token_with_email_address
+      @token_with_email_address ||= HMAC::Generator
+        .new(context: "sessions")
+        .generate(id:, extra_fields: { email_address: })
+    end
+
+    def display_name(current_donator: nil)
+      return I18n.t("common.abstract.you") if current_donator == self
+
+      chosen_name.presence || name.presence || I18n.t("common.abstract.anonymous")
+    end
+
+    def anonymous?
+      name.blank? && chosen_name.blank?
+    end
+
+    def twitch_connected?
+      twitch_id.present?
+    end
+
+    def no_identifying_marks?
+      email_address.blank? && twitch_id.blank?
+    end
+
+    def confirm
+      return unless confirmed? || unconfirmed_email_address.present?
+
+      update(
+        confirmed: true,
+        email_address: unconfirmed_email_address,
+        unconfirmed_email_address: nil,
+      )
+    end
+  end
+end

data/app/models/munificent/donator_bundle.rb

@@ -0,0 +1,51 @@
+module Munificent
+  class DonatorBundle < ApplicationRecord
+    belongs_to :donator
+    belongs_to :bundle
+
+    has_many :donator_bundle_tiers, dependent: :destroy
+    has_many :keys, through: :donator_bundle_tiers
+
+    def self.build_from(bundle, **attrs)
+      new(bundle:, **attrs).tap do |donator_bundle|
+        bundle.bundle_tiers.each do |bundle_tier|
+          donator_bundle.donator_bundle_tiers.build(bundle_tier:)
+        end
+      end
+    end
+
+    def self.create_from(...)
+      build_from(...).tap(&:save!)
+    end
+
+    def complete?
+      locked_tiers.none?
+    end
+
+    def next_unlockable_tier
+      unlockable_tiers.first
+    end
+
+    def unlockable_tiers_at_or_below(amount)
+      unlockable_tiers.where("price_decimals <= ?", amount.fractional)
+    end
+
+  private
+
+    def locked_tiers
+      donator_bundle_tiers.locked
+    end
+
+    def unlockable_tiers
+      window_sql = <<~SQL.squish
+        (munificent_bundle_tiers.starts_at IS NULL OR munificent_bundle_tiers.starts_at <= :now)
+        AND (munificent_bundle_tiers.ends_at IS NULL OR munificent_bundle_tiers.ends_at > :now)
+      SQL
+
+      locked_tiers
+        .joins(:bundle_tier)
+        .order(:price_decimals)
+        .where(window_sql, now: Time.now.utc)
+    end
+  end
+end