plan_my_stuff 0.6.0 → 0.8.0

data/app/controllers/plan_my_stuff/project_items/assignments_controller.rb

@@ -8,7 +8,7 @@ module PlanMyStuff
     # PATCH  /projects/:project_id/items/:item_id/assignment -> update (assign)
     # DELETE /projects/:project_id/items/:item_id/assignment -> destroy (unassign)
     #
-    class AssignmentsController < ApplicationController
+    class AssignmentsController < PlanMyStuff::ApplicationController
       # PATCH /projects/:project_id/items/:item_id/assignment
       def update
         item = find_project_item
@@ -16,9 +16,15 @@ module PlanMyStuff
 
         item.assign!(assignees)
 
-        flash[:success] = "Item assigned to #{assignees.join(', ')}."
+        flash[:success] =
+          if assignees.present?
+            "Item assigned to #{assignees.join(', ')}."
+          else
+            'All assignees removed.'
+          end
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
-      rescue ArgumentError, PMS::Error => e
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
       end
@@ -39,7 +45,8 @@ module PlanMyStuff
 
         flash[:success] = "#{params[:username]} unassigned."
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
-      rescue ArgumentError, PMS::Error => e
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
       end
@@ -51,10 +58,10 @@ module PlanMyStuff
         # @return [PlanMyStuff::ProjectItem]
         #
         def find_project_item
-          project = PMS::Project.find(params[:project_id].to_i)
+          project = PlanMyStuff::Project.find(params[:project_id].to_i)
           item = project.items.find { |i| i.id == params[:item_id] }
 
-          raise(PMS::APIError, "Item not found: #{params[:item_id]}") unless item
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
 
           item
         end

data/app/controllers/plan_my_stuff/project_items/statuses_controller.rb

@@ -7,7 +7,7 @@ module PlanMyStuff
     #
     # PATCH /projects/:project_id/items/:item_id/status -> update (moves to new status)
     #
-    class StatusesController < ApplicationController
+    class StatusesController < PlanMyStuff::ApplicationController
       # PATCH /projects/:project_id/items/:item_id/status
       def update
         item = find_project_item
@@ -16,7 +16,8 @@ module PlanMyStuff
 
         flash[:success] = "Item moved to #{params[:status]}."
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
-      rescue ArgumentError, PMS::Error => e
+      rescue ArgumentError, PlanMyStuff::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.project_path(params[:project_id]))
       end
@@ -28,10 +29,10 @@ module PlanMyStuff
         # @return [PlanMyStuff::ProjectItem]
         #
         def find_project_item
-          project = PMS::Project.find(params[:project_id].to_i)
+          project = PlanMyStuff::Project.find(params[:project_id].to_i)
           item = project.items.find { |i| i.id == params[:item_id] }
 
-          raise(PMS::APIError, "Item not found: #{params[:item_id]}") unless item
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
 
           item
         end

data/app/controllers/plan_my_stuff/project_items_controller.rb

@@ -1,22 +1,47 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class ProjectItemsController < ApplicationController
+  class ProjectItemsController < PlanMyStuff::ApplicationController
     # POST /projects/:project_id/items
     def create
       project_number = params[:project_id].to_i
 
       if params[:draft] == '1'
-        PMS::ProjectItem.create!(params[:title], draft: true, body: params[:body], project_number: project_number)
+        PlanMyStuff::ProjectItem.create!(
+          params[:title],
+          draft: true,
+          body: params[:body],
+          project_number: project_number,
+        )
         flash[:success] = 'Draft item created.'
       else
-        issue = PMS::Issue.find(params[:issue_number].to_i)
-        PMS::ProjectItem.create!(issue, project_number: project_number)
+        issue = PlanMyStuff::Issue.find(params[:issue_number].to_i)
+        PlanMyStuff::ProjectItem.create!(issue, project_number: project_number)
         flash[:success] = "Issue ##{issue.number} added to project."
       end
 
       redirect_to(plan_my_stuff.project_path(project_number))
