implemented the reward admin controller

Author: elmuerte

app/controllers/discourse_kofi/admin/rewards_controller.rb

@@ -20,19 +20,111 @@ def index
       end
 
       def show
-        #TODO
+        render_reward(find_reward)
       end
 
       def create
-        #TODO
+        reward = Reward.new
+        errors = update_reward_from_params(reward, new: true)
+        if errors.present?
+          render_json_error errors
+        else
+          StaffActionLogger.new(current_user).log_custom(
+            "kofi_reward_creation",
+            log_details(reward)
+          )
+          render_reward(reward)
+        end
       end
 
       def update
-        #TODO
+        reward = find_reward
+        errors = update_reward_from_params(reward)
+        if errors.present?
+          render_json_error errors
+        else
+          StaffActionLogger.new(current_user).log_custom(
+            "kofi_reward_change",
+            log_details(reward, update: true)
+          )
+          render_reward(reward)
+        end
       end
 
       def destroy
-        #TODO
+        Reward.transaction do
+          reward = find_reward
+          StaffActionLogger.new(current_user).log_custom(
+            "kofi_reward_deletion",
+            log_details(reward)
+          )
+          reward.destroy!
+        end
+        render json: success_json
+      end
+
+      private
+
+      def render_reward(reward)
+        if reward.subscription
+          render_serialized(reward, SubscriptionRewardSerializer)
+        else
+          render_serialized(reward, RewardSerializer)
+        end
+      end
+
+      def find_reward
+        params.require(:id)
+        reward = Reward.find(params[:id])
+        raise Discourse::NotFound unless reward
+        reward
+      end
+
+      def update_reward_from_params(reward, opts = {})
+        errors = []
+        Reward.transaction do
+          allowed = Reward.column_names.map(&:to_sym)
+          allowed -= %i[id created_at updated_at]
+          allowed -= %i[subscription] unless opts[:new]
+          params.permit(*allowed)
+
+          allowed.each do |key|
+            reward.public_send("#{key}=", params[key]) if params[key]
+          end
+
+          reward.id = nil if opts[:new]
+          reward.save!
+        end
+
+        if opts[:new].blank?
+          #TODO schedule mass reward
+        end
+
+        errors
+      rescue ActiveRecord::RecordInvalid
+        errors.push(*reward.errors.full_messages)
+        errors
+      end
+
+      REWARD_FIELDS =
+        Reward.attribute_names.excluding("id", "created_at", "updated_at")
+
+      def log_details(reward, update = false)
+        details = {}
+        if update
+          details[:subscription] = reward.subscription
+          reward.previous_changes.each do |f, values|
+            details[f.to_sym] = values[1] if REWARD_FIELDS.include?(f)
+          end
+        else
+          details =
+            REWARD_FIELDS
+              .map { |f| [f, reward.public_send(f)] }
+              .select { |f, v| v.present? }
+              .to_h
+        end
+        details[:reward_id] = reward.id
+        details
       end
     end
   end

app/models/discourse_kofi/reward.rb

@@ -34,12 +34,18 @@ class Reward < ActiveRecord::Base
     validate :valid_payment_types, unless: :subscription?
 
     def valid_payment_types
-      payment_types.each do |payment_type|
-        if !Payment::PAYMENT_TYPES.keys.include?(payment_type.to_sym)
-          errors.add(
-            :payment_types,
-            "'#{payment_type}' is not a valid payment type"
-          )
+      if !payment_types.kind_of?(Array)
+        errors.add(:payment_types, "must be an array")
+      elsif payment_types.empty?
+        errors.add(:payment_types, "must contain at least one value")
+      else
+        payment_types.each do |payment_type|
+          if !Payment::PAYMENT_TYPES.keys.include?(payment_type.to_sym)
+            errors.add(
+              :payment_types,
+              "'#{payment_type}' is not a valid payment type"
+            )
+          end
         end
       end
     end

