bima-shark-sdk 2.3.0

data/lib/shark/mailing_service/mailers/base_mailer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Shark
+  module MailingService
+    module Mailers
+      class BaseMailer
+        class << self
+          attr_writer :layout, :template_root
+
+          def layout
+            @layout || MailingService.config.default_layout
+          end
+
+          def method_missing(method, *args, &block)
+            return super unless respond_to?(method)
+
+            instance = new(
+              layout: layout,
+              template_name: method.to_s,
+              template_path: File.join(template_root.to_s, name.underscore)
+            )
+            instance.send(method, *args)
+            instance
+          end
+
+          def template_root
+            @template_root || MailingService.config.default_template_root
+          end
+
+          protected
+
+          def respond_to_missing?(method, include_private = false)
+            known_methods = if include_private
+                              instance_methods(false)
+                            else
+                              public_instance_methods(false)
+                            end
+            known_methods.include?(method)
+          end
+        end
+
+        attr_reader :layout, :template_name, :template_path
+
+        def initialize(layout:, template_path:, template_name:)
+          @layout = layout
+          @template_name = template_name
+          @template_path = template_path
+        end
+
+        def deliver
+          @mail.save
+        end
+        alias deliver_now deliver
+
+        protected
+
+        def body(format, locals = {})
+          renderer.render(template_name, format, locals)
+        end
+
+        def attribute_with_default(attributes, attribute)
+          return attributes[attribute] if attributes.key?(attribute)
+
+          I18n.t!("#{self.class.name.underscore}.#{template_name}.#{attribute}")
+        rescue StandardError
+          nil
+        end
+
+        def mail(attributes)
+          locals = attributes[:locals] || {}
+          mail_attributes = {
+            layout: layout,
+            reply_to: attributes[:reply_to],
+            recipient: attributes[:to],
+            subject: attribute_with_default(attributes, :subject),
+            header: attribute_with_default(attributes, :header),
+            sub_header: attribute_with_default(attributes, :sub_header),
+            html_body: body(:html, locals),
+            text_body: body(:text, locals),
+            attachments: attributes[:attachments] || {}
+          }
+          %i[from header_image reply_to unsubscribe_url].each do |key|
+            value = attributes[key]
+            mail_attributes[key] = value if value.present?
+          end
+
+          @mail = Shark::MailingService::Mail.new(mail_attributes)
+        end
+
+        def renderer
+          @renderer ||= Renderers::ErbRenderer.new(template_path)
+        end
+      end
+    end
+  end
+end

