sls_adf 0.0.1

data/lib/sls_adf/template/fragment.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SlsAdf
+  module Template
+    module Fragment
+      User = SlsAdf.client.parse <<~'GRAPHQL'
+        fragment Fields on User {
+          id
+          name
+          role
+        }
+
+        fragment StudentFields on User {
+          id
+          name
+          classSerialNo
+          level
+        }
+      GRAPHQL
+
+      SubjectGroup = SlsAdf.client.parse <<~'GRAPHQL'
+        fragment Fields on SubjectGroup {
+          uuid
+          code
+          subject
+        }
+      GRAPHQL
+
+      Assignment = SlsAdf.client.parse <<~'GRAPHQL'
+        fragment Fields on Assignment {
+          uuid
+          title
+          start
+          end
+        }
+      GRAPHQL
+
+      Task = SlsAdf.client.parse <<~'GRAPHQL'
+        fragment Fields on Task {
+          uuid
+          title
+          start
+          end
+          subject
+          status
+        }
+      GRAPHQL
+
+      Notification = SlsAdf.client.parse <<~'GRAPHQL'
+        fragment Fields on Notification {
+          message
+          scope
+          scopeId
+          eventType
+          eventTypeId
+          recipient
+        }
+      GRAPHQL
+
+      Event = SlsAdf.client.parse <<~'GRAPHQL'
+        fragment Fields on Event {
+          type
+          typeId
+        }
+      GRAPHQL
+    end
+  end
+end

data/lib/sls_adf/template/mutation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'sls_adf/template/fragment'
+
+module SlsAdf
+  module Template
+    module Mutation
+      module Assignment
+        Create = SlsAdf.client.parse <<~'GRAPHQL'
+          mutation($assignment_input: AssignmentInput!) {
+            createAssignment(input: $assignment_input) {
+              ...SlsAdf::Template::Fragment::Assignment::Fields
+            }
+          }
+        GRAPHQL
+
+        Update = SlsAdf.client.parse <<~'GRAPHQL'
+          mutation($uuid: UUID!, $assignment_input: AssignmentInput!) {
+            updateAssignment(uuid: $uuid, input: $assignment_input) {
+              ...SlsAdf::Template::Fragment::Assignment::Fields
+            }
+          }
+        GRAPHQL
+
+        Delete = SlsAdf.client.parse <<~'GRAPHQL'
+          mutation($uuid: UUID!) {
+            deleteAssignment(uuid: $uuid)
+          }
+        GRAPHQL
+      end
+
+      module Task
+        Update = SlsAdf.client.parse <<~'GRAPHQL'
+          mutation($uuid: UUID!, $task_status: TaskStatus!) {
+            updateTask(uuid: $uuid, status: $task_status) {
+              ...SlsAdf::Template::Fragment::Task::Fields
+            }
+          }
+        GRAPHQL
+      end
+
+      module Notification
+        Add = SlsAdf.client.parse <<~'GRAPHQL'
+          mutation($notification_input: NotificationInput!) {
+            createNotification(input: $notification_input) {
+              ...SlsAdf::Template::Fragment::Notification::Fields
+            }
+          }
+        GRAPHQL
+      end
+    end
+  end
+end

