canvas_shim 0.1.0

data/app/services/grades_service/commands/zero_out_assignment_grades_rollback.rb

@@ -0,0 +1,38 @@
+module GradesService
+  module Commands
+    class ZeroOutAssignmentGradesRollback
+      def call!(options={})
+        load_audit(options)
+
+        CSV.foreach('/tmp/zero_grader_rollback.csv') do |row|
+          submission_id = row[0]
+          orig_score = row[1]
+          submission = Submission.find(submission_id)
+          user = submission.user
+          grader = GradesService::Account.account_admin
+          submission = Submission.find(submission_id)
+          assignment = submission.assignment
+
+          if orig_score.present? && submission.score == 0 || submission.score.nil?
+            puts "Setting submission #{submission.id} from #{submission.score} to #{orig_score or 'nil'}"
+            begin
+              puts "assignment.grade_student(#{user.id}, score: #{orig_score or 'nil'}, grader: 1)"
+              assignment.grade_student(user, score: orig_score, grader: grader)
+            rescue => e
+              puts "Failed Setting submission #{submission.id} from #{submission.score} to #{orig_score or 'nil'}: #{e}"
+            end
+          end
+        end
+      end
+
+      private
+
+      def load_audit(options)
+        s3 = Aws::S3::Client.new(access_key_id: ENV['S3_ACCESS_KEY_ID'], secret_access_key: ENV['S3_ACCESS_KEY'])
+        File.open('/tmp/zero_grader_rollback.csv', 'w') do |file|
+          s3.get_object({ bucket: ENV['S3_BUCKET_NAME'], key: 'zero_grader/' + options[:log_file] }, target: file)
+        end
+      end
+    end
+  end
+end

data/app/services/pipeline_service.rb

@@ -0,0 +1,27 @@
+# The public api for the PipelineService
+# By default the command will be enqueued.
+#
+# Example: PipelineService.publish(User.first)
+module PipelineService
+  cattr_reader :queue_mode
+  def self.publish(object, api: API::Publish, noun: nil)
+    return if SettingsService.get_settings(object: :school, id: 1)['disable_pipeline']
+    api.new(object, noun: noun).call
+  end
+
+  def self.perform_synchronously?
+    queue_mode == 'synchronous'
+  end
+
+  @@queue_mode = ENV['SYNCHRONOUS_PIPELINE_JOBS'] == 'true' ? 'synchronous' : 'asynchronous'
+  def self.queue_mode=(mode)
+    case mode
+    when 'synchronous'
+      @@queue_mode = 'synchronous'
+    when 'asynchronous'
+      @@queue_mode = 'asynchronous'
+    else
+      raise 'unknown queue mode: ' + mode
+    end
+  end
+end

data/app/services/pipeline_service/account.rb

@@ -0,0 +1,9 @@
+module PipelineService
+  module Account
+    def self.account_admin
+      account = ::Account.default.account_users.find do |account_user|
+        account_user.role.name == 'AccountAdmin'
+      end.try(:user)
+    end
+  end
+end

data/app/services/pipeline_service/api/publish.rb

@@ -0,0 +1,53 @@
+# The API calls Commands
+#
+# Class methods map to Commands
+# ie: PipelineService::API::Publish calls PipelineService::Commands::Publish
+#
+module PipelineService
+  module API
+    class Publish
+      def initialize(object, args={})
+        @object = object
+        @changes = object.try(:changes)
+        @noun = args[:noun]
+        @args = args
+        configure_dependencies
+      end
+
+      def call
+        return if SettingsService.get_settings(object: :school, id: 1)['disable_pipeline']
+        queue.enqueue(self, priority: 1000000)
+      end
+
+      def perform
+        command.call
+      end
+
+      private
+
+      attr_reader :object, :jobs, :command_class, :queue, :noun, :changes
+
+      def configure_dependencies
+        @command_class = @args[:command_class] || Commands::Publish
+        @queue         = @args[:queue] || Delayed::Job
+      end
+
+
+      def subscriptions
+        Events::Subscription.new(
+          event: 'graded_out',
+          responder: Events::Responders::SIS
+        )
+      end
+
+      def command
+        command_class.new(
+          object: object,
+          event_subscriptions: subscriptions,
+          noun: noun,
+          changes: changes
+        )
+      end
+    end
+  end
+end

data/app/services/pipeline_service/commands/publish.rb

