ledger_sync 1.1.3 → 1.3.1

data/lib/ledger_sync/adaptors/netsuite_soap/subsidiary/operations/create.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    module NetSuiteSOAP
+      module Subsidiary
+        module Operations
+          class Create < NetSuiteSOAP::Operation::Create
+            class Contract < LedgerSync::Adaptors::Contract
+              params do
+                required(:external_id).filled(:string)
+                required(:ledger_id).value(:nil)
+                required(:name).filled(:string)
+                required(:state).filled(:string)
+              end
+            end
+
+            private
+
+            def operate
+              netsuite_resource = ::NetSuite::Records::Subsidiary.new(
+                external_id: resource.external_id,
+                name: resource.name,
+                state: resource.state
+              )
+
+              return netsuite_failure(netsuite_resource: netsuite_resource) unless netsuite_resource.add
+
+              resource.name = netsuite_resource.name
+              resource.ledger_id = netsuite_resource.internal_id
+
+              success(
+                resource: resource,
+                response: netsuite_resource
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/adaptors/netsuite_soap/subsidiary/operations/find.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    module NetSuiteSOAP
+      module Subsidiary
+        module Operations
+          class Find < NetSuiteSOAP::Operation::Find
+            class Contract < LedgerSync::Adaptors::Contract
+              params do
+                required(:external_id).maybe(:string)
+                required(:ledger_id).filled(:string)
+                required(:name).maybe(:string)
+                required(:state).maybe(:string)
+              end
+            end
+
+            private
+
+            def operate
+              netsuite_resource = ::NetSuite::Records::Subsidiary.get(
+                internal_id: resource.ledger_id
+              )
+
+              resource.name = netsuite_resource.name
+              resource.ledger_id = netsuite_resource.internal_id
+
+              success(
+                resource: resource,
+                response: netsuite_resource
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/adaptors/operation.rb

@@ -3,7 +3,7 @@
 module LedgerSync
   module Adaptors
     module Operation
-      TYPES = %i[create find update].freeze
+      TYPES = %i[create delete find update].freeze
 
       module Mixin
         module ClassMethods
@@ -11,6 +11,10 @@ module LedgerSync
             @adaptor_klass ||= Class.const_get("#{name.split('::')[0..2].join('::')}::Adaptor")
           end
 
+          def operations_module
+            @operations_module ||= Object.const_get(name.split('::Operations::').first + '::Operations')
+          end
+
           def resource_klass
             @resource_klass ||= LedgerSync.const_get(
               name
@@ -25,7 +29,7 @@ module LedgerSync
         def self.included(base)
           base.include SimplySerializable::Mixin
           base.include Fingerprintable::Mixin
-          # base.include Validatable
+          base.include Adaptors::Mixins::InferLedgerSerializerMixin
           base.extend ClassMethods
 
           base.class_eval do
@@ -107,10 +111,7 @@ module LedgerSync
         end
 
         def ledger_serializer
-          @ledger_serializer ||= begin
-            modules = self.class.name.split('::Operations::').first
-            Object.const_get("#{modules}::LedgerSerializer").new(resource: resource)
-          end
+          self.class.inferred_ledger_serializer(resource: resource)
         end
 
         # Results
@@ -182,11 +183,6 @@ module LedgerSync
           define_method "#{type.to_s.downcase}?" do
             false
           end
-
-          define_method "convert_to_#{type.to_s.downcase}" do
-            update_klass_name = self.class.name.split('::')[0..-2].append(LedgerSync::Util::StringHelpers.camelcase(type.to_s)).join('::')
-            Object.const_get(update_klass_name).new(adaptor: adaptor, resource: resource)
-          end
         end
 
         private

data/lib/ledger_sync/adaptors/quickbooks_online/account/searcher.rb

@@ -5,19 +5,8 @@ module LedgerSync
     module QuickBooksOnline
       module Account
         class Searcher < QuickBooksOnline::Searcher
-          def resources
-            @resources ||= begin
-              adaptor
-                .query(
-                  resource: 'account',
-                  query: "Name LIKE '%#{query}%'",
-                  limit: limit,
-                  offset: offset
-                )
-                .map do |c|
-                  LedgerSerializer.new(resource: LedgerSync::Account.new).deserialize(hash: c)
-                end
-            end
+          def query_string
+            "Name LIKE '%#{query}%'"
           end
         end
       end

data/lib/ledger_sync/adaptors/quickbooks_online/adaptor.rb

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
-require 'oauth2'
+require_relative 'oauth_client'
+require_relative 'dashboard_url_helper'
 
 module LedgerSync
   module Adaptors
     module QuickBooksOnline
       class Adaptor < LedgerSync::Adaptors::Adaptor
-        AUTHORIZE_URL     = 'https://appcenter.intuit.com/connect/oauth2'
         OAUTH_HEADERS     = { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }.freeze
         ROOT_URI          = 'https://quickbooks.api.intuit.com'
+        REVOKE_TOKEN_URI  = 'https://developer.api.intuit.com/v2/oauth2/tokens/revoke'
         ROOT_SANDBOX_URI  = 'https://sandbox-quickbooks.api.intuit.com'
-        SITE_URL          = 'https://appcenter.intuit.com/connect/oauth2'
-        TOKEN_URL         = 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer'
+        API_RESOURCE_MAPPING_OVERRIDE = {
+          LedgerSync::Expense => 'purchase',
+          LedgerSync::LedgerClass => 'class'
+        }
+        API_RESOURCE_MAPPING_OVERRIDE_REVERSE = API_RESOURCE_MAPPING_OVERRIDE.invert
 
         attr_reader :access_token,
                     :client_id,
@@ -23,7 +27,8 @@ module LedgerSync
                     :refresh_token,
                     :refresh_token_expires_at,
                     :root_uri,
-                    :test
+                    :test,
+                    :update_dotenv
 
         def initialize(
           access_token:,
@@ -31,167 +36,209 @@ module LedgerSync
           client_secret:,
           realm_id:,
           refresh_token:,
-          test: false
+          test: false,
+          update_dotenv: true
         )
           @access_token = access_token
           @client_id = client_id
           @client_secret = client_secret
-          @previous_access_tokens = []
-          @previous_refresh_tokens = []
           @realm_id = realm_id
           @refresh_token = refresh_token
           @test = test
+          @update_dotenv = update_dotenv
+
+          @previous_access_tokens = []
+          @previous_refresh_tokens = []
 
           @root_uri = (test ? ROOT_SANDBOX_URI : ROOT_URI)
+
+          update_secrets_in_dotenv if update_dotenv
         end
 
         def authorization_url(redirect_uri:)
-          oauth_client.auth_code.authorize_url(
-            redirect_uri: redirect_uri,
-            response_type: 'code',
-            state: SecureRandom.hex(12),
-            scope: 'com.intuit.quickbooks.accounting'
-          )
+          oauth_client.authorization_url(redirect_uri: redirect_uri)
         end
 
-        def find(resource:, id:)
-          resource = resource.to_s
-          url = "#{oauth_base_uri}/#{resourcify(resource)}/#{id}"
+        def find(path:)
+          url = "#{oauth_base_uri}/#{path}"
 
-          response = request(:get, url, headers: OAUTH_HEADERS.dup)
-          JSON.parse(response.body).dig(resource.classify)
+          request(
+            headers: OAUTH_HEADERS.dup,
+            method: :get,
+            url: url
+          )
         end
 
-        def parse_operation_error(error:, operation:)
-          return nil unless error.is_a?(OAuth2::Error)
+        def oauth
+          OAuth2::AccessToken.new(
+            oauth_client.client,
+            access_token,
+            refresh_token: refresh_token
+          )
+        end
 
-          Util::OperationErrorParser.new(
-            error: error,
-            operation: operation
-          ).parse
+        def oauth_client
+          @oauth_client ||= OAuthClient.new(
+            client_id: client_id,
+            client_secret: client_secret
+          )
         end
 
-        def post(resource:, payload:)
-          resource = resource.to_s
-          url = "#{oauth_base_uri}/#{resourcify(resource)}"
+        def post(path:, payload:)
+          url = "#{oauth_base_uri}/#{path}"
 
-          response = request(:post, url, headers: OAUTH_HEADERS.dup, body: payload.to_json)
-          JSON.parse(response.body).dig(resource.classify)
+          request(
+            headers: OAUTH_HEADERS.dup,
+            method: :post,
+            body: payload.to_json,
+            url: url
+          )
         end
 
-        def query(resource:, query:, limit: 10, offset: 1)
-          resource = resource.to_s
-          full_query = "SELECT * FROM #{resource.classify} WHERE #{query} STARTPOSITION #{offset} MAXRESULTS #{limit}"
+        def query(limit: 10, offset: 1, query:, resource_class:)
+          ledger_resource_type = self.class.ledger_resource_type_for(
+            resource_class: resource_class
+          ).classify
+          full_query = "SELECT * FROM #{ledger_resource_type} WHERE #{query} STARTPOSITION #{offset} MAXRESULTS #{limit}"
           url = "#{oauth_base_uri}/query?query=#{CGI.escape(full_query)}"
 
-          response = request(:get, url, headers: OAUTH_HEADERS.dup)
-          JSON.parse(response.body).dig('QueryResponse', resource.classify) || []
+          request(
+            headers: OAUTH_HEADERS.dup,
+            method: :get,
+            url: url
+          )
         end
 
         def refresh!
-          set_credentials_from_oauth_token(token: oauth.refresh!)
-
+          set_credentials_from_oauth_token(
+            token: Request.new(
+              adaptor: self
+            ).refresh!
+          )
           self
-        rescue OAuth2::Error => e
-          raise parse_error(error: e)
         end
 
-        def set_credentials_from_oauth_code(code:, redirect_uri:)
-          oauth_token = oauth_client.auth_code.get_token(
-            code,
+        def revoke_token!
+          headers = OAUTH_HEADERS.dup.merge('Authorization' => 'Basic ' + Base64.strict_encode64(client_id + ':' + client_secret))
+          LedgerSync::Adaptors::Request.new(
+            body: {
+              token: access_token
+            },
+            headers: headers,
+            method: :post,
+            url: REVOKE_TOKEN_URI
+          ).perform.status == 200
+        end
+
+        def set_credentials_from_oauth_code(code:, realm_id: nil, redirect_uri:)
+          oauth_token = oauth_client.get_token(
+            code: code,
             redirect_uri: redirect_uri
           )
 
-          set_credentials_from_oauth_token(token: oauth_token)
+          set_credentials_from_oauth_token(
+            realm_id: realm_id,
+            token: oauth_token
+          )
 
           oauth_token
         end
 
+        def update_secrets_in_dotenv
+          return if ENV['TEST_ENV'] && !ENV['USE_DOTENV_ADAPTOR_SECRETS']
+
+          filename = File.join(LedgerSync.root, '.env')
+          return unless File.exist?(filename)
+
+          prefix = 'QUICKBOOKS_ONLINE_'
+
+          Tempfile.open(".#{File.basename(filename)}", File.dirname(filename)) do |tempfile|
+            File.open(filename).each do |line|
+              env_key = line.split('=').first
+              adaptor_method = env_key.split(prefix).last.downcase
+
+              if line =~ /\A#{prefix}/ && respond_to?(adaptor_method)
+                env_value = ENV[env_key]
+                new_value = send(adaptor_method)
+                tempfile.puts "#{env_key}=#{new_value}"
+                next if env_value == new_value
+
+                ENV[env_key] = new_value
+                tempfile.puts "# #{env_key}=#{env_value} # Updated on #{Time.now}"
+              else
+                tempfile.puts line
+              end
+            end
+            tempfile.close
+            FileUtils.mv tempfile.path, filename
+          end
+
+          Dotenv.load
+        end
+
         def url_for(resource:)
-          base_url = test ? 'https://app.sandbox.qbo.intuit.com/app' : 'https://qbo.intuit.com/app'
-          resource_path = case resource
-                          when LedgerSync::Account
-                            "/register?accountId=#{resource.ledger_id}"
-                          when LedgerSync::Bill
-                            "/bill?txnId=#{resource.ledger_id}"
-                          when LedgerSync::Customer
-                            "/customerdetail?nameId=#{resource.ledger_id}"
-                          when LedgerSync::Deposit
-                            "/deposit?txnId=#{resource.ledger_id}"
-                          when LedgerSync::Expense
-                            "/expense?txnId=#{resource.ledger_id}"
-                          when LedgerSync::JournalEntry
-                            "/journal?txnId=#{resource.ledger_id}"
-                          when LedgerSync::Payment
-                            "/recvpayment?txnId=#{resource.ledger_id}"
-                          when LedgerSync::Transfer
-                            "/transfer?txnId=#{resource.ledger_id}"
-                          when LedgerSync::Vendor
-                            "/vendordetail?nameId=#{resource.ledger_id}"
-                          end
-
-          base_url + resource_path
+          DashboardURLHelper.new(resource: resource, test: test).url
         end
 
         def self.ledger_attributes_to_save
           %i[access_token expires_at refresh_token refresh_token_expires_at]
         end
 
-        private
-
-        def oauth_base_uri
-          @oauth_base_uri ||= "#{root_uri}/v3/company/#{realm_id}"
-        end
-
-        def oauth(force: false)
-          if @oauth.nil? || force
-            @oauth = OAuth2::AccessToken.new(
-              oauth_client,
-              access_token,
-              refresh_token: refresh_token
-            )
-          end
-
-          @oauth
+        def self.ledger_resource_type_for(resource_class:)
+          API_RESOURCE_MAPPING_OVERRIDE[resource_class] || resource_class.resource_type.to_s
         end
 
-        def oauth_client
-          @oauth_client ||= OAuth2::Client.new(
-            client_id,
-            client_secret,
-            authorize_url: AUTHORIZE_URL,
-            site: SITE_URL,
-            token_url: TOKEN_URL
+        def self.new_from_env(**override)
+          new(
+            {
+              access_token: ENV.fetch('QUICKBOOKS_ONLINE_ACCESS_TOKEN'),
+              client_id: ENV.fetch('QUICKBOOKS_ONLINE_CLIENT_ID'),
+              client_secret: ENV.fetch('QUICKBOOKS_ONLINE_CLIENT_SECRET'),
+              realm_id: ENV.fetch('QUICKBOOKS_ONLINE_REALM_ID'),
+              refresh_token: ENV.fetch('QUICKBOOKS_ONLINE_REFRESH_TOKEN')
+            }.merge(override)
           )
         end
 
-        def request(method, *args)
-          oauth.send(method, *args)
-        rescue OAuth2::Error => e
-          error = parse_error(error: e) || parse_operation_error(error: e, operation: nil) || e
+        def self.new_from_oauth_client_uri(oauth_client:, uri:, **override)
+          parsed_uri = OAuthClient::RedirectURIParser.new(uri: uri)
+          oauth_token = oauth_client.get_token(
+            code: parsed_uri.code,
+            redirect_uri: parsed_uri.redirect_uri
+          )
 
-          raise error unless error.is_a?(Error::AdaptorError::AuthenticationError)
+          new(
+            {
+              access_token: oauth_token.token,
+              client_id: oauth_client.client_id,
+              client_secret: oauth_client.client_secret,
+              realm_id: parsed_uri.realm_id,
+              refresh_token: oauth_token.refresh_token
+            }.merge(override)
+          )
+        end
 
-          begin
-            refresh!
-            oauth.send(method, *args)
-          rescue OAuth2::Error => e
-            raise parse_error(error: e) || e
-          end
+        def self.resource_from_ledger_type(type:)
+          API_RESOURCE_MAPPING_OVERRIDE_REVERSE[type.downcase] || LedgerSync.resources[type.downcase.to_sym]
         end
 
-        def parse_error(error:)
-          Util::AdaptorErrorParser.new(
-            error: error,
-            adaptor: self
-          ).parse
+        private
+
+        def oauth_base_uri
+          @oauth_base_uri ||= "#{root_uri}/v3/company/#{realm_id}"
         end
 
-        def resourcify(str)
-          str.tr('_', '')
+        def request(body: nil, headers: {}, method:, url:)
+          Request.new(
+            adaptor: self,
+            body: body,
+            headers: headers,
+            method: method,
+            url: url
+          ).perform
         end
 
-        def set_credentials_from_oauth_token(token:)
+        def set_credentials_from_oauth_token(realm_id: nil, token:)
           @previous_access_tokens << access_token if access_token.present?
           @access_token = token.token
 
@@ -201,7 +248,9 @@ module LedgerSync
           @previous_refresh_tokens << refresh_token if refresh_token.present?
           @refresh_token = token.refresh_token
 
-          oauth(force: true) # Ensure we update the memoized @oauth
+          @realm_id = realm_id unless realm_id.nil?
+        ensure
+          update_secrets_in_dotenv if update_dotenv
         end
       end
     end