-    rescue ArgumentError, PMS::Error, Octokit::Error => e
+    rescue ArgumentError, PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
+      flash[:error] = e.message
+      redirect_to(plan_my_stuff.project_path(project_number))
+    end
+
+    # DELETE /projects/:project_id/items/:id
+    def destroy
+      project_number = params[:project_id].to_i
+      item_id = params[:id]
+
+      project = PlanMyStuff::Project.find(project_number)
+      item = project.items.find { |i| i.id == item_id }
+      raise(PlanMyStuff::APIError, "Item not found: #{item_id}") if item.nil?
+
+      item.destroy!(user: pms_current_user)
+
+      flash[:success] = 'Item removed from project.'
+      redirect_to(plan_my_stuff.project_path(project_number))
+    rescue ArgumentError, PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
       flash[:error] = e.message
       redirect_to(plan_my_stuff.project_path(project_number))
     end

data/app/controllers/plan_my_stuff/projects_controller.rb

@@ -1,28 +1,27 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class ProjectsController < ApplicationController
+  class ProjectsController < PlanMyStuff::ApplicationController
     # GET /projects
     def index
-      all_projects = PMS::BaseProject.list.reject(&:closed)
+      all_projects = PlanMyStuff::BaseProject.list.reject(&:closed)
       @filter = params[:filter].presence_in(%w[testing all]) || 'regular'
       @projects =
         case @filter
-        when 'testing' then all_projects.select { |p| p.is_a?(PMS::TestingProject) }
-        when 'regular' then all_projects.reject { |p| p.is_a?(PMS::TestingProject) }
+        when 'testing' then all_projects.select { |p| p.is_a?(PlanMyStuff::TestingProject) }
+        when 'regular' then all_projects.reject { |p| p.is_a?(PlanMyStuff::TestingProject) }
         else all_projects
         end
-      @support_user = support_user?
     end
 
     # GET /projects/new
     def new
-      @project = PMS::Project.new
+      @project = PlanMyStuff::Project.new
     end
 
     # POST /projects
     def create
