Gifted Stickers for incomplete users

app/models/user.rb

@@ -30,6 +30,11 @@ class User < ApplicationRecord
       transition registered: :incompleted
     end
 
+    event :gifted do
+      transition incompleted: :gifted_sticker,
+                 if: ->(user) { user.sticker_coupon }
+    end
+
     event :retry_complete do
       transition incompleted: :completed
     end
@@ -48,7 +53,7 @@ class User < ApplicationRecord
       validates :shirt_coupon, absence: true
     end
 
-    state all - [:won_sticker] do
+    state all - %i[won_sticker gifted_sticker] do
       validates :sticker_coupon, absence: true
     end
 
@@ -88,6 +93,15 @@ def win
         in: [true], message: 'hacktoberfest has not yet ended' }
       validates :sufficient_eligible_prs?, inclusion: {
         in: [false], message: 'user has too many sufficient eligible prs' }
+
+      def gift
+        assign_coupon
+        gifted
+      end
+    end
+
+    state :gifted_sticker do
+      validates :sticker_coupon, presence: true
     end
 
     before_transition do |user, _transition|

app/services/coupon_service.rb

@@ -6,11 +6,7 @@ def initialize(user)
   end
 
   def assign_coupon
-    if shirt_coupon.present?
-      @user.association(:shirt_coupon).replace(shirt_coupon, false)
-    elsif sticker_coupon.present?
-      @user.association(:sticker_coupon).replace(sticker_coupon, false)
-    end
+    assign_sticker_coupon unless assign_shirt_coupon
   end
 
   private
@@ -22,4 +18,18 @@ def shirt_coupon
   def sticker_coupon
     StickerCoupon.first_available
   end
+
+  def assign_shirt_coupon
+    # TODO: Remove this return statement to allow gifting of extra shirt
+    # coupons in future Hacktoberfest events.
+    return unless @user.completed? && shirt_coupon.present?
+
+    @user.association(:shirt_coupon).replace(shirt_coupon, false)
+  end
+
+  def assign_sticker_coupon
+    return if sticker_coupon.blank?
+
+    @user.association(:sticker_coupon).replace(sticker_coupon, false)
+  end
 end

app/services/gift_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GiftService
+  module_function
+
+  def call
+    user_dates = []
+
+    User.where(state: 'incompleted').find_in_batches do |group|
+      group.each do |u|
+        last_pr = u.receipt.max_by do |pr_obj|
+          Time.zone.parse(
+            pr_obj['github_pull_request']['graphql_hash']['createdAt']
+          )
+        end
+        date = last_pr['github_pull_request']['graphql_hash']['createdAt']
+        score = u.receipt.count
+        user_dates << { id: u.id, score: score, date: date }
+      end
+    end
+
+    sorted = user_dates.sort do |a, b|
+      a_date = Time.zone.parse(a[:date])
+      b_date = Time.zone.parse(b[:date])
+
+      # This comparison will prioritize first the score of the objects and then
+      # their dates.
+      [b[:score], a_date] <=> [a[:score], b_date]
+    end
+
+    sorted.each do |user_date|
+      u = User.find(user_date[:id])
+      u.gift
+    end
+  end
+end

app/services/user_state_transition_segment_service.rb

@@ -15,6 +15,7 @@ def call(user, transition)
     when :incomplete then incomplete(user)
     when :ineligible then ineligible(user)
     when :won then won(user, transition)
+    when :gift_sticker then gift_sticker(user)
     end
   end
 
@@ -61,6 +62,11 @@ def won(user, transition)
     end
   end
 
+  def gift_sticker(user)
+    segment(user).identify(state: 'gifted_sticker')
+    segment(user).track('user_gifted_sticker')
+  end
+
   def segment(user)
     SegmentService.new(user)
   end

