GT-1314, implement saving user count values

app/controllers/user_counters_controller.rb

@@ -3,16 +3,18 @@
 class UserCountersController < WithUserController
   def update
     counter = current_user.user_counters.where(counter_name: counter_name).first_or_initialize
+    counter.decay
     increment = permitted_params[:increment].to_f
     counter.count += increment
-    counter.decay
     counter.decayed_count += increment
+    counter.save! if counter.new_record? # need to save before applying values if new user counter
+    counter.apply_values(permitted_params[:values]) if permitted_params[:values]
     counter.save!
     render json: counter, status: :ok
   end
 
   def index
-    counters = current_user.user_counters
+    counters = current_user.user_counters.order(:id)
     # decay but don't save as it's not needed and it'll be more efficient this way -- the in-memory decay calculation is very fast
     counters.each(&:decay)
     render json: counters, status: :ok
@@ -21,7 +23,7 @@ def index
   protected
 
   def permitted_params
-    params.require(:data).require(:attributes).permit(:increment)
+    params.require(:data).require(:attributes).permit(:increment, values: [])
   end
 
   def counter_name

app/models/user_counter.rb

@@ -7,13 +7,20 @@ class UserCounter < ApplicationRecord
   validates :counter_name, format: {with: /\A[-_.a-zA-Z0-9]+\z/, message: "has invalid characters"}
 
   def decay
-    date_now = Date.today
-    self.last_decay ||= Date.today
+    date_now = Time.now.utc.to_date
+    self.last_decay ||= date_now
     days_to_decay = date_now - last_decay
 
     if days_to_decay > 0
       self.decayed_count *= (Math::E**(DECAY_RATE * days_to_decay))
       self.last_decay = date_now
     end
   end
+
+  def apply_values(values)
+    new_values = values - self.values
+    self.values += new_values
+    self.count += new_values.count
+    self.decayed_count += new_values.count
+  end
 end

db/migrate/20211110153757_create_user_counters.rb

@@ -5,7 +5,7 @@ def change
       t.string :counter_name
       t.integer :count, default: 0
       t.float :decayed_count, default: 0
-      t.date :last_decay, default: -> { "NOW()" }
+      t.date :last_decay, default: -> { timezone("utc", NOW()) }
 
       t.timestamps
     end

db/migrate/20220504203747_add_values_to_user_counters.rb

@@ -0,0 +1,8 @@
+class AddValuesToUserCounters < ActiveRecord::Migration[6.1]
+  def change
+    change_table :user_counters do |t|
+      t.string "values", array: true, default: "{}"
+    end
+    add_index :user_counters, :values, using: "gin"
+  end
+end

db/migrate/20220504204229_remove_user_counter_values_table.rb

@@ -0,0 +1,6 @@
+class RemoveUserCounterValuesTable < ActiveRecord::Migration[6.1]
+  def change
+    return unless ActiveRecord::Base.connection.table_exists?("user_counter_values")
+    drop_table :user_counter_values
+  end
+end

spec/acceptance/user_counters_controller_spec.rb

@@ -57,12 +57,55 @@
         expect(UserCounter.last.last_decay).to eq(Date.today)
       end
     end
+
+    context "with values" do
+      it "creates user_counter" do
+        expect {
+          do_request data: {type: "user_counter", attributes: {increment: 20, values: ["v1", "v2"]}}
+        }.to change { UserCounter.count }.by(1)
+
+        expect(status).to eq(200)
+        json_response = JSON.parse(response_body)["data"]
+        expect(json_response).not_to be_nil
+        expect(json_response["id"]).to eq("tool_opens.kgp")
+        expect(json_response["attributes"]["count"]).to eq(22)
+        expect(json_response["attributes"]["decayed-count"]).to eq(22)
+        expect(json_response["attributes"]["last-decay"]).to eq(Date.today.to_s)
+        expect(UserCounter.last.counter_name).to eq("tool_opens.kgp")
+        expect(UserCounter.last.count).to eq(22)
+        expect(UserCounter.last.decayed_count).to eq(22)
+        expect(UserCounter.last.last_decay).to eq(Date.today)
+      end
+
+      context "when user_counter exists" do
+        let!(:user_counter) { FactoryBot.create(:user_counter, user: user, counter_name: "tool_opens.kgp", count: 50, decayed_count: 50, last_decay: 90.days.ago) }
+
+        it "updates the count and decay" do
+          expect {
+            do_request data: {type: "user_counter", attributes: {increment: 20, values: ["v1", "v2"]}}
+          }.to_not change { user_counter.count }
+
+          expect(status).to eq(200)
+          json_response = JSON.parse(response_body)["data"]
+          expect(json_response).not_to be_nil
+          expect(json_response["id"]).to eq("tool_opens.kgp")
+          expect(json_response["attributes"]["count"]).to eq(72)
+          expect((json_response["attributes"]["decayed-count"] - 47).abs).to be <= 0.004 # look within 0.004, close enough
+          expect(json_response["attributes"]["last-decay"]).to eq(Date.today.to_s)
+          expect(UserCounter.last.count).to eq(72)
+          # get close to 45 -- original value of 50 should decay to 25 with the 90 day half-life, then +20 from the patch count incremement
+          expect((UserCounter.last.decayed_count - 47).abs).to be <= 0.004
+          expect(UserCounter.last.last_decay).to eq(Date.today)
+          expect(UserCounter.last.values).to eq(["v1", "v2"])
+        end
+      end
+    end
   end
 
   get "user/counters" do
     let(:user) { FactoryBot.create(:user) }
-    let!(:user_counter) { FactoryBot.create(:user_counter, user: user, counter_name: "tool_opens.kgp", count: 50, decayed_count: 50, last_decay: 90.days.ago) }
-    let!(:user_counter2) { FactoryBot.create(:user_counter, user: user, counter_name: "other.kgp", count: 60, decayed_count: 40, last_decay: 90.days.ago) }
+    let!(:user_counter) { FactoryBot.create(:user_counter, user: user, counter_name: "tool_opens.kgp", count: 50, decayed_count: 50, last_decay: 90.days.ago.utc) }
+    let!(:user_counter2) { FactoryBot.create(:user_counter, user: user, counter_name: "other.kgp", count: 60, decayed_count: 40, last_decay: 90.days.ago.utc) }
     requires_okta_login
 
     it "gets counts" do
@@ -73,5 +116,17 @@
       expected_result = %({"data":[{"id":"tool_opens.kgp","type":"user-counter","attributes":{"count":50,"decayed-count":25.00367978478838,"last-decay":"#{today}"}},{"id":"other.kgp","type":"user-counter","attributes":{"count":60,"decayed-count":20.002943827830705,"last-decay":"#{today}"}}]})
       expect(response_body).to eq(expected_result)
     end
+
+    context "with values" do
+      it "includes values" do
+        user_counter.update(values: ["v1", "v2"])
+        do_request
+
+        expect(status).to eq(200)
+        today = Date.today.to_s
+        expected_result = %({"data":[{"id":"tool_opens.kgp","type":"user-counter","attributes":{"count":50,"decayed-count":25.00367978478838,"last-decay":"#{today}"}},{"id":"other.kgp","type":"user-counter","attributes":{"count":60,"decayed-count":20.002943827830705,"last-decay":"#{today}"}}]})
+        expect(response_body).to eq(expected_result)
+      end
+    end
   end
 end