data/lib/shark/mailing_service/renderers/context.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Shark
+  module MailingService
+    module Renderers
+      class Context
+        extend Forwardable
+
+        attr_writer :format
+
+        def_delegator :I18n, :t
+
+        def initialize(renderer, locals = {})
+          @locals = locals.symbolize_keys
+          @renderer = renderer
+        end
+
+        def binding
+          super
+        end
+
+        def render(template, locals = {})
+          @renderer.render(template, @format, locals)
+        end
+
+        protected
+
+        def method_missing(name, *args, &block)
+          return super unless respond_to?(name)
+
+          @locals[name]
+        end
+
+        def respond_to_missing?(name, _include_all)
+          @locals.keys.include?(name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/shark/mailing_service/renderers/erb_renderer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Shark
+  module MailingService
+    module Renderers
+      class ErbRenderer
+        attr_reader :template_folder
+
+        def initialize(template_folder)
+          @template_folder = template_folder
+        end
+
+        def render(template, format, locals = {})
+          template = load_template(template, format)
+          context = build_context(format, locals)
+          ::ERB.new(template).result(context.binding)
+        end
+
+        protected
+
+        def build_context(format, locals)
+          context_class = Class.new(Context) do
+            if MailingService.config.context_helpers.present?
+              MailingService.config.context_helpers.each do |helper|
+                include helper
+              end
+            end
+          end
+
+          context = context_class.new(self, locals)
+          context.format = format
+
+          context
+        end
+
+        def load_template(template, format, language = 'de')
+          filename = "#{template}.#{language}.#{format}.erb"
+          path = ::File.join(template_folder, filename)
+          ::File.read(path)
+        end
+      end
+    end
+  end
+end

data/lib/shark/mailing_service.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'shark/mailing_service/base'
+require 'shark/mailing_service/mail'
+
+module Shark
+  module MailingService
+    class << self
+      def use_shark_mailer
+        require 'shark/mailing_service/configuration'
+        require 'shark/mailing_service/renderers/context'
+        require 'shark/mailing_service/renderers/erb_renderer'
+        require 'shark/mailing_service/mailers/base_mailer'
+
+        yield(config)
+      end
+
+      def config
+        @config ||= Configuration.new
+      end
+    end
+  end
+end

data/lib/shark/membership.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Shark
+  class Membership < Base
+    extend ContactService::Resource
+
+    belongs_to :group
+
+    def self.exists?(group_id:, contact_id:)
+      where(group_id: group_id, contact_id: contact_id).first
+      true
+    rescue Shark::ResourceNotFound
+      false
+    end
+  end
+end

data/lib/shark/middleware/compose_request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shark
+  module Middleware
+    class ComposeRequest < Faraday::Middleware
+      HTTP_METHODS_WITH_BODY = %i[post patch put].freeze
+      CONTENT_TYPE = 'Content-Type'
+      JSON_MIME_TYPE = 'application/json'
+      JSON_MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+
+      def call(env)
+        compose_request_body(env) if request_with_body?(env)
+
+        @app.call(env)
+      end
+
+      def request_with_body?(env)
+        HTTP_METHODS_WITH_BODY.include?(env[:method])
+      end
+
+      def compose_request_body(env)
+        type = request_type(env)
+        params = env[:body] || {}
+
+        params = if JSON_MIME_TYPE_REGEX =~ type
+                   ::JSON.dump(params)
+                 else
+                   params.to_param
+                 end
+
+        env[:body] = params
+      end
+
+      def request_type(env)
+        type = env[:request_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end

data/lib/shark/middleware/status.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Shark
+  module Middleware
+    class Status < Faraday::Middleware
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          handle_status(env[:status], env)
+
+          if env[:body].is_a?(Hash)
+            status = env[:body].fetch('meta', {}).fetch('status', 200).to_i
+            handle_status(status, env)
+          end
+        end
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError
+        raise ConnectionError, environment
+      end
+
+      private
+
+      def handle_status(status, environment)
+        return if (200..399).cover?(status)
+
+        case status
+        when 401 then raise NotAuthorized.new(status, environment)
+        when 403 then raise AccessDenied.new(status, environment)
+        when 404 then raise ResourceNotFound.new(status, environment)
+        when 409 then raise ResourceConflict.new(status, environment)
+        when 422 then raise UnprocessableEntity.new(status, environment)
+        when 500..599 then raise ServerError.new(status, environment)
+        else raise UnexpectedStatus.new(status, environment)
+        end
+      end
+    end
+  end
+end

data/lib/shark/notification.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shark
+  class Notification < Base
+    extend NotificationService::Resource
+
+    custom_endpoint :bulk_creation, on: :collection, request_method: :post
+    custom_endpoint :read_all, on: :collection, request_method: :patch
+
+    def self.create_multiple(attributes)
+      data = {
+        data: {
+          type: 'notifications',
+          attributes: attributes
+        }
+      }
+
+      bulk_creation(data)
+    end
+  end
+end

data/lib/shark/package.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Shark
+  class Package < Base
+    extend AssetService::Resource
+  end
+end

data/lib/shark/permission.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Shark
+  class Permission < Base
+    extend ContactService::Resource
+  end
+end

data/lib/shark/rails.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Shark
+  if Object.const_defined?(:Rails) && Rails.const_defined?(:Railtie)
+    class Railtie < Rails::Railtie
+      initializer 'bima_shark_sdk.initialize' do |_|
+        Shark.configure do |config|
+          config.logger = ::Rails.logger
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_asset_service/object_cache.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Shark
+  module RSpec
+    module FakeAssetService
+      class ObjectCache
+        include Singleton
+
+        def initialize
+          @objects = {}
+          @blobs = {}
+        end
+
+        def host
+          Shark.configuration.asset_service.site
+        end
+
+        def self.clear
+          instance.clear
+        end
+
+        def add(payload_data)
+          id = payload_data.delete('id') || SecureRandom.uuid
+          base_uri = "#{host}/assets"
+          public_id = PublicId.encode_id(id)
+
+          @objects[id] = {
+            'id' => id,
+            'attributes' => payload_data,
+            'links' => {
+              'download' => "#{base_uri}/public/#{public_id}",
+              'upload' => "#{base_uri}/#{id}/upload",
+              'show' => "#{base_uri}/#{id}",
+              'self' => "#{base_uri}/#{id}"
+            }
+          }
+        end
+
+        def add_blob(id, blob)
+          @blobs[id] = blob
+        end
+
+        def clear
+          @objects = {}
+        end
+
+        def find(id)
+          @objects[id]
+        end
+
+        def find_blob(id)
+          @blobs[id]
+        end
+
+        def remove(id)
+          @objects.delete(id)
+        end
+
+        def remove_blob(id)
+          @blobs.delete(id)
+        end
+
+        def objects
+          @objects.values
+        end
+
+        def objects=(new_objects)
+          @objects = new_objects.map do |new_object|
+            object_id = new_object['id']
+            [object_id, new_object]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_asset_service/public_id.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shark
+  module RSpec
+    module FakeAssetService
+      module PublicId
+        module_function
+
+        def decode_public_id(public_id)
+          Base64.urlsafe_decode64(public_id)
+        rescue ArgumentError
+          nil
+        end
+
+        def encode_id(id)
+          Base64.urlsafe_encode64(id)
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_asset_service/request.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+module Shark
+  module RSpec
+    module FakeAssetService
+      class Request
+        include Singleton
+
+        def self.setup
+          instance = self.instance
+          instance.stub_requests
+        end
+
+        def host
+          Shark.configuration.asset_service.site
+        end
+
+        def stub_requests
+          WebMock.stub_request(:get, uri_patterns[:resource]).to_return do |request|
+            log_info '[Shark][AssetService] Faking GET request'
+
+            id = extract_id_from_request_uri(request.uri)
+
+            object_data = ObjectCache.instance.find(id)
+
+            if object_data.present?
+              SharkSpec.fake_response(200, data: object_data)
+            else
+              SharkSpec.fake_response(404, errors: [])
+            end
+          end
+
+          WebMock.stub_request(:get, uri_patterns[:download]).to_return do |request|
+            log_info '[Shark][AssetService] Faking GET request'
+
+            public_id = extract_id_from_request_uri(request.uri)
+            id = PublicId.decode_public_id(public_id)
+
+            blob = ObjectCache.instance.find_blob(id)
+
+            if blob.present?
+              SharkSpec.fake_response(200, blob)
+            else
+              SharkSpec.fake_response(404, nil)
+            end
+          end
+
+          WebMock.stub_request(:get, uri_patterns[:resources]).to_return do |_request|
+            log_info '[Shark][AssetService] Faking GET request'
+            SharkSpec.fake_response(200, data: ObjectCache.instance.objects)
+          end
+
+          WebMock.stub_request(:delete, uri_patterns[:resource]).to_return do |request|
+            log_info '[Shark][AssetService] Faking DELETE request'
+
+            id = extract_id_from_request_uri(request.uri)
+
+            ObjectCache.instance.remove(id)
+
+            SharkSpec.fake_response(204, nil)
+          end
+
+          WebMock.stub_request(:post, uri_patterns[:resources]).to_return do |request|
+            log_info "[Shark][AssetService] Faking POST request with body: #{request.body}"
+
+            payload = get_payload(request.body)
+            object_data = ObjectCache.instance.add(payload)
+
+            SharkSpec.fake_response(200, data: object_data)
+          end
+
+          WebMock.stub_request(:post, uri_patterns[:recreate_variations]).to_return do |request|
+            log_info '[Shark][AssetService] Faking POST request'
+
+            id = extract_id_from_request_uri(request.uri)
+
+            if ObjectCache.instance.find(id)
+              SharkSpec.fake_response(204, nil)
+            else
+              SharkSpec.fake_response(404, errors: [])
+            end
+          end
+
+          WebMock.stub_request(:post, %r{^#{host}/packages}).to_return do |request|
+            log_info "[Shark][AssetService] Faking POST request with body: #{request.body}"
+
+            payload = get_payload(request.body)
+
+            package_data = {
+              attributes: {
+                filename: payload['filename'],
+                directory: payload['directory']
+              }
+            }
+
+            object_data = ObjectCache.instance.add(package_data)
+
+            SharkSpec.fake_response(200, data: object_data)
+          end
+
+          WebMock.stub_request(:get, %r{^#{host}/.+/download}).to_return do |_request|
+            log_info '[Shark][AssetService] Faking GET download request'
+
+            SharkSpec.fake_response(200, body: 'Lorem ipsum')
+          end
+
+          WebMock.stub_request(:put, %r{^#{host}/.+/upload}).to_return do |request|
+            log_info '[Shark][AssetService] Faking PUT upload request'
+
+            id = extract_id_from_request_uri(request.uri)
+            object_data = ObjectCache.instance.find(id)
+
+            object_data['attributes']['uploaded-at'] = 1 if object_data.present?
+
+            SharkSpec.fake_response(200, body: '<response>true</response>')
+          end
+        end
+
+        def log_info(message)
+          Shark.logger.info message
+        end
+
+        private
+
+        def extract_id_from_request_uri(uri)
+          path = uri.path
+          base_path = path['/assets/public/'] ? '/assets/public' : '/assets'
+          path.match(%r{#{base_path}/([^/]+)[/?]?})[1]
+        end
+
+        def uri_patterns
+          base_uri = "#{host}/assets"
+          id = '[^/]+'
+          optional_query = '(\?.*)?'
+
+          {
+            resources: /\A#{base_uri}#{optional_query}\z/,
+            resource: %r{\A#{base_uri}/#{id}#{optional_query}\z},
+            download: %r{\A#{base_uri}/public/#{id}#{optional_query}\z},
+            recreate_variations: %r{\A#{base_uri}/#{id}/recreate_variations#{optional_query}\z}
+          }
+        end
+
+        def get_payload(body)
+          payload = JSON.parse(body)['data']
+          payload['attributes']['id'] = payload['id'] if payload['id']
+          payload['attributes']
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_asset_service.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'fake_asset_service/public_id'
+require_relative 'fake_asset_service/object_cache'
+require_relative 'fake_asset_service/request'
+
+module Shark
+  module RSpec
+    module FakeAssetService
+      def self.setup
+        ObjectCache.clear
+        Request.setup
+      end
+
+      def self.reset
+        ObjectCache.clear
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_consent_service/object_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Shark
+  module RSpec
+    module FakeConsentService
+      class ObjectCache
+        include Singleton
+        attr_accessor :objects
+
+        def initialize
+          @objects = []
+        end
+
+        def self.clear
+          instance.objects = []
+        end
+
+        def add(payload_data)
+          id = payload_data['attributes']['legal_subject_id']
+          existing_object = objects.detect { |o| o['id'] == id }
+
+          items = (existing_object.present? && existing_object['attributes']['items']) || {}
+
+          (payload_data['attributes']['items'] || {}).each do |name, attrs|
+            items[name] = attrs.merge({ 'updated_at' => Time.now })
+          end
+
+          objects.delete_if { |o| o['id'] == id }
+
+          object = {
+            'id' => id,
+            'attributes' => {
+              'items' => items
+            },
+            'type' => 'consents'
+          }
+
+          objects.push(object)
+          object
+        end
+      end
+    end
+  end
+end