wolf_core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9b284a7f298a9af0d3d5bba012296ae0c3097561fc68152d3c9c172dc4f51d83
+  data.tar.gz: 9836ec6f17456d430c81f91fdb753454b6fe4dcd14399c64026295f608fa4a23
+SHA512:
+  metadata.gz: b56f79dec0d5ff8b128dd2bee0dada31b54c8df9b660923bb4274fd89d28c44a9099dcdff5776a666b0edf92146d69db63998f15b0527e6f0832b0be332543e7
+  data.tar.gz: e531e17cb5befd062079f8dd3a165ec8705a973039a080dfc0c7133766bb1f6e5a32f8f4fa6e714df9ab5a8e163033f2b8488f5962b2722477eca3152eac6914

data/lib/wolf_core/application/application_service.rb

@@ -0,0 +1,130 @@
+module WolfCore
+  class ApplicationService
+    def call
+      process
+    rescue => e
+      if e.instance_of?(WolfCore::ServiceException)
+        return Result.failure(
+          error: e.error.to_h.merge({ backtrace: e.backtrace })
+        )
+      end
+
+      # Honeybadger.notify(e)
+      return Result.failure(error: { message: e.message, backtrace: e.backtrace })
+    end
+
+    def process
+      raise NotImplementedError
+    end
+
+    def raise_failed_result(result)
+      return if result.success?
+
+      raise_service_error(result.error.to_h)
+    end
+
+    def validate_presence(object, message)
+      return if object.present?
+
+      raise_service_error({ message: message })
+    end
+
+    def raise_service_error(error_data)
+      raise WolfCore::ServiceException, error_data
+    end
+
+    def remove_non_permitted_parameters(params, allowed_params)
+      permitted = params.slice(*allowed_params)
+      if permitted.blank?
+        raise_service_error({ message: "There are not permitted parameters"})
+      end
+      return permitted
+    end
+
+    def http_get(url:, headers: {}, query: nil)
+    WolfCore::HttpDataSource.http_get(url: url, headers: headers, query: query)
+    end
+
+    def http_post(url:, headers: {}, body: nil, query: nil)
+    WolfCore::HttpDataSource.http_post(url: url, headers: headers, query: query, body: body)
+    end
+
+    def barton_integration_http_post(path:, body:, error_message:)
+      domain_url = ENV['CURRENT_SAM_URL']
+      response = http_post(url: "#{domain_url}/#{path}", body: body)
+      validate_http_response(
+        response: response, message: error_message, error_data: { url: path }
+      )
+      response
+    end
+
+    def validate_http_response(response:, message:, error_data: nil)
+      unless response.code == 200
+        error_data = {
+          message: message,
+          response: parse_http_response(response)
+        }.merge(error_data || {})
+        raise_service_error(error_data)
+      end
+    end
+
+    def parse_http_response(response)
+      body = JSON.parse(response.body) rescue response.body
+      {
+        code: response.code,
+        body: body,
+        message: response.message,
+      }
+    end
+
+    def get_salesforce_access_token
+      result = WolfCore::SalesforceOauthService.new.call
+      raise_failed_result(result)
+      result.data.access_token
+    end
+
+    def get_salesforce_foreign_object(record_id:)
+      data = saleforce_http_get(
+        query: { calltype: 'getRecord', RecordId: record_id }
+      )
+      foreign_object = data.first
+      puts "foreign object is"
+      pp foreign_object
+      foreign_object
+    end
+
+    def saleforce_http_get(query: nil)
+      response = http_get(
+        url: ENV['SALESFORCE_URL'],
+        headers: { 'Authorization' => "Bearer #{@salesforce_access_token}" },
+        query: query
+      )
+      validate_salesforce_response(response)
+      JSON.parse(response.parsed_response)
+    end
+
+    def validate_salesforce_response(response)
+      return if response.code == 200
+      message = JSON.parse(response.body).first['message']
+      raise_service_error({ message: message })
+    end
+
+    def get_wolf_token
+      response = http_post(
+        query: { tenant: ENV['TENANT'] },
+        url: "#{ENV['WOLF_PLATFORM_URL']}/api/v1/sign_in",
+        body: {
+          email: ENV['WOLF_ADMIN_EMAIL'],
+          password: ENV['WOLF_ADMIN_PASSWORD']
+        }
+      )
+      validate_http_response(
+        response: response, message: 'Failed to get wolf token'
+      )
+      response_body = JSON.parse(response.body)
+      wolf_token = response_body.dig('user', 'authentication_token')
+      puts "wolf token is #{wolf_token}"
+      wolf_token
+    end
+  end
+end

data/lib/wolf_core/application/salesforce_oauth_service.rb

