sp-duh 2.0.6

data/lib/sp/duh/i18n/excel_loader.rb

@@ -0,0 +1,26 @@
+require 'sp-excel-loader'
+
+module SP
+  module Duh
+    module I18n
+
+      class ExcelLoader < ::Sp::Excel::Loader::WorkbookLoader
+
+        def initialize(filename, pg_connection)
+          super(filename)
+          @connection = pg_connection
+        end
+
+        def clear
+          @connection.exec "DELETE FROM public.i18n"
+        end
+
+        def reload
+          export_table_to_pg(@connection,  'public', '', 'i18n')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sp/duh/jsonapi/adapters/base.rb

@@ -0,0 +1,168 @@
+module SP
+  module Duh
+    module JSONAPI
+      module Adapters
+
+        class Base
+
+          def service ; @service ; end
+
+          def initialize(service)
+            @service = service
+          end
+
+          def get(path, params = {})
+            request('GET', path, params)
+          end
+          def post(path, params = {})
+            request('POST', path, params)
+          end
+          def patch(path, params = {})
+            request('PATCH', path, params)
+          end
+          def delete(path)
+            request('DELETE', path, nil)
+          end
+
+          def get!(path, params = {})
+            request!('GET', path, params)
+          end
+          def post!(path, params = {})
+            request!('POST', path, params)
+          end
+          def patch!(path, params = {})
+            request!('PATCH', path, params)
+          end
+          def delete!(path)
+            request!('DELETE', path, nil)
+          end
+
+          def get_explicit!(exp_accounting_schema, exp_accounting_prefix, path, params = {})
+            explicit_request!(exp_accounting_schema, exp_accounting_prefix, 'GET', path, params)
+          end
+          def post_explicit!(exp_accounting_schema, exp_accounting_prefix, path, params = {})
+            explicit_request!(exp_accounting_schema, exp_accounting_prefix, 'POST', path, params)
+          end
+          def patch_explicit!(exp_accounting_schema, exp_accounting_prefix, path, params = {})
+            explicit_request!(exp_accounting_schema, exp_accounting_prefix, 'PATCH', path, params)
+          end
+          def delete_explicit!(exp_accounting_schema, exp_accounting_prefix, path)
+            explicit_request!(exp_accounting_schema, exp_accounting_prefix, 'DELETE', path, nil)
+          end
+
+          alias_method :put, :patch
+          alias_method :put!, :patch!
+          alias_method :put_explicit!, :patch_explicit!
+
+          def unwrap_request
+            unwrap_response(yield)
+          end
+
+          # do_request MUST be implemented by each specialized adapter, and returns a tuple: the request status and a JSONAPI string or hash with the result
+          def do_request(method, path, params) ; ; end
+          def explicit_do_request(exp_accounting_schema, exp_accounting_prefix, method, path, params) ; ; end
+
+          def request(method, path, params)
+            # As it is now, this method is EXACTLY the same as request!()
+            # And it cannot be reverted without affecting lots of changes already made in the app's controllers.
+            # TODO: end it, or end the !() version
+            # begin
+              unwrap_request do
+                do_request(method, path, params)
+              end
+            # THIS CAN'T BE DONE, because the same method cannot return both a single result (in case there is NOT an error) and a pair (in case there IS an error)
+            # rescue SP::Duh::JSONAPI::Exceptions::GenericModelError => e
+            #   [
+            #     e.status,
+            #     e.result
+            #   ]
+            # rescue Exception => e
+            #   [
+            #     SP::Duh::JSONAPI::Status::ERROR,
+            #     get_error_response(path, e)
+            #   ]
+            # end
+          end
+
+          def request!(method, path, params)
+            unwrap_request do
+              do_request(method, path, params)
+            end
+          end
+
+          def explicit_request!(exp_accounting_schema, exp_accounting_prefix, method, path, params)
+            unwrap_request do
+              explicit_do_request(exp_accounting_schema, exp_accounting_prefix, method, path, params)
+            end
+          end
+
+          protected
+
+            def url(path) ; File.join(service.url, path) ; end
+
+            def url_with_params_for_query(path, params)
+              query = params_for_query(params)
+              query.blank? ? url(path) : url(path) + "?" + query
+            end
+
+            def params_for_query(params)
+              query = ""
+              if !params.blank?
+                case
+                  when params.is_a?(Array)
+                    # query = params.join('&')
+                    query = params.map{ |v| URI.encode(URI.encode(v).gsub("'","''"), "&") }.join('&')
+                  when params.is_a?(Hash)
+                    query = params.map do |k,v|
+                      if v.is_a?(String)
+                        "#{k}=\"#{URI.encode(URI.encode(v).gsub("'","''"), "&")}\""
+                      else
+                        "#{k}=#{v}"
+                      end
+                    end.join('&')
+                  else
+                    query = params.to_s
+                end
+              end
+              query
+            end
+
+            def params_for_body(params)
+              params.blank? ?  '' : params.to_json.gsub("'","''")
+            end
+
+            # unwrap_response SHOULD be implemented by each specialized adapter, and returns the request result as a JSONAPI string or hash and raises an exception if there was an error
+            def unwrap_response(response)
+              # As the method request() is EXACTLY the same as request!(), and it cannot be reverted without affecting lots of changes already made in the app's controllers...
+              # Allow for response being both a [ status, result ] pair (as of old) OR a single result (as of now)
+              if response.is_a?(Array)
+                status = response[0].to_i
+                result = response[1]
+                result
+              else
+                response
+              end
+            end
+
+            def error_response(path, error)
+              {
+                errors: [
+                  {
+                    status: "#{SP::Duh::JSONAPI::Status::ERROR}",
+                    code: error.message
+                  }
+                ],
+                links: { self: url(path) },
+                jsonapi: { version: SP::Duh::JSONAPI::VERSION }
+              }
+            end
+
+            # get_error_response MUST be implemented by each specialized adapter, and returns a JSONAPI error result as a string or hash
+            def get_error_response(path, error) ; ; end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/sp/duh/jsonapi/adapters/db.rb