data/lib/sls_adf/template/query.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'sls_adf/template/fragment'
+
+module SlsAdf
+  module Template
+    module Query
+      User = SlsAdf.client.parse <<~'GRAPHQL'
+        query($id: ID!, $first: Int = 2) {
+          user(id: $id) {
+            ...SlsAdf::Template::Fragment::User::Fields
+            subjectGroups(first: $first) {
+              ...SlsAdf::Template::Fragment::SubjectGroup::Fields
+            }
+          }
+        }
+      GRAPHQL
+
+      SubjectGroup = SlsAdf.client.parse <<~'GRAPHQL'
+        query($uuid: UUID!, $first_student: Int = 2, $first_teacher: Int = 2) {
+          subjectGroup(uuid: $uuid){
+            ...SlsAdf::Template::Fragment::SubjectGroup::Fields
+            assignments
+            students(first: $first_student, sortField:CLASS_SERIAL_NO) {
+              ...SlsAdf::Template::Fragment::User::StudentFields
+            }
+            teachers(first: $first_teacher) {
+              ...SlsAdf::Template::Fragment::User::Fields
+            }
+          }
+        }
+      GRAPHQL
+
+      Assignment = SlsAdf.client.parse <<~'GRAPHQL'
+        query($uuid: UUID!, $first: Int = 2) {
+          assignment(uuid: $uuid){
+            ...SlsAdf::Template::Fragment::Assignment::Fields
+            createdBy {
+              ...SlsAdf::Template::Fragment::User::Fields
+            }
+            modifiedBy {
+              ...SlsAdf::Template::Fragment::User::Fields
+            }
+            tasks(first: $first) {
+              ...SlsAdf::Template::Fragment::Task::Fields
+            }
+          }
+        }
+      GRAPHQL
+
+      Task = SlsAdf.client.parse <<~'GRAPHQL'
+        query($uuid: UUID!) {
+          task(uuid: $uuid) {
+            ...SlsAdf::Template::Fragment::Task::Fields
+            createdBy {
+              ...SlsAdf::Template::Fragment::User::Fields
+            }
+            assignee {
+              ...SlsAdf::Template::Fragment::User::StudentFields
+            }
+          }
+        }
+      GRAPHQL
+
+      Context = SlsAdf.client.parse <<~'GRAPHQL'
+        query($uuid: UUID!, $first: Int = 15) {
+          context(uuid: $uuid) {
+            event {
+              ...SlsAdf::Template::Fragment::Event::Fields
+            }
+            user {
+              ...SlsAdf::Template::Fragment::User::Fields
+              subjectGroups(first: $first) {
+                ...SlsAdf::Template::Fragment::SubjectGroup::Fields
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
+  end
+end

data/lib/sls_adf/template.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SlsAdf
+  # Module used to declare Query, Mutation and Fragments to be used.
+  module Template; end
+end

data/lib/sls_adf/util/adapter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'typhoeus'
+require 'json'
+
+module SlsAdf
+  module Util
+    # Custom adapter written for github/graphql-client, built to achieve 2 things:
+    #   1. Expose HTTP status of response through the #execute method.
+    #   2. Automatically GETs token from token endpoint if call is unauthorised.
+    #
+    # Adapter can be customised with special logic when calling SLS ADF APIs.
+    class Adapter
+      # GraphQL execution adapter used with the graphql-client library.
+      # The Adapter must respond to the execute method with the following method
+      # signature.
+      #
+      # Link: https://github.com/github/graphql-client/blob/master/guides/remote-queries.md
+      #
+      # @param [GraphQL::Language::Nodes::Document] document The query itself.
+      # @param [String] operation_name The name of the operation
+      # @param [Hash] variables A hash of the query variables.
+      # @param [Hash] context Arbitary hash of values that can be accessed
+      # @return [Hash] Parsed API response. Sample shape:
+      #   If successful: { 'data' => ... }
+      #   If unsuccessful: { 'errors' => ... }
+      def execute(document:, operation_name: nil, variables: {}, context: {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        body = {}
+        # Convert document into query parameters
+        body['query'] = document.to_query_string
+        body['operationName'] = operation_name if operation_name
+        body['variables'] = variables if variables.any?
+
+        headers = context.merge(authorization_header(token.token))
+        response = execute_call(headers: headers, body: body)
+
+        if response.code == 401 # Unauthorized
+          new_headers = context.merge(authorization_header(token.refresh_token))
+          response = execute_call(headers: new_headers, body: body)
+        end
+
+        if response.code.zero?
+          { errors: [{ message: 'Unable to establish a connection' }] }
+        else
+          JSON.parse(response.body).merge(http_status: response.code)
+        end
+      rescue JSON::ParserError
+        { errors: [{ message: 'JSON parsing failed' }] }
+      end
+
+      private
+
+      # Returns a hash for the autorizatiom key and value.
+      #
+      # @param [String] token Actual token to be inserted.
+      # @return [Hash] Authorization header key and values
+      def authorization_header(token)
+        { Authorization: 'Bearer ' + token }
+      end
+
+      # Executes a HTTP POST call to the specified GraphQL URL.
+      #
+      # @param [Hash] headers Additional headers to be included, other than
+      #   those specified in +SlsAdf::Util::COMMON_HEADERS+.
+      # @param [Hash] body The body to be sent in the POST call.
+      # @return [Typhoeus::Response] The response object.
+      def execute_call(headers: {}, body: {})
+        headers = COMMON_HEADERS.merge(headers)
+        Typhoeus.post(graphql_url, headers: headers, body: JSON.dump(body))
+      end
+
+      # Reference to the Token object. Can be over-written with a custom
+      # implementation of the Token object, offering +Token.token+ and
+      # +Token.refresh_token+ methods.
+      #
+      # @return [SlsAdf::Util::Token] The reference to the default token used.
+      def token
+        @token ||= SlsAdf::Util::Token
+      end
+
+      # Reference to the GraphQL URL, which can be over-written.
+      #
+      # @return [String] The GraphQL URL
+      def graphql_url
+        @graphql_url ||= SlsAdf.configuration.graphql_url
+      end
+    end
+  end
+end

data/lib/sls_adf/util/token.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'typhoeus'
+require 'json'
+
+module SlsAdf
+  module Util
+    # Token used to store the ADF API's client credentials token.
+    # This is used by +SlsAdf::Util::Adapter+ to make API calls to ADF.
+    #
+    # The token will be an empty string if:
+    #   i) The get_token call is unsuccessful (HTTP status code not 200).
+    #   ii) The credentials are invalid.
+    class Token
+      class << self
+        # Returns the token. If no token exists, an API call is made to get the token.
+        #
+        # @return [String] The ADF API token.
+        def token
+          @token ||= get_token
+        end
+
+        # Forces an API call to get the token.
+        #
+        # @return [String] The ADF API token.
+        def refresh_token
+          @token = get_token
+        end
+
+        private
+
+        # Returns the token after making an API call to get the token.
+        # An empty string is returned if:
+        #   i) The call is unsuccessful (HTTP status code not 200).
+        #   ii) The credentials are invalid.
+        #
+        # @return [String] The responded token, or an empty string.
+        def get_token # rubocop:disable Style/AccessorMethodName
+          response = get_token_call
+          response.code == 200 ? parse_response(response.body) : ''
+        end
+
+        # Returns the response for a POST token API call.
+        #
+        # @return [Typhoeus::Response] The response object.
+        def get_token_call # rubocop:disable Style/AccessorMethodName
+          Typhoeus.post(get_token_url, headers: COMMON_HEADERS, body: body)
+        end
+
+        # Attempts to parse the string in Json to obtain the token.
+        #
+        # @param [String] body String to be parsed
+        # @return [String] The parsed token, or blank if an error occurs.
+        def parse_response(body)
+          token = JSON.parse(body)['data']['token']
+          token ? token : ''
+        rescue JSON::ParserError
+          ''
+        end
+
+        def body
+          JSON.dump(
+            clientId: client_id,
+            clientSecret: client_secret,
+            grantType: 'client_credentials',
+            scope: 'all'
+          )
+        end
+
+        def client_id
+          SlsAdf.configuration.client_id
+        end
+
+        def client_secret
+          SlsAdf.configuration.client_secret
+        end
+
+        def get_token_url # rubocop:disable Style/AccessorMethodName
+          SlsAdf.configuration.get_token_url
+        end
+      end
+    end
+  end
+end

data/lib/sls_adf/util.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'sls_adf/util/token'
+require 'sls_adf/util/adapter'
+
+module SlsAdf
+  module Util
+    COMMON_HEADERS = {
+      'Accept' => 'application/json',
+      'Content-Type' => 'application/json'
+    }.freeze
+  end
+end

data/lib/sls_adf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SlsAdf
+  VERSION = '0.0.1'
+end

data/lib/sls_adf.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'sls_adf/version'
+require 'sls_adf/configuration'
+require 'sls_adf/util'
+require 'sls_adf/base'
+require 'graphql/client'
+
+module SlsAdf #:nodoc:
+  def self.adapter
+    @adapter ||= SlsAdf::Util::Adapter.new
+  end
+
+  def self.schema
+    @schema ||= begin
+      schema_path = File.join(File.dirname(__FILE__), "sls_adf/schema/schema.json")
+      GraphQL::Client.load_schema(schema_path)
+    end
+  end
+
+  def self.client
+    @client ||= GraphQL::Client.new(schema: schema, execute: adapter)
+  end
+end
+
+require 'sls_adf/query'
+require 'sls_adf/mutation'

data/sls_adf.gemspec

@@ -0,0 +1,44 @@
+#sls_adf: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sls_adf/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'sls_adf'
+  s.version       = SlsAdf::VERSION
+  s.authors       = ['Toh Weiqing']
+  s.email         = ['hello@estl.moe']
+
+  s.summary       = 'Ruby client library for SLS (in progress).'
+  s.description   = "Ruby client library for SLS's Application Development Framework (in progress)."
+  s.homepage      = 'https://github.com/moexmen/sls-adf'
+  s.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if s.respond_to?(:metadata)
+    s.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  s.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|s|features)/})
+  end
+  s.bindir        = 'exe'
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 2.4.0'
+
+  s.add_dependency 'graphql-client', '~>0.12'
+  s.add_dependency 'typhoeus', '~>1.3'
+
+  s.add_development_dependency 'bundler', '~> 1.16'
+  s.add_development_dependency 'dotenv', '~> 2.2'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rdoc'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'webmock'
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,4 @@
+if ENV['CI']
+  require 'simplecov'
+  SimpleCov.start
+end

data/spec/lib/base_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe SlsAdf::Base do
+  # Dummy class for testing SlsAdf::Base
+  class DummyBase < SlsAdf::Base
+    class << self
+      def test_execute_query(template, variables = {})
+        execute_query(template, variables)
+      end
+    end
+  end
+
+  module SlsAdf
+    # Set SlsAdf.client to point to configuration url, and load schema from there
+    def self.set_configration_sls_adf_client!
+      def self.client
+        @new_client ||= begin
+          new_schema = GraphQL::Client.load_schema(adapter)
+          GraphQL::Client.new(schema: new_schema, execute: adapter)
+        end
+      end
+    end
+
+    # Resets SlsAdf.client to the default
+    def self.reset_sls_adf_client!
+      def self.client
+        @client ||= GraphQL::Client.new(schema: schema, execute: adapter)
+      end
+    end
+  end
+
+  describe '.execute_query' do
+    subject { DummyBase.test_execute_query(template, variables) }
+    let(:character_variables) { { 'id' => '1001' } }
+    let(:starship_variables) { { 'id' => '3000' } }
+    before { SlsAdf.set_configration_sls_adf_client! }
+    after { SlsAdf.reset_sls_adf_client! }
+
+    it 'returns the correct response' do
+      WebMock.allow_net_connect!
+
+      GetCharacter = SlsAdf.client.parse <<~'GRAPHQL'
+        query ($id: ID!) {
+          character(id: $id) {
+            name
+          }
+        }
+      GRAPHQL
+
+      GetStarship = SlsAdf.client.parse <<~'GRAPHQL'
+        query($id: ID!) {
+          starship(id: $id) {
+            name
+            length
+          }
+        }
+      GRAPHQL
+
+      character_response = DummyBase.test_execute_query(GetCharacter, character_variables)
+      expect(character_response.data.to_h).to include('character' => hash_including('name' => 'Darth Vader'))
+
+      starship_response = DummyBase.test_execute_query(GetStarship, starship_variables)
+      expect(starship_response.data.to_h).to eq('starship' => { 'name' => 'Millenium Falcon', 'length' => 34.37 })
+
+      WebMock.disable_net_connect!
+    end
+  end
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe SlsAdf::Configuration do
+  subject { SlsAdf.configuration }
+
+  it 'has a configuration object' do
+    expect(subject).not_to be nil
+  end
+
+  describe 'sls_adf_helper file' do
+    it 'initialises the paramters' do
+      expect(subject.graphql_url).not_to be_nil
+      expect(subject.get_token_url).not_to be_nil
+      expect(subject.client_id).not_to be_nil
+      expect(subject.client_secret).not_to be_nil
+    end
+  end
+
+  describe 'when editing parameters' do
+    let(:new_graphql_url) { 'new_url.com' }
+    let(:new_token_url) { 'new_url.com/token' }
+    let(:new_client_id) { 'new_client_id' }
+    let(:new_client_secret) { 'new_client_secret' }
+
+    before do
+      SlsAdf.configure do |config|
+        config.graphql_url = new_graphql_url
+        config.get_token_url = new_token_url
+        config.client_id = new_client_id
+        config.client_secret = new_client_secret
+      end
+    end
+    after { SlsAdf.initialise_sls_adf_gem! }
+
+    it 'changes the parameters when accessed again' do
+      expect(subject.graphql_url).to eq new_graphql_url
+      expect(subject.get_token_url).to eq new_token_url
+      expect(subject.client_id).to eq new_client_id
+      expect(subject.client_secret).to eq new_client_secret
+    end
+  end
+end

data/spec/lib/mutation_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe SlsAdf::Mutation do
+  let!(:stub) do
+    stub_request(:post, SlsAdf.configuration.graphql_url).
+      to_return(status: 200, body: JSON.dump('data' => response_hash))
+  end
+  let(:uuid) { SecureRandom.uuid }
+
+  describe '.create_assignment' do
+    let(:input) do
+      {
+        'title' => 'Foo',
+        'start' => Time.now.iso8601,
+        'end' => (Time.now + 10_000).iso8601,
+        'createBy' => 'USERID-1',
+        'type' => 'QUIZ',
+        'subjectGroupUuid' => SecureRandom.uuid,
+        'assignees' => ['USERID-2', 'USERID-3']
+      }
+    end
+    let(:response_hash) { { 'subjectGroup' => {} } }
+    subject { SlsAdf::Mutation.create_assignment(input) }
+
+    it 'makes a http request' do
+      subject
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe '.update_assignment' do
+    let(:input) { { 'title' => 'Bar' } }
+    let(:response_hash) { { 'subjectGroup' => {} } }
+    subject { SlsAdf::Mutation.update_assignment(uuid, input) }
+
+    it 'makes a http request' do
+      subject
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe '.delete_assignment' do
+    let(:response_hash) { { 'uuid' => {} } }
+    subject { SlsAdf::Mutation.delete_assignment(uuid) }
+
+    it 'makes a http request' do
+      subject
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe '.update_task' do
+    let(:uuid) { SecureRandom.uuid }
+    let(:status) { 'COMPLETED' }
+    let(:response_hash) { { 'task' => {} } }
+    subject { SlsAdf::Mutation.update_task(uuid, status) }
+
+    it 'makes a http request' do
+      subject
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe '.create_notification' do
+    let(:input) do
+      {
+        'message' => 'Test notification',
+        'scope' => 'SUBJECT_GROUP',
+        'scopeId' => SecureRandom.uuid,
+        'eventType' => 'LAUNCH_APP',
+        'eventTypeId' => SecureRandom.uuid,
+        'receipient' => ['USERID-1', 'USERID-2']
+      }
+    end
+    let(:response_hash) { { 'notification' => {} } }
+    subject { SlsAdf::Mutation.create_notification(input) }
+
+    it 'makes a http request' do
+      subject
+      expect(stub).to have_been_requested
+    end
+  end
+end