@@ -0,0 +1,24 @@
+module WolfCore
+  class SalesforceOauthService < WolfCore::ApplicationService
+    def process
+      response = http_post(
+        url: ENV['SALESFORCE_OAUTH_URL'],
+        headers: { 'Content-Type' => 'application/x-www-form-urlencoded' },
+        body: {
+          grant_type: ENV['SALESFORCE_OAUTH_GRANT_TYPE'],
+          username: ENV['SALESFORCE_OAUTH_USERNAME'],
+          password: ENV['SALESFORCE_OAUTH_PASSWORD'],
+          client_id: ENV['SALESFORCE_OAUTH_CLIENT_ID'],
+          client_secret: ENV['SALESFORCE_OAUTH_CLIENT_SECRET'],
+        }
+      )
+      if response.code == 200
+        access_token = JSON.parse(response.body)['access_token']
+        puts "salesforce access token is #{access_token}"
+        Result.success(data: { access_token: access_token })
+      else
+        Result.failure(error: { message: response.message, code: response.code, body: response.body })
+      end
+    end
+  end
+end

data/lib/wolf_core/application/service_exception.rb

@@ -0,0 +1,12 @@
+module WolfCore
+  class ServiceException < StandardError
+    attr_reader :error
+
+    def initialize(error)
+      @error = OpenStruct.new(
+        { message: 'error' }.merge(error)
+      )
+      super(@error[:message])
+    end
+  end
+end

data/lib/wolf_core/infrastructure/http_data_source.rb

@@ -0,0 +1,15 @@
+module WolfCore
+  module HttpDataSource
+    module_function
+
+    def http_get(url:, headers: {}, query: nil)
+      HTTParty.get(url, headers: headers, query: query)
+    end
+
+    def http_post(url:, headers: {}, query: nil, body: nil)
+      headers['Content-Type'] ||= 'application/json'
+      body = body&.to_json if headers['Content-Type'] == 'application/json'
+      HTTParty.post(url, headers: headers, query: query, body: body)
+    end
+  end
+end

data/lib/wolf_core/utils/hash_extension.rb

@@ -0,0 +1,26 @@
+class Hash
+  def with_indifferent_access
+    hash = self.dup
+    hash.extend IndifferentAccess
+    hash
+  end
+
+  module IndifferentAccess
+    def [](key)
+      fetch(key.to_s) { fetch(key.to_sym) { nil } }
+    end
+
+    def fetch(key, *extras)
+      super(key.to_s, *extras)
+    rescue KeyError
+      super(key.to_sym, *extras)
+    end
+
+    def has_key?(key)
+      key?(key.to_s) || key?(key.to_sym)
+    end
+    alias_method :include?, :has_key?
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
+  end
+end

data/lib/wolf_core/utils/object_extension.rb

@@ -0,0 +1,9 @@
+class Object
+  def present?
+    !blank?
+  end
+
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end

data/lib/wolf_core/utils/require_utils.rb

@@ -0,0 +1,10 @@
+module WolfCore
+  module RequireUtils
+    module_function
+
+    def require_relative_files(*folders)
+      folder_files = File.join(*folders, '**', '*.rb')
+      Dir[folder_files].sort.each { |file| require_relative file }
+    end
+  end
+end

data/lib/wolf_core/utils/result.rb

@@ -0,0 +1,27 @@
+module WolfCore
+  class Result
+    attr_accessor :data, :error
+  
+    def initialize(success:, data: nil, error: nil)
+      @success = success
+      @data = data
+      @error = error
+    end
+  
+    def self.success(data: {})
+      Result.new(success: true, data: OpenStruct.new(data))
+    end
+  
+    def self.failure(error: {})
+      Result.new(success: false, error: OpenStruct.new(error))
+    end
+  
+    def success?
+      @success
+    end
+  
+    def failure?
+      !@success
+    end
+  end
+end

data/lib/wolf_core/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WolfCore
+  VERSION = "0.1.0"
+end

data/lib/wolf_core.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'httparty'
+
+module WolfCore; end
+
+require 'wolf_core/utils/require_utils'
+
+WolfCore::RequireUtils.require_relative_files(__dir__, 'wolf_core')

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: wolf_core
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Javier Roncallo
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Repository to store shared code among Ruby projects.
+email:
+- jroncallo96@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wolf_core.rb
+- lib/wolf_core/application/application_service.rb
+- lib/wolf_core/application/salesforce_oauth_service.rb
+- lib/wolf_core/application/service_exception.rb
+- lib/wolf_core/infrastructure/http_data_source.rb
+- lib/wolf_core/utils/hash_extension.rb
+- lib/wolf_core/utils/object_extension.rb
+- lib/wolf_core/utils/require_utils.rb
+- lib/wolf_core/utils/result.rb
+- lib/wolf_core/version.rb
+homepage: https://github.com/onewolfxyz/wolf_core
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/onewolfxyz/wolf_core
+  source_code_uri: https://github.com/onewolfxyz/wolf_core
+  changelog_uri: https://github.com/onewolfxyz/wolf_core
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.4
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.14
+signing_key:
+specification_version: 4
+summary: Repository to store shared code among Ruby projects.
+test_files: []