@@ -0,0 +1,36 @@
+module SP
+  module Duh
+    module JSONAPI
+      module Adapters
+
+        class Db < RawDb
+
+          protected
+
+            def get_error_response(path, error) ; HashWithIndifferentAccess.new(error_response(path, error)) ; end
+
+            def do_request(method, path, params)
+              process_result(do_request_on_the_db(method, path, params))
+            end
+
+            def explicit_do_request(exp_accounting_schema, exp_accounting_prefix, method, path, params)
+              process_result(explicit_do_request_on_the_db(exp_accounting_schema, exp_accounting_prefix, method, path, params))
+            end
+
+          private
+
+            def is_error?(result) ; !result[:errors].blank? ; end
+
+            def process_result(result)
+              result = HashWithIndifferentAccess.new(result)
+              result[:response] = JSON.parse(result[:response])
+              raise SP::Duh::JSONAPI::Exceptions::GenericModelError.new(result[:response]) if is_error?(result[:response])
+              [ result[:http_status], result[:response] ]
+            end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/sp/duh/jsonapi/adapters/raw_db.rb

@@ -0,0 +1,77 @@
+module SP
+  module Duh
+    module JSONAPI
+      module Adapters
+
+        class RawDb < Base
+
+          protected
+
+            def unwrap_response(response)
+              # As the method request() is EXACTLY the same as request!(), and it cannot be reverted without affecting lots of changes already made in the app's controllers...
+              # Allow for response being both a [ status, result ] pair (as of old) OR a single result (as of now)
+              if response.is_a?(Array)
+                status = response[0].to_i
+                result = response[1]
+                raise SP::Duh::JSONAPI::Exceptions::GenericModelError.new(result) if status != SP::Duh::JSONAPI::Status::OK
+                result
+              else
+                # No raise here, we do not know the status...
+                response
+              end
+            end
+
+            def get_error_response(path, error) ; error_response(path, error).to_json ; end
+
+            def do_request(method, path, param)
+              process_result(do_request_on_the_db(method, path, params))
+            end
+
+            def explicit_do_request(accounting_schema, method, path, param)
+              process_result(explicit_do_request_on_the_db(accounting_schema, method, path, params))
+            end
+
+          private
+            def user_id           ; "'#{service.parameters.user_id}'" ; end
+            def company_id        ; "'#{service.parameters.company_id}'" ; end
+            def company_schema    ; service.parameters.company_schema.nil? ? 'NULL' : "'#{service.parameters.company_schema}'" ; end
+            def sharded_schema    ; service.parameters.sharded_schema.nil? ? 'NULL' : "'#{service.parameters.sharded_schema}'" ; end
+            def accounting_schema ; service.parameters.accounting_schema.nil? ? 'NULL' : "'#{service.parameters.accounting_schema}'" ; end
+            def accounting_prefix ; service.parameters.accounting_prefix.nil? ? 'NULL' : "'#{service.parameters.accounting_prefix}'" ; end
+
+            def process_result(result)
+              raise SP::Duh::JSONAPI::Exceptions::GenericModelError.new(result) if is_error?(result)
+              [ SP::Duh::JSONAPI::Status::OK, result ]
+            end
+
+            # Implement the JSONAPI request by direct querying of the JSONAPI function in the database
+            def do_request_on_the_db(method, path, params)
+              jsonapi_query = if method == 'GET'
+                %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url_with_params_for_query(path, params)}', '', #{user_id}, #{company_id}, #{company_schema}, #{sharded_schema}, #{accounting_schema}, #{accounting_prefix}) ]
+              else
+                %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url(path)}', '#{params_for_body(params)}', #{user_id}, #{company_id}, #{company_schema}, #{sharded_schema}, #{accounting_schema}, #{accounting_prefix}) ]
+              end
+              response = service.connection.exec jsonapi_query
+              response.first if response.first
+            end
+
+            def explicit_do_request_on_the_db(exp_accounting_schema, exp_accounting_prefix, method, path, params)
+              _accounting_schema = "'#{exp_accounting_schema}'"
+              _accounting_prefix = "'#{exp_accounting_prefix}'"
+
+              jsonapi_query = if method == 'GET'
+                %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url_with_params_for_query(path, params)}', '', #{user_id}, #{company_id}, #{company_schema}, #{sharded_schema}, #{_accounting_schema}, #{_accounting_prefix}) ]
+              else
+                %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url(path)}', '#{params_for_body(params)}', #{user_id}, #{company_id}, #{company_schema}, #{sharded_schema}, #{_accounting_schema}, #{_accounting_prefix}) ]
+              end
+              response = service.connection.exec jsonapi_query
+              response.first if response.first
+            end
+
+            def is_error?(result) ; result =~ /^\s*{\s*"errors"\s*:/ ; end
+        end
+
+      end
+    end
+  end
+end

data/lib/sp/duh/jsonapi/configuration.rb

@@ -0,0 +1,167 @@
+module SP
+  module Duh
+    module JSONAPI
+
+      class Configuration
+
+        CONFIGURATION_TABLE_NAME = 'public.jsonapi_config'
+        DEFAULT_SETTINGS_FILE = 'config/jsonapi/settings.yml'
+
+        @@publishers = []
+
+        def settings
+          @settings ||= {}
+          if @settings.blank?
+            load_settings_from_file(File.join(SP::Duh.root, DEFAULT_SETTINGS_FILE))
+          end
+          @settings
+        end
+
+        def settings=(hash)
+          @settings = hash
+        end
+
+        def resources ; @resources || [] ; end
+        def resource_names ; resources.map { |r| r.keys.first } ; end
+        def connection ; @pg_connection ; end
+        def url ; @url ; end
+
+        def publishers ; @@publishers || [] ; end
+
+        def initialize(pg_connection, url)
+          @pg_connection = pg_connection
+          @url = url
+        end
+
+        def self.add_publisher(publisher)
+          begin
+            publisher = publisher.constantize if publisher.is_a?(String)
+            raise Exceptions::InvalidResourcePublisherError.new(publisher: publisher.name) if !publisher.include?(ResourcePublisher)
+            @@publishers << publisher
+          rescue StandardError => e
+            raise Exceptions::InvalidResourcePublisherError.new(publisher: publisher.is_a?(String) ? publisher : publisher.name)
+          end
+        end
+
+        def setup
+          begin
+            create_jsonapi_configuration_store()
+          rescue StandardError => e
+            raise Exceptions::GenericServiceError.new(e)
+          end
+        end
+
+        def exists?
+          check = connection.exec %Q[ SELECT COUNT(*) FROM #{Configuration::CONFIGURATION_TABLE_NAME} WHERE prefix = '#{url}' ]
+          return check.first.values.first.to_i > 0
+        end
+
+        def load_from_database
+          @resources = []
+          @settings = {}
+          configuration = connection.exec %Q[ SELECT config FROM #{Configuration::CONFIGURATION_TABLE_NAME} WHERE prefix = '#{url}' ]
+          if configuration.first
+            configuration = JSON.parse(configuration.first['config'])
+            @resources = configuration['resources']
+            @settings = configuration.reject { |k,v| k == 'resources' }
+          end
+          @resources
+        end
+
+        def load_from_publishers(replace = false)
+          @resources = []
+          @settings = {}
+          @@publishers.each do |publisher|
+             add_resources_from_folder(publisher.jsonapi_resources_root, replace)
+          end
+          @resources
+        end
+
+        def save
+          begin
+            if exists?
+              connection.exec %Q[
+                UPDATE #{Configuration::CONFIGURATION_TABLE_NAME} SET config='#{definition.to_json}' WHERE prefix='#{url}';
+              ]
+            else
+              connection.exec %Q[
+                INSERT INTO #{Configuration::CONFIGURATION_TABLE_NAME} (prefix, config) VALUES ('#{url}','#{definition.to_json}');
+              ]
+            end
+          rescue StandardError => e
+            raise Exceptions::SaveConfigurationError.new(nil, e)
+          end
+        end
+
+        def reload!
+          load_from_publishers(true)
+          save
+          @resources
+        end
+
+        def load_settings_from_file(file_name)
+          @settings = YAML.load_file(file_name)
+        end
+
+        private
+
+          def create_jsonapi_configuration_store
+            connection.exec %Q[
+              CREATE TABLE IF NOT EXISTS #{Configuration::CONFIGURATION_TABLE_NAME} (
+                prefix varchar(64) PRIMARY KEY,
+                config text NOT NULL
+              );
+            ]
+          end
+
+          def definition
+            settings.merge(resources: resources)
+          end
+
+          def add_resources_from_folder(folder_name, replace)
+            @resources ||= []
+            # First load resources at the root folder
+            Dir.glob(File.join(folder_name, '*.yml')) do |configuration_file|
+              add_resources_from_file(configuration_file, replace)
+            end
+            # Then load resources at the inner folders
+            Dir.glob(File.join(folder_name, '*', '*.yml')) do |configuration_file|
+              add_resources_from_file(configuration_file, replace)
+            end
+            @resources
+          end
+
+          def add_resources_from_file(configuration_file, replace)
+            _log "Processing resources from file #{configuration_file}", "JSONAPI::Configuration"
+            configuration =  YAML.load_file(configuration_file)
+            if configuration.is_a? Hash
+              add_resource(configuration, configuration_file, replace)
+            else
+              if configuration.is_a? Array
+                configuration.each { |resource| add_resource(resource, configuration_file, replace) }
+              else
+                raise Exceptions::InvalidResourceConfigurationError.new(file: configuration_file)
+              end
+            end
+          end
+
+          def add_resource(resource, configuration_file, replace)
+            raise Exceptions::InvalidResourceConfigurationError.new(file: configuration_file) if (resource.keys.count != 1)
+            resource_name = resource.keys[0]
+            _log "Processing resource #{resource_name}", "JSONAPI::Configuration"
+            processed = false
+            @resources.each_with_index do |r, i|
+              if r.keys.include?(resource_name)
+                raise Exceptions::DuplicateResourceError.new(name: resource_name) if !replace
+                @resources[i] = resource
+                processed = true
+                break
+              end
+            end
+            @resources << resource if !processed
+          end
+      end
+
+    end
+  end
+end