lib/tasks/gifts.rake

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+namespace :gift do
+  # TODO: Update this rake task to reflect giving users any remaining available
+  # shirt coupons when that is implemented in `CouponService`
+  desc 'gift remaining stickers to incompleted users'
+  task stickers: :environment do
+    sticker_coupon_count = StickerCoupon.where(user_id: nil).count
+
+    incompleted_user_count = User.where(state: 'incompleted').count
+
+    message = "There are #{sticker_coupon_count} stickers remaining.
+      There are #{incompleted_user_count} users who are incompleted
+      and eligible for gift_sticker.
+
+      Do you want to gift the remaining coupons to incompleted users? (y/n)"
+
+    Rails.logger.info message
+
+    input = STDIN.gets.strip
+
+    if input == 'y'
+      Rails.logger.info 'Gifting coupons...'
+      GiftService.call
+    else
+      Rails.logger.info 'Terminating.'
+    end
+  end
+end

spec/models/user_spec.rb

@@ -519,12 +519,51 @@
     end
   end
 
+  describe '#gift' do
+    before do
+      allow(UserStateTransitionSegmentService)
+        .to receive(:gift_sticker).and_return(true)
+    end
+
+    context 'the user is in the incompleted state' do
+      let(:user) { FactoryBot.create(:user, :incompleted) }
+
+      context 'there are shirt coupons available' do
+        before do
+          FactoryBot.create(:shirt_coupon)
+        end
+
+        # TODO: Edit this spec to allow ability for an incomplete user to
+        # receive a gifted shirt and therefore entering gifted_shirt state.
+        it 'does not transition user to gifted_shirt state' do
+          expect(user.state).to_not eq('gifted_shirt')
+        end
+      end
+
+      context 'there are sticker coupons available' do
+        before do
+          FactoryBot.create(:sticker_coupon)
+        end
+
+        it 'transitions the user to gifted_sticker state' do
+          user.gift
+          expect(user.state).to eq('gifted_sticker')
+        end
+      end
+
+      context 'there are no shirt coupons or sticker coupons available' do
+        it 'does not transition the user' do
+          user.gift
+          expect(user.state).to eq('incompleted')
+        end
+      end
+    end
+  end
+
   describe '#win' do
     before do
       allow(UserStateTransitionSegmentService)
         .to receive(:won).and_return(true)
-
-      user.register
     end
     context 'the user is in the completed state' do
       let(:user) { FactoryBot.create(:user, :completed) }

spec/rails_helper.rb

@@ -92,6 +92,7 @@ def segment_write_key
   config.include AuthenticationHelper
   config.include PullRequestFilterHelper
   config.include GraphqlClientHelper
+  config.include UserReceiptHelper
 
   config.infer_spec_type_from_file_location!
 

spec/services/coupon_service_spec.rb

@@ -3,67 +3,140 @@
 require 'rails_helper'
 
 RSpec.describe CouponService do
-  let(:user) { FactoryBot.create(:user, :completed) }
-  let(:coupon_service) { CouponService.new(user) }
-
   describe '#assign_coupon' do
-    context 'there are only shirt coupons available' do
-      before do
-        FactoryBot.create(:shirt_coupon)
-        coupon_service.assign_coupon
-      end
+    context 'with a completed user' do
+      let(:user) { FactoryBot.create(:user, :completed) }
+      let(:coupon_service) { CouponService.new(user) }
 
-      it 'assigns the user a shirt coupon' do
-        expect(user.shirt_coupon).to be_a(ShirtCoupon)
-      end
+      context 'there are only shirt coupons available' do
+        before do
+          FactoryBot.create(:shirt_coupon)
+          coupon_service.assign_coupon
+        end
 
-      it 'does not assign a sticker coupon' do
-        expect(user.sticker_coupon).to eq(nil)
+        it 'assigns the user a shirt coupon' do
+          expect(user.shirt_coupon).to be_a(ShirtCoupon)
+        end
+
+        it 'does not assign a sticker coupon' do
+          expect(user.sticker_coupon).to eq(nil)
+        end
       end
-    end
 
-    context 'there are only sticker coupons available' do
-      before do
-        FactoryBot.create(:sticker_coupon)
-        coupon_service.assign_coupon
+      context 'there are only sticker coupons available' do
+        before do
+          FactoryBot.create(:sticker_coupon)
+          coupon_service.assign_coupon
+        end
+
+        it 'assigns the user a sticker coupon' do
+          expect(user.sticker_coupon).to be_a(StickerCoupon)
+        end
+
+        it 'does not assign a shirt coupon' do
+          expect(user.shirt_coupon).to eq(nil)
+        end
       end
 