-      @project = PMS::Project.create!(
+      @project = PlanMyStuff::Project.create!(
         title: project_params[:title],
         readme: project_params[:readme] || '',
         description: project_params[:description],
@@ -31,32 +30,32 @@ module PlanMyStuff
 
       flash[:success] = 'Project was successfully created.'
       redirect_to(plan_my_stuff.project_path(@project.number))
-    rescue PMS::ValidationError => e
-      @project = PMS::Project.new(
+    rescue PlanMyStuff::ValidationError => e
+      pms_handle_rescue(e)
+      @project = PlanMyStuff::Project.new(
         title: project_params[:title],
         readme: project_params[:readme],
         description: project_params[:description],
       )
       flash.now[:error] = e.message
-      render(:new, status: PMS.unprocessable_status)
+      render(:new, status: PlanMyStuff.unprocessable_status)
     end
 
     # GET /projects/:id
     def show
-      @project = PMS::Project.find(params[:id].to_i)
+      @project = PlanMyStuff::Project.find(params[:id].to_i)
       @statuses = @project.statuses.pluck(:name)
       @items_by_status = @project.items.group_by(&:status)
-      @support_user = support_user?
     end
 
     # GET /projects/:id/edit
     def edit
-      @project = PMS::Project.find(params[:id].to_i)
+      @project = PlanMyStuff::Project.find(params[:id].to_i)
     end
 
     # PATCH/PUT /projects/:id
     def update
-      @project = PMS::Project.find(params[:id].to_i)
+      @project = PlanMyStuff::Project.find(params[:id].to_i)
 
       @project.update!(
         title: project_params[:title],
@@ -66,9 +65,10 @@ module PlanMyStuff
 
       flash[:success] = 'Project was successfully updated.'
       redirect_to(plan_my_stuff.project_path(@project.number))
-    rescue PMS::StaleObjectError
+    rescue PlanMyStuff::StaleObjectError => e
+      pms_handle_rescue(e)
       flash.now[:error] = 'Project was modified by someone else. Please review the latest changes and try again.'
-      render(:edit, status: PMS.unprocessable_status)
+      render(:edit, status: PlanMyStuff.unprocessable_status)
     end
 
     private

data/app/controllers/plan_my_stuff/testing_project_items/results_controller.rb

@@ -7,7 +7,7 @@ module PlanMyStuff
     # Pass is submitted directly via button_to with result: "pass".
     # Fail renders a form (new) to capture result_notes before posting to create.
     #
-    class ResultsController < ApplicationController
+    class ResultsController < PlanMyStuff::ApplicationController
       # GET /testing_projects/:testing_project_id/items/:item_id/result/new
       def new
         @project_number = params[:testing_project_id].to_i
@@ -19,21 +19,31 @@ module PlanMyStuff
         project_number = params[:testing_project_id].to_i
         item = find_project_item(project_number)
 
-        if params[:result] == 'pass'
+        case params[:result]
+        when 'pass'
           item.mark_passed!(pms_current_user)
           flash[:success] = 'Item marked as Passed.'
-        else
+        when 'fail'
           item.mark_failed!(pms_current_user, result_notes: params[:result_notes])
           flash[:success] = 'Item marked as Failed.'
+        else
+          raise(ArgumentError, "Invalid result: #{params[:result].inspect}")
         end
 
         redirect_to(plan_my_stuff.testing_project_path(project_number))
-      rescue PMS::ValidationError => e
-        flash.now[:error] = e.message
-        @project_number = params[:testing_project_id].to_i
-        @item_id = params[:item_id]
-        render(:new, status: PMS.unprocessable_status)
-      rescue ArgumentError, PMS::Error, Octokit::Error => e
+      rescue PlanMyStuff::ValidationError => e
+        pms_handle_rescue(e)
+        if params[:result] == 'fail'
+          flash.now[:error] = e.message
+          @project_number = params[:testing_project_id].to_i
+          @item_id = params[:item_id]
+          render(:new, status: PlanMyStuff.unprocessable_status)
+        else
+          flash[:error] = e.message
+          redirect_to(plan_my_stuff.testing_project_path(params[:testing_project_id].to_i))
+        end
+      rescue ArgumentError, PlanMyStuff::Error, Octokit::Error => e
+        pms_handle_rescue(e)
         flash[:error] = e.message
         redirect_to(plan_my_stuff.testing_project_path(params[:testing_project_id].to_i))
       end
@@ -43,9 +53,9 @@ module PlanMyStuff
         # @param project_number [Integer]
         # @return [PlanMyStuff::TestingProjectItem]
         def find_project_item(project_number)
-          project = PMS::TestingProject.find(project_number)
+          project = PlanMyStuff::TestingProject.find(project_number)
           item = project.items.find { |i| i.id == params[:item_id] }
-          raise(PMS::APIError, "Item not found: #{params[:item_id]}") unless item
+          raise(PlanMyStuff::APIError, "Item not found: #{params[:item_id]}") unless item
 
           item
         end

data/app/controllers/plan_my_stuff/testing_project_items_controller.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class TestingProjectItemsController < ApplicationController
+  class TestingProjectItemsController < PlanMyStuff::ApplicationController
     # GET /testing_projects/:testing_project_id/items/new
     def new
-      @project = PMS::TestingProject.find(params[:testing_project_id].to_i)
+      @project = PlanMyStuff::TestingProject.find(params[:testing_project_id].to_i)
+    rescue PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
+      flash[:error] = e.message
+      redirect_to(plan_my_stuff.testing_projects_path)
     end
 
     # POST /testing_projects/:testing_project_id/items
     def create
       project_number = params[:testing_project_id].to_i
-      item = PMS::TestingProjectItem.create!(
+      item = PlanMyStuff::TestingProjectItem.create!(
         item_params[:title],
         draft: true,
         body: item_params[:body],
@@ -24,7 +28,8 @@ module PlanMyStuff
 
       flash[:success] = 'Item added.'
       redirect_to(plan_my_stuff.testing_project_path(project_number))
-    rescue ArgumentError, PMS::Error, Octokit::Error => e
+    rescue ArgumentError, PlanMyStuff::Error, Octokit::Error => e
+      pms_handle_rescue(e)
       flash[:error] = e.message
       redirect_to(plan_my_stuff.testing_project_path(project_number))
     end

data/app/controllers/plan_my_stuff/testing_projects_controller.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module PlanMyStuff
-  class TestingProjectsController < ApplicationController
+  class TestingProjectsController < PlanMyStuff::ApplicationController
     # GET /testing_projects/new
     def new
-      @project = PMS::TestingProject.new
+      @project = PlanMyStuff::TestingProject.new
       @project.metadata.subject_urls = [params[:subject_url]] if params[:subject_url].present?
     end
 
     # POST /testing_projects
     def create
-      @project = PMS::TestingProject.create!(
+      @project = PlanMyStuff::TestingProject.create!(
         title: testing_project_params[:title],
         description: testing_project_params[:description],
         subject_urls: parse_subject_urls(testing_project_params[:subject_urls]),
@@ -21,28 +21,34 @@ module PlanMyStuff
 
       flash[:success] = 'Testing project was successfully created.'
       redirect_to(plan_my_stuff.testing_project_path(@project.number))
-    rescue PMS::ValidationError => e
-      @project = PMS::TestingProject.new(title: testing_project_params[:title])
+    rescue PlanMyStuff::ValidationError => e
+      pms_handle_rescue(e)
+      @project = PlanMyStuff::TestingProject.new(
+        title: testing_project_params[:title],
+        description: testing_project_params[:description],
+      )
+      @project.metadata.subject_urls = parse_subject_urls(testing_project_params[:subject_urls])
+      @project.metadata.due_date = safe_parse_due_date(testing_project_params[:due_date])
+      @project.metadata.deadline_miss_reason = testing_project_params[:deadline_miss_reason]
       flash.now[:error] = e.message
-      render(:new, status: PMS.unprocessable_status)
+      render(:new, status: PlanMyStuff.unprocessable_status)
     end
 
     # GET /testing_projects/:id
     def show
-      @project = PMS::TestingProject.find(params[:id].to_i)
+      @project = PlanMyStuff::TestingProject.find(params[:id].to_i)
       @statuses = @project.statuses.pluck(:name)
       @items_by_status = @project.items.group_by(&:status)
-      @support_user = support_user?
     end
 
     # GET /testing_projects/:id/edit
     def edit
-      @project = PMS::TestingProject.find(params[:id].to_i)
+      @project = PlanMyStuff::TestingProject.find(params[:id].to_i)
     end
 
     # PATCH/PUT /testing_projects/:id
     def update
-      @project = PMS::TestingProject.find(params[:id].to_i)
+      @project = PlanMyStuff::TestingProject.find(params[:id].to_i)
 
       @project.update!(
         title: testing_project_params[:title],
@@ -56,13 +62,15 @@ module PlanMyStuff
 
       flash[:success] = 'Testing project was successfully updated.'
       redirect_to(plan_my_stuff.testing_project_path(@project.number))
-    rescue PMS::StaleObjectError
+    rescue PlanMyStuff::StaleObjectError => e
+      pms_handle_rescue(e)
       flash.now[:error] =
         'Testing project was modified by someone else. Please review the latest changes and try again.'
-      render(:edit, status: PMS.unprocessable_status)
-    rescue PMS::ValidationError => e
+      render(:edit, status: PlanMyStuff.unprocessable_status)
+    rescue PlanMyStuff::ValidationError => e
+      pms_handle_rescue(e)
       flash.now[:error] = e.message
-      render(:edit, status: PMS.unprocessable_status)
+      render(:edit, status: PlanMyStuff.unprocessable_status)
     end
 
     private
@@ -80,6 +88,14 @@ module PlanMyStuff
 
         Date.parse(raw)
       rescue ArgumentError, TypeError
+        raise(PlanMyStuff::ValidationError, 'Due date must be a valid date.')
+      end
+
+      # @param raw [String, nil]
+      # @return [Date, nil]
+      def safe_parse_due_date(raw)
+        parse_due_date(raw)
+      rescue PlanMyStuff::ValidationError
         nil
       end
 

data/app/controllers/plan_my_stuff/webhooks/aws_controller.rb

@@ -5,7 +5,7 @@ module PlanMyStuff
     class AwsController < ActionController::API
       VALID_SNS_MESSAGE_TYPES = %w[Notification SubscriptionConfirmation UnsubscribeConfirmation].freeze
 
-      before_action :verify_signature!
+      before_action :verify_signature
 
       # POST /webhooks/aws
       def create
@@ -14,6 +14,13 @@ module PlanMyStuff
 
         Rails.logger.info("[PlanMyStuff] SNS #{message_type}: #{sns_params.to_unsafe_h.inspect}")
 
+        if message_type == 'SubscriptionConfirmation'
+          confirm_subscription!
+          head(:ok)
+
+          return
+        end
+
         unless message_type == 'Notification'
           head(:ok)
 
@@ -42,14 +49,36 @@ module PlanMyStuff
 
       private
 
+        # Visits the SubscribeURL provided by SNS to confirm the subscription. Without this, SNS leaves the
+        # endpoint in +PendingConfirmation+ and never delivers Notifications.
+        #
+        # @return [void]
+        #
+        def confirm_subscription!
+          subscribe_url = sns_params[:subscribe_url].to_s
+          if subscribe_url.blank?
+            Rails.logger.warn('[PlanMyStuff] SubscriptionConfirmation missing SubscribeURL')
+
+            return
+          end
+
+          uri = URI.parse(subscribe_url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == 'https')
+          response = http.request(Net::HTTP::Get.new(uri.request_uri))
+
+          Rails.logger.info("[PlanMyStuff] Confirmed SNS subscription: HTTP #{response.code}")
+        rescue => e
+          Rails.logger.error("[PlanMyStuff] SNS subscription confirmation failed: #{e.class}: #{e.message}")
+        end
+
         # Validates the SNS message signature.
-        # Checks message type header and topic ARN first (cheap), then
-        # delegates to the configured verifier class for cryptographic
-        # certificate-based verification.
+        # Checks message type header and topic ARN first (cheap), then delegates to the configured verifier class
+        # for cryptographic certificate-based verification.
         #
         # @return [void]
         #
-        def verify_signature!
+        def verify_signature
           message_type = request.headers['x-amz-sns-message-type'].to_s
 
           if VALID_SNS_MESSAGE_TYPES.exclude?(message_type)
@@ -82,9 +111,8 @@ module PlanMyStuff
             end
         end
 
-        # Parses the SNS envelope. Returns empty params if the body is
-        # not valid JSON so signature verification rejects the request
-        # with 401 instead of bubbling a 500.
+        # Parses the SNS envelope. Returns empty params if the body is not valid JSON so signature verification
+        # rejects the request with 401 instead of bubbling a 500.
         #
         # @return [ActionController::Parameters]
         #
@@ -94,8 +122,8 @@ module PlanMyStuff
           @sns_params ||= ActionController::Parameters.new
         end
 
-        # Parses the nested SNS message payload. Returns empty params on
-        # malformed JSON so callers degrade gracefully.
+        # Parses the nested SNS message payload. Returns empty params on malformed JSON so callers degrade
+        # gracefully.
         #
         # @return [ActionController::Parameters]
         #
@@ -106,8 +134,7 @@ module PlanMyStuff
           ActionController::Parameters.new
         end
 
-        # Checks whether any resource ARN in the ECS event matches the
-        # configured service identifier suffix.
+        # Checks whether any resource ARN in the ECS event matches the configured service identifier suffix.
         #
         # @param service_identifier [String, nil]
         #
@@ -119,15 +146,21 @@ module PlanMyStuff
           sns_message_params.fetch(:resources, []).any? { |arn| arn.end_with?(service_identifier) }
         end
 
-        # Finds "Release in Progress" items whose linked issue commit SHA
-        # matches the configured production commit SHA (prefix match),
-        # then completes deployment for each.
+        # Finds "Release in Progress" items whose linked issue commit SHA matches the configured production
+        # commit SHA (prefix match), then completes deployment for each.
         #
         # @return [void]
         #
         def handle_deployment_completed
           sha = PlanMyStuff.configuration.production_commit_sha
-          raise(PlanMyStuff::PipelineError, 'production_commit_sha is not configured') if sha.nil?
+
+          if sha.blank?
+            Rails.logger.error(
+              '[PlanMyStuff] production_commit_sha is not configured - skipping deployment completion',
+            )
+
+            return
+          end
 
           release_in_progress_items.each do |item|
             next if item.draft?
@@ -143,7 +176,7 @@ module PlanMyStuff
         # @return [Array<PlanMyStuff::ProjectItem>]
         #
         def release_in_progress_items
-          project_number = PlanMyStuff::Pipeline.resolve_pipeline_project_number
+          project_number = PlanMyStuff::Pipeline.resolve_pipeline_project_number!
           project = PlanMyStuff::Project.find(project_number)
 
           release_status = PlanMyStuff::Pipeline.resolve_status_name(