@@ -0,0 +1,44 @@
+module PipelineService
+  module Commands
+    # Serialize a canvas object into their API format and
+    # send to the pipeline
+    #
+    # Usage:
+    # Send.new(message: User.last).call
+    class Publish
+      attr_reader :message, :serializer
+
+      def initialize(args)
+        @args       = args
+        @object     = args[:object]
+        @changes    = args[:changes]
+        configure_dependencies
+      end
+
+      def call
+        return if SettingsService.get_settings(object: :school, id: 1)['disable_pipeline']
+        post_to_pipeline
+        publish_events unless changes.nil?
+        self
+      end
+
+      private
+
+      attr_reader :object, :client, :responder, :changes
+
+      def configure_dependencies
+        @client     = @args[:client] || PipelineClient
+      end
+
+      def publish_events
+        Commands::PublishEvents.new(@args).call
+      end
+
+      def post_to_pipeline
+        client.new(
+          @args.merge(object: object)
+        ).call
+      end
+    end
+  end
+end

data/app/services/pipeline_service/commands/publish_events.rb

@@ -0,0 +1,17 @@
+module PipelineService
+  module Commands
+    class PublishEvents
+      def initialize(args={})
+        @args = args
+      end
+
+      def call
+        self.class.emitter.new(@args).call
+      end
+
+      def self.emitter
+        Events::Emitter
+      end
+    end
+  end
+end

data/app/services/pipeline_service/endpoints/pipeline.rb

@@ -0,0 +1,62 @@
+module PipelineService
+  module Endpoints
+    class Pipeline
+      def initialize(args={})
+        @args = args
+        configure_dependencies
+        raise 'Missing config' if missing_config?
+      end
+
+      def call
+        return if SettingsService.get_settings(object: :school, id: 1)['disable_pipeline']
+        if PipelineService.perform_synchronously?
+          perform
+        else
+          Delayed::Job.enqueue(self, priority: 1000000)
+        end
+        self
+      end
+
+      def perform
+        configure_publisher
+        build_payload
+        post
+      end
+
+      private
+
+      attr_reader :endpoint, :username, :password, :publisher, :message_builder, :payload
+
+      def build_payload
+        @payload = message_builder.new(@args).call
+      end
+
+      def configure_dependencies
+        @message_builder = @args[:message_builder] || MessageBuilder
+        @publisher   = @args[:publisher] || PipelinePublisher
+        @endpoint    = ENV['PIPELINE_ENDPOINT']
+        @username    = ENV['PIPELINE_USER_NAME']
+        @password    = ENV['PIPELINE_PASSWORD']
+      end
+
+      def missing_config?
+        [endpoint, username, password].any?(&:nil?)
+      end
+
+      def configure_publisher
+        publisher.configure do |config|
+          config.host     = endpoint
+          config.username = username
+          config.password = password
+          if endpoint.slice(0,7) == 'http://'
+            config.scheme = 'http'
+          end
+        end
+      end
+
+      def post
+        PipelineService::HTTPClient.post(payload)
+      end
+    end
+  end
+end

data/app/services/pipeline_service/endpoints/pipeline/message_builder.rb

@@ -0,0 +1,75 @@
+module PipelineService
+  module Endpoints
+    class Pipeline
+      class MessageBuilder
+        SOURCE = 'canvas'
+
+        def initialize(args)
+          @object        = args[:object]
+          @serializer    = args[:serializer]
+          @args          = args
+          configure_dependencies
+        end
+
+        def call
+          fetch_serializer
+          serialize
+          result = build
+          log
+          result
+        end
+
+        private
+
+        attr_reader :message_class, :object, :fetcher, :serializer, :canvas_domain, :logger, :serialized_object
+
+        def serialize
+          @serialized_object = serializer.new(object: object).call
+        end
+
+        def log
+          Logger.new(source: 'pipeline', message: payload).call
+        end
+
+        def payload
+          {
+            noun: noun,
+            meta: {
+              source: SOURCE,
+              domain_name: canvas_domain,
+              api_version: 1,
+              status: object.try(:state)
+            },
+            identifiers: { id: id },
+            data: serialized_object
+          }
+        end
+
+        def configure_dependencies
+          @message_class = @args[:message_class] || PipelinePublisher::Message
+          @fetcher       = @args[:fetcher] || Serializers::Fetcher
+          @logger        = @args[:logger] || PipelineService::Logger
+          @canvas_domain = ENV['CANVAS_DOMAIN']
+        end
+
+        def fetch_serializer
+          return if @serializer
+          @serializer = fetcher.fetch(object: object)
+        end
+
+        def build
+          message_class.new(payload.to_hash)
+        end
+
+        def noun
+          object.class.to_s.underscore
+        end
+
+        def id
+          return object.id unless object.is_a?(Hash)
+          object[:id]
+        end
+      end
+    end
+  end
+end