app/serializers/discourse_kofi/base_reward_serializer.rb

@@ -8,7 +8,9 @@ class IdNameSerializer < ApplicationSerializer
   end
 
   class BaseRewardSerializer < ApplicationSerializer
-    attributes :id
+    root "reward"
+
+    attributes :id, :subscription
 
     has_one :group, serializer: IdNameSerializer, embed: :objects
   end

spec/requests/admin/rewards_controller_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+RSpec.describe DiscourseKofi::Admin::RewardsController do
+  fab!(:admin)
+
+  before do
+    SiteSetting.kofi_enabled = true
+    sign_in(admin)
+  end
+
+  fab!(:reward)
+  fab!(:subscription_reward)
+
+  describe "#index" do
+    it "returns all rewards" do
+      get "/ko-fi/admin/rewards.json"
+      expect(response.status).to eq(200)
+      parsed = response.parsed_body
+      expect(parsed[:rewards]).to contain_exactly(include(id: reward.id))
+      expect(parsed[:subscriptions]).to contain_exactly(
+        include(id: subscription_reward.id)
+      )
+    end
+  end
+
+  describe "#show" do
+    it "returns a reward" do
+      get "/ko-fi/admin/rewards/#{reward.id}.json"
+      expect(response.status).to eq(200)
+      parsed = response.parsed_body
+      expect(parsed[:reward][:id]).to eq reward.id
+      expect(parsed[:reward][:subscription]).to be false
+      expect(parsed[:reward][:amount]).to eq reward.amount.as_json
+
+      expect(parsed[:reward][:tier_name]).to be_nil
+    end
+
+    it "returns a subscription reward" do
+      get "/ko-fi/admin/rewards/#{subscription_reward.id}.json"
+      expect(response.status).to eq(200)
+      parsed = response.parsed_body
+      expect(parsed[:reward][:id]).to eq subscription_reward.id
+      expect(parsed[:reward][:subscription]).to be true
+      expect(parsed[:reward][:tier_name]).to eq subscription_reward.tier_name
+
+      expect(parsed[:reward][:amount]).to be_nil
+    end
+
+    it "cannot find an unknown reward" do
+      get "/ko-fi/admin/rewards/99999999999999999.json"
+      expect(response.status).to eq(404)
+    end
+  end
+
+  describe "#create" do
+    fab!(:badge)
+    fab!(:group)
+
+    it "can create a new reward" do
+      StaffActionLogger
+        .any_instance
+        .expects(:log_custom)
+        .with("kofi_reward_creation", anything)
+        .once
+
+      post "/ko-fi/admin/rewards.json",
+           params: {
+             subscription: false,
+             badge_id: badge.id,
+             group_id: group.id,
+             amount: 123.45,
+             payment_types: %i[donation subscription]
+           }
+
+      expect(response.status).to eq(200)
+      parsed = response.parsed_body
+      expect(parsed[:reward][:id]).not_to be_nil
+      expect(parsed[:reward][:subscription]).to be false
+      expect(parsed[:reward][:badge][:id]).to eq badge.id
+      expect(parsed[:reward][:group][:id]).to eq group.id
+      expect(parsed[:reward][:amount]).to eq "123.45"
+      expect(parsed[:reward][:payment_types]).to match_array(
+        %w[donation subscription]
+      )
+    end
+
+    it "can create a new subscription reward" do
+      StaffActionLogger
+        .any_instance
+        .expects(:log_custom)
+        .with("kofi_reward_creation", anything)
+        .once
+
+      post "/ko-fi/admin/rewards.json",
+           params: {
+             subscription: true,
+             group_id: group.id,
+             tier_name: "premium"
+           }
+
+      expect(response.status).to eq(200)
+      parsed = response.parsed_body
+      expect(parsed[:reward][:id]).not_to be_nil
+      expect(parsed[:reward][:subscription]).to be true
+      expect(parsed[:reward][:group][:id]).to eq group.id
+      expect(parsed[:reward][:tier_name]).to eq "premium"
+    end
+
+    it "cannot create an invalid reward" do
+      StaffActionLogger
+        .any_instance
+        .expects(:log_custom)
+        .with("kofi_reward_creation", anything)
+        .never
+
+      post "/ko-fi/admin/rewards.json",
+           params: {
+             subscription: false,
+             group_id: group.id,
+             tier_name: "premium"
+           }
+
+      expect(response.status).to eq(422)
+      parsed = response.parsed_body
+      expect(parsed[:errors]).to match_array(
+        [
+          "Tier name must be blank",
+          "Payment types can't be blank",
+          "Amount is not a number",
+          "Payment types must be an array"
+        ]
+      )
+    end
+
+    describe "#update" do
+      it "can update a reward" do
+        StaffActionLogger
+          .any_instance
+          .expects(:log_custom)
+          .with("kofi_reward_change", anything)
+          .once
+
+        patch "/ko-fi/admin/rewards/#{reward.id}.json",
+              params: {
+                group_id: nil,
+                amount: 123.45,
+                payment_types: %w[donation subscription]
+              }
+
+        expect(response.status).to eq(200)
+        parsed = response.parsed_body
+        expect(parsed[:reward][:id]).to eq reward.id
+        expect(parsed[:reward][:subscription]).to be false
+        expect(parsed[:reward][:group]).to be_nil
+        expect(parsed[:reward][:amount]).to eq "123.45"
+        expect(parsed[:reward][:payment_types]).to match_array(
+          %w[donation subscription]
+        )
+      end
+
+      it "cannot change the subscription kind" do
+        patch "/ko-fi/admin/rewards/#{reward.id}.json",
+              params: {
+                subscription: true
+              }
+
+        expect(response.status).to eq(200)
+        parsed = response.parsed_body
+        expect(parsed[:reward][:subscription]).to be false
+      end
+
+      it "cannot make invalid changes" do
+        patch "/ko-fi/admin/rewards/#{reward.id}.json",
+              params: {
+                tier_name: "something"
+              }
+
+        expect(response.status).to eq(422)
+      end
+
+      it "cannot unpdate an unknown reward" do
+        patch "/ko-fi/admin/rewards/9999999999999.json", params: {}
+
+        expect(response.status).to eq(404)
+      end
+    end
+
+    describe "#destroy" do
+      it "can delete a reward" do
+        StaffActionLogger
+          .any_instance
+          .expects(:log_custom)
+          .with("kofi_reward_deletion", anything)
+          .once
+
+        delete "/ko-fi/admin/rewards/#{reward.id}.json"
+        expect(response.status).to eq(200)
+
+        get "/ko-fi/admin/rewards/#{reward.id}.json"
+        expect(response.status).to eq(404)
+      end
+
+      it "cannot delete an unknown rewared" do
+        delete "/ko-fi/admin/rewards/9999999999999.json"
+        expect(response.status).to eq(404)
+      end
+    end
+  end
+end

spec/serializers/reward_serializer_spec.rb

@@ -7,6 +7,7 @@
     json = DiscourseKofi::RewardSerializer.new(reward, { root: false }).as_json
 
     expect(json[:id]).not_to be_nil
+    expect(json[:subscription]).to be false
     expect(json[:badge]).not_to be_nil
     expect(json[:badge][:id]).to eq reward.badge.id
     expect(json[:badge][:name]).to eq reward.badge.name

spec/serializers/subscription_reward_serializer_spec.rb

@@ -11,6 +11,7 @@
       ).as_json
 
     expect(json[:id]).not_to be_nil
+    expect(json[:subscription]).to be true
     expect(json[:group]).not_to be_nil
     expect(json[:group][:id]).to eq reward.group.id
     expect(json[:group][:name]).to eq reward.group.name