-      it 'assigns the user a sticker coupon' do
-        expect(user.sticker_coupon).to be_a(StickerCoupon)
+      context 'there are both shirt and sticker coupons available' do
+        before do
+          FactoryBot.create(:shirt_coupon)
+          FactoryBot.create(:sticker_coupon)
+          coupon_service.assign_coupon
+        end
+
+        it 'assigns the user a shirt coupon' do
+          expect(user.shirt_coupon).to be_a(ShirtCoupon)
+        end
+
+        it 'does not assign a sticker coupon' do
+          expect(user.sticker_coupon).to eq(nil)
+        end
       end
 
-      it 'does not assign a shirt coupon' do
-        expect(user.shirt_coupon).to eq(nil)
+      context 'there are neither shirt nor sticker coupons available' do
+        before do
+          coupon_service.assign_coupon
+        end
+
+        it 'does not assign a shirt coupon' do
+          expect(user.shirt_coupon).to eq(nil)
+        end
+
+        it 'does not assign a sticker coupon' do
+          expect(user.sticker_coupon).to eq(nil)
+        end
       end
     end
 
-    context 'there are both shirt and sticker coupons available' do
-      before do
-        FactoryBot.create(:shirt_coupon)
-        FactoryBot.create(:sticker_coupon)
-        coupon_service.assign_coupon
-      end
+    context 'with an incompleted user' do
+      let(:user) { FactoryBot.create(:user, :incompleted) }
+      let(:coupon_service) { CouponService.new(user) }
 
-      it 'assigns the user a shirt coupon' do
-        expect(user.shirt_coupon).to be_a(ShirtCoupon)
-      end
+      context 'there are only shirt coupons available' do
+        before do
+          FactoryBot.create(:shirt_coupon)
+          coupon_service.assign_coupon
+        end
+
+        # TODO: Add this test to allow gifting of extra shirt
+        # coupons in future Hacktoberfest events.
+        xit 'assigns the user a shirt coupon' do
+          expect(user.shirt_coupon).to be_a(ShirtCoupon)
+        end
 
-      it 'does not assign a sticker coupon' do
-        expect(user.sticker_coupon).to eq(nil)
+        it 'does not assign a sticker coupon' do
+          expect(user.sticker_coupon).to eq(nil)
+        end
       end
-    end
 
-    context 'there are neither shirt nor sticker coupons available' do
-      before do
-        coupon_service.assign_coupon
+      context 'there are both shirt and sticker coupons available' do
+        before do
+          FactoryBot.create(:shirt_coupon)
+          FactoryBot.create(:sticker_coupon)
+          coupon_service.assign_coupon
+        end
+
+        # TODO: Add this test to allow gifting of extra shirt
+        # coupons in future Hacktoberfest events.
+        xit 'assigns the user a shirt coupon' do
+          expect(user.shirt_coupon).to be_a(ShirtCoupon)
+        end
+
+        # TODO: Add this test to allow gifting of extra shirt
+        # coupons in future Hacktoberfest events.
+        xit 'does not assign a sticker coupon' do
+          expect(user.sticker_coupon).to eq(nil)
+        end
       end
 
-      it 'does not assign a shirt coupon' do
-        expect(user.shirt_coupon).to eq(nil)
+      context 'there are only sticker coupons available' do
+        before do
+          FactoryBot.create(:sticker_coupon)
+          coupon_service.assign_coupon
+        end
+
+        it 'assigns the user a sticker coupon' do
+          expect(user.sticker_coupon).to be_a(StickerCoupon)
+        end
+
+        it 'does not assign a shirt coupon' do
+          expect(user.shirt_coupon).to eq(nil)
+        end
       end
 
-      it 'does not assign a sticker coupon' do
-        expect(user.sticker_coupon).to eq(nil)
+      context 'there are no coupons available' do
+        before do
+          coupon_service.assign_coupon
+        end
+
+        it 'does not assign a shirt coupon' do
+          expect(user.shirt_coupon).to eq(nil)
+        end
+
+        it 'does not assign the user a sticker coupon' do
+          expect(user.sticker_coupon).to eq(nil)
+        end
       end
     end
   end