data/app/services/pipeline_service/events/emitter.rb

@@ -0,0 +1,56 @@
+module PipelineService
+  module Events
+    class Emitter
+      def initialize(args={})
+        @object = args[:object]
+        @args = args
+        @responder  = @args[:responder] || Events::Responders::SIS
+        @event = Events::GradedOutEvent
+      end
+
+      def call
+        return unless object.is_a?(Enrollment)
+        fetch_serializer
+        build_message
+        build_responder
+        build_subscriptions
+        emit
+      end
+
+      private
+
+      attr_reader :subscriptions, :object, :responder, :message, :serializer, :event
+
+      def build_subscriptions
+        @subscriptions = [
+          Events::Subscription.new(
+            event: :graded_out,
+            responder: responder
+          )
+        ]
+      end
+
+      def build_responder
+        @responder = responder.new(
+          object: object,
+          message: message
+        )
+      end
+
+      def fetch_serializer
+        @serializer = Serializers::CanvasAPIEnrollment
+      end
+
+      def build_message
+        @message = serializer.new(object: object).call
+      end
+
+      def emit
+        subscriptions.each do |subscription|
+          next if subscription.event != :graded_out
+          event.new(@args.merge(subscription: subscription)).emit
+        end
+      end
+    end
+  end
+end

data/app/services/pipeline_service/events/graded_out_event.rb

@@ -0,0 +1,31 @@
+module PipelineService
+  module Events
+    class GradedOutEvent
+      def initialize(args)
+        @args = args
+        @subscription = args[:subscription]
+        @object    = args[:object]
+        @changes   = args[:changes]
+      end
+
+      def emit
+        return unless should_trigger?
+        subscription.responder.call
+      end
+
+      private
+
+      attr_accessor :subscription, :object, :changes
+
+      def should_trigger?
+        return unless object.is_a?(::Enrollment)
+        recently_completed?
+      end
+
+      def recently_completed?
+        return false unless changes['workflow_state']
+        changes['workflow_state'][1] == 'completed'
+      end
+    end
+  end
+end

data/app/services/pipeline_service/events/http_client.rb

@@ -0,0 +1,14 @@
+module PipelineService
+  module Events
+    class HTTPClient
+      include Singleton
+      def self.post(endpoint, args={})
+        instance.post(endpoint, args)
+      end
+
+      def post(endpoint, args)
+        HTTParty.post(endpoint, args)
+      end
+    end
+  end
+end

data/app/services/pipeline_service/events/responders/sis.rb

@@ -0,0 +1,66 @@
+module PipelineService
+  module Events
+    module Responders
+      class SIS
+        HEADERS = { 'Content-Type' => 'application/json' }
+
+        def initialize(object:, message:, args: {})
+          @message = message
+          @args = args
+          configure_dependencies
+        end
+
+        def call
+          raise 'Missing config' if missing_config?
+
+          if PipelineService.perform_synchronously?
+             perform
+          else
+            queue.enqueue(self)
+          end
+        end
+
+        def perform
+          post
+          log
+        end
+
+        private
+
+        attr_reader :message, :api_key, :endpoint, :args, :queue
+
+        def configure_dependencies
+          @api_key  = ENV['SIS_ENROLLMENT_UPDATE_API_KEY']
+          @endpoint = ENV['SIS_ENROLLMENT_UPDATE_ENDPOINT']
+          @queue    = args[:queue] || Delayed::Job
+        end
+
+        def missing_config?
+          [@api_key, @endpoint].any?(&:nil?)
+        end
+
+        def log
+          PipelineService::Logger.new(
+              source: 'pipeline_event::graded_out',
+              message: message,
+              enpdoint: build_endpoint
+          ).call
+        end
+
+        def build_endpoint
+          endpoint + '?apiKey=' + api_key
+        end
+
+        def post
+          return unless message
+
+          PipelineService::Events::HTTPClient.post(
+            build_endpoint,
+            body:    message.to_json,
+            headers: HEADERS
+          )
+        end
+      end
+    end
+  end
+end