rnsap 0.4.0 → 0.4.8

data/lib/read_table/table_column.rb

@@ -0,0 +1,14 @@
+  # class used to represent a Table Column. Used internally
+  # to map SAP's returned working area (WA) into class instances
+    class TableColumn
+        # @return [String] Name of the table field
+        attr_accessor :field_name
+        # @return [Integer] Number of characters to offset when looking for the field in the Working Area (WA)
+        attr_accessor :offset
+        # @return [Integer] Length of the field returned in the Working Area (WA)
+        attr_accessor :length
+        # @return [String] Data Type (ex: Character, Decimal, Number)
+        attr_accessor :type
+        # @return [String] Field Description returned by the SAP dictionary
+        attr_accessor :description
+    end

data/lib/return.rb

@@ -0,0 +1,21 @@
+# class used to represent RETURN. Used internally
+class Return
+  # @return [String] Message code
+  attr_accessor :code
+  # @return [String] Application log: Internal message serial number
+  attr_accessor :log_msg_no
+  # @return [String] Application log: log number
+  attr_accessor :log_no
+  # @return [String] Message Text
+  attr_accessor :message
+  # @return [String] Message Variable
+  attr_accessor :message_v1
+  # @return [String] Message Variable
+  attr_accessor :message_v2
+  # @return [String] Message Variable
+  attr_accessor :message_v3
+  # @return [String] Message Variable
+  attr_accessor :message_v4
+  # @return [String] Message type: S Success, E Error, W Warning, I Info, A Abort
+  attr_accessor :type  
+end

data/lib/rnsap.rb

@@ -1,8 +1,25 @@
 # frozen_string_literal: true
 
 require 'nwrfc'
+require 'read_table/table_column'
+require 'preq_detail/preq_item'
+require 'preq_detail/preq_acct_assignment'
+require 'preq_detail/preq_text'
+require 'preq_detail/preq_limits'
+require 'preq_detail/preq_contract_limits'
+require 'preq_detail/preq_services'
+require 'preq_detail/preq_services_texts'
+require 'preq_detail/preq_srv_accass_values'
+require 'preq_release_info/preq_gen_release_info'
+require 'preq_release_info/preq_release_prerequisites'
+require 'preq_release_info/preq_release_posted'
+require 'preq_release_info/preq_release_final'
+require 'return'
+require 'helper/rfc_helper'
+require 'helper/util_helper'
 
 include NWRFC
+include UtilHelper
 
 # Module for SAP helper methods. RnSap allows for a simpler
 # manner to access SAP servers calling RFC BAPIs.
@@ -18,6 +35,9 @@ module RnSap
     # keeps the SAP connection alive during the Sap instance lifecycle
     attr_reader :conn
 
+    INT_TYPES ||= ['b','N']
+    FLOAT_TYPES ||= ['P']
+    DATE_TYPES ||=['D']
     # Constructor requires to receive connection parameters,
     # a hash containint necessary information to logon to SAP
     # @param conn_parms [Hash] SAP Connection Parameters
@@ -30,6 +50,28 @@ module RnSap
       conn.disconnect
     end
 
+    def commit(conn)
+
+      #-- Execute BAPI_TRANSACTION_COMMIT
+      fn_commit = conn.get_function('BAPI_TRANSACTION_COMMIT')
+      fn_commit = fn_commit.get_function_call
+      fn_commit[:WAIT] = 'X'
+
+      fn_commit.invoke
+
+      api_return_success({tb_return: fn_commit[:RETURN]})
+    end
+    
+    def rollback(conn)
+      #-- Execute BAPI_TRANSACTION_ROLLBACK
+      fn_rollback = conn.get_function('BAPI_TRANSACTION_ROLLBACK')
+      fn_rollback = fn_rollback.get_function_call
+
+      fn_rollback.invoke
+
+      api_return_success({tb_return: fn_rollback[:RETURN]})
+    end
+
     # Invokes SAP RFC_READ_TABLE function module remotely, passing
     # the table to be read and receiving back a list of objects of that
     # table.
@@ -107,13 +149,38 @@ module RnSap
       end
 
       list = []
+
       fc_read_table[:DATA].each do |row|
         obj = base_obj.class.new
-        wa = row[:WA]
+        wa = row[:WA].split('|')
+        pos = -1
         fields_down.each do |field|
+          pos = pos + 1
           column = columns_hash[field.upcase]
-          value = wa[column.offset.to_i, column.length.to_i]
-          eval("obj.#{field} = '#{value}'")
+          # value = wa[column.offset.to_i, column.length.to_i]
+          if INT_TYPES.include?(column.type)
+            value = wa[pos].to_i
+            eval("obj.#{field} = #{value}")
+          elsif FLOAT_TYPES.include?(column.type)
+            value = wa[pos].to_f
+            eval("obj.#{field} = #{value}")
+          elsif DATE_TYPES.include?(column.type)
+            value = wa[pos].strip
+            if value == '00000000'
+              eval("obj.#{field} = nil")
+            else
+              value = Date.new(
+                value[0..3], 
+                value[4..5], 
+                value[6..7]
+              )
+              eval("obj.#{field} = #{value}")
+            end            
+          else
+            value = wa[pos].strip
+            eval("obj.#{field} = '#{value}'")
+          end
+
         end
         list << obj
       end
@@ -133,26 +200,155 @@ module RnSap
       fc_preq_detail[:SERVICE_TEXTS] = services_texts
       
       fc_preq_detail.invoke
+
+      #-- Execute conversions for returned tables to a designated list (array)
+      preq_items = get_object_list(fc_preq_detail[:REQUISITION_ITEMS], PreqItem.to_s)
+      preq_acct_assignment = get_object_list(fc_preq_detail[:REQUISITION_ACCOUNT_ASSIGNMENT], PreqAcctAssignment.to_s)
+      preq_text = get_object_list(fc_preq_detail[:REQUISITION_TEXT], PreqText.to_s)
+      preq_limits = get_object_list(fc_preq_detail[:REQUISITION_LIMITS], PreqLimits.to_s)
+      preq_contract_limits = get_object_list(fc_preq_detail[:REQUISITION_CONTRACT_LIMITS], PreqContractLimits.to_s)
+      preq_services = get_object_list(fc_preq_detail[:REQUISITION_SERVICES], PreqItem.to_s)
+      preq_services_texts = get_object_list(fc_preq_detail[:REQUISITION_SERVICES_TEXTS], PreqServicesText.to_s)
+      preq_srv_accass_values = get_object_list(fc_preq_detail[:REQUISITION_SRV_ACCASS_VALUES], PreqServicesAccassValues.to_s)
+      tb_return = get_object_list(fc_preq_detail[:RETURN], Return.to_s)
+
+      retcode = tb_return.detect{|r| r.type == 'E'} 
+
+      if retcode
+        api_return_error(retcode)
+      else
+        api_return_success({
+          preq_items: preq_items,
+          preq_acct_assignment: preq_acct_assignment,
+          preq_text: preq_text,
+          preq_limits: preq_limits,
+          preq_contract_limits: preq_contract_limits,
+          preq_services: preq_services,
+          preq_services_texts: preq_services_texts,
+          preq_srv_accass_values: preq_srv_accass_values,
+          tb_return: tb_return,
+        })
+      end
       
-      list = []
-      avoid_list = ['!','__','+', '=','!', '?','~','>', '<']
-      fc_preq_detail[:REQUISITION_ITEMS].each do |row|
-        preq = PreqItem.new
-        preq.class.instance_methods.each do |method_name|
-          begin
-            if preq.respond_to?("#{method_name}=")
-              unless avoid_list.any? { |word| method_name.to_s.include?(word)}
-                value = row[method_name]
-                eval("preq.#{method_name} = '#{value}'")
-              end
-            end
-          rescue
-          end
+    end
+
+    def preq_release_strategy_info(preq = 0, item = "00000", rel_code = "")
+      #-- Execute BAPI_REQUISITION_GETRELINFO
+      fn_preq_rel_strat_info = @conn.get_function('BAPI_REQUISITION_GETRELINFO')
+      fn_preq_rel_strat_info = fn_preq_rel_strat_info.get_function_call
+      
+      fn_preq_rel_strat_info[:NUMBER] = preq
+      fn_preq_rel_strat_info[:ITEM] = item
+      fn_preq_rel_strat_info[:REL_CODE] = rel_code
+      
+      fn_preq_rel_strat_info.invoke
+
+      #-- Execute conversions for returned tables to a designated list (array)
+      preq_gen_release_info = get_object_list(fn_preq_rel_strat_info[:GENERAL_RELEASE_INFO], PreqGenReleaseInfo.to_s)
+      preq_release_prerequisites = get_object_list(fn_preq_rel_strat_info[:RELEASE_PREREQUISITES], PreqReleasePrerequisites.to_s)
+      preq_release_posted = get_object_list(fn_preq_rel_strat_info[:RELEASE_ALREADY_POSTED], PreqReleasePosted.to_s)
+      preq_release_final = get_object_list(fn_preq_rel_strat_info[:RELEASE_FINAL], PreqReleaseFinal.to_s)
+      tb_return = get_object_list(fn_preq_rel_strat_info[:RETURN], Return.to_s)
+
+      retcode = tb_return.detect{|r| r.type == 'E'} 
+
+      if retcode
+        api_return_error(retcode)
+      else
+        api_return_success({
+          preq_gen_release_info: preq_gen_release_info,
+          preq_release_prerequisites: preq_release_prerequisites,
+          preq_release_posted: preq_release_posted,
+          preq_release_final: preq_release_final,
+          tb_return: tb_return,
+        })
+      end
+    end
+
+    def preq_release(preq = 0, rel_code = "", no_commit="", item="00000", use_exceptions="")
+      #Validate if will release by item ou general
+      if item == "00000" or item == nil or item.empty?
+        #-- Execute BAPI_REQUISITION_RELEASE_GEN
+        fn_preq_exec_release = @conn.get_function('BAPI_REQUISITION_RELEASE_GEN')
+        fn_preq_exec_release = fn_preq_exec_release.get_function_call
+      else
+        #-- Execute BAPI_REQUISITION_RELEASE
+        fn_preq_exec_release = @conn.get_function('BAPI_REQUISITION_RELEASE')
+        fn_preq_exec_release = fn_preq_exec_release.get_function_call
+        fn_preq_exec_release[:ITEM] = item
+        fn_preq_exec_release[:USE_EXCEPTIONS] = use_exceptions
+      end
+
+      fn_preq_exec_release[:NUMBER] = preq
+      fn_preq_exec_release[:REL_CODE] = rel_code
+      fn_preq_exec_release[:NO_COMMIT_WORK] = no_commit
+
+      fn_preq_exec_release.invoke
+
+      tb_return = get_object_list(fn_preq_exec_release[:RETURN], Return.to_s)
+
+      retcode = tb_return.detect{|r| r.type == 'E'} 
+
+      if retcode
+        api_return_error(retcode)
+      else
+        api_return_success({
+          status_new: fn_preq_exec_release[:REL_STATUS_NEW],
+          indicator_new: fn_preq_exec_release[:REL_INDICATOR_NEW],
+          tb_return: tb_return,
+        })
+      end
+    end
+
+    def po_detail(po = 0)
+      []
+    end
+
+    def po_release_strategy_info(po = 1)
+      []
+    end
+
+    # Performs SAP Authority check on a certain authorization
+    # object. For more details on SAP authorization, 
+    # this link will provide good details:
+    # * https://www.sdn.sap.com/irj/scn/index?rid=/library/uuid/a92195a9-0b01-0010-909c-f330ea4a585c&overridelayout=true
+    # * https://blogs.sap.com/2020/11/14/some-important-information-about-sap-authorization-objects/
+    # @param user [String] SAP userid for which authorization will be performed
+    # @param auth_object [String] Authorization object to be checked in SAP
+    # @param field [String] Authorization field checked within the authorization object
+    # @param value [String] Authorization value to be checked. (i.e. 01 for creation, 02 for change, XX for release code)
+    def authority_check(user, auth_object, field, value)
+      #-- Execute AUTHORITY_CHECK
+      function = @conn.get_function('AUTHORITY_CHECK')
+      fun_call = function.get_function_call
+      
+      fun_call[:USER] = user
+      fun_call[:OBJECT] = auth_object
+      fun_call[:FIELD1] = field
+      fun_call[:VALUE1] = value
+
+      begin
+        fun_call.invoke
+      rescue Exception => ex
+        if ex.to_s.include?('USER_IS_AUTHORIZED')
+          api_return(0,'Authorized');
+        else
+          api_return(8,'User is not authorized.')
         end
-        list.push(preq)
       end
 
-      list
+    end
+
+    def api_return_success(obj=nil )
+      UtilHelper.api_return(0, 'Success!', obj)
+    end
+
+    def api_return_error(obj={}, exception=nil)
+      UtilHelper.api_return(8, 'Error.', obj, exception)
+    end
+
+    def api_return(rc=0, message ='', obj=nil, exception=nil )
+      UtilHelper.api_return(rc, message, obj, exception)
     end
 
     private

data/lib/rnsap_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'yaml'
+require_relative '../lib/rnsap'
+require_relative '../lib/preq_detail/preq_item'
+
+describe RnSap::Sap do
+  let(:params) do
+    file = File.expand_path(File.join(File.dirname(__FILE__), '..', 'secrets.yml'))
+    YAML.safe_load(File.read(file))
+  end
+
+  let(:logon_info) do
+    { 'user' => params['user'],
+      'passwd' => params['password'],
+      'trace' => params['trace'],
+      'client' => params['client'],
+      'ashost' => params['ashost'],
+      'sysnr' => params['sysnr'] }
+  end
+
+  let(:test_data) do
+    file = File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_data.yml'))
+    YAML.safe_load(File.read(file))
+  end
+
+  let(:conn) do
+    RnSap::Sap.new(logon_info)
+  end
+
+  context 'Based on connection available parameters' do
+    it 'connects to SAP' do
+      expect(conn).not_to be_nil
+    end
+  end
+
+  context 'Reads table information from SAP' do
+    it 'gets at least one vendor' do
+      list = conn.read_table('lfa1', %w[NAME1 LIFNR LAND1])
+      expect(list.count).to be > 0
+    end
+    it 'gets at least one Raw material' do
+      list = conn.read_table('mara', %w[matnr ernam], ["MTART = 'ROH'"])
+      expect(list.count).to be > 0
+    end
+
+    it 'gets a two Raw materials skipping the first in the database' do
+      list = conn.read_table({ name: 'mara', fields: %w[matnr ernam], clauses: ["MTART = 'ROH'"], row_skip: 1, row_count: 2 })
+      expect(list.count).to eq(2)
+    end
+  end
+
+  context 'Gets information from a Purchase Requisition' do
+    it 'Obtains details from purchase requisition' do
+      pr = test_data['preqs']['number']
+      puts "    -> Pesquisando P.Req: #{pr}"
+      details = conn.preq_detail(pr)
+
+      expect(details).not_to be_nil 
+      expect(details.class).to be(Hash)
+    end
+
+    it 'gets purchase requisition Release Strategy info' do
+      pr = test_data['preqs']['number']
+      details = conn.preq_release_strategy_info(pr)
+
+      expect(details).not_to be_nil 
+      expect(details.class).to be(Hash)
+    end
+  end
+
+  context 'Gets information from a Purchase Order' do
+    it 'Obtains details from purchase requisition' do
+      po = test_data['po']['number']
+      puts "    -> Pesquisando P.Order: #{po}"
+      details = conn.po_detail(po)
+
+      expect(details).not_to be_nil 
+      expect(details.class).to be(Array)
+    end
+
+    it 'gets purchase requisition Release Strategy info' do
+      po = test_data['po']['number']
+      details = conn.po_release_strategy_info(po)
+
+      expect(details).not_to be_nil 
+      expect(details.class).to be(Array)
+    end
+  end
+
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rnsap
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.8
 platform: ruby
 authors:
 - Rogerio Nascimento
@@ -45,7 +45,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/helper/rfc_helper.rb
+- lib/helper/util_helper.rb
+- lib/preq_detail/preq_acct_assignment.rb
+- lib/preq_detail/preq_contract_limits.rb
+- lib/preq_detail/preq_item.rb
+- lib/preq_detail/preq_limits.rb
+- lib/preq_detail/preq_services.rb
+- lib/preq_detail/preq_services_texts.rb
+- lib/preq_detail/preq_srv_accass_values.rb
+- lib/preq_detail/preq_text.rb
+- lib/preq_release_info/preq_gen_release_info.rb
+- lib/preq_release_info/preq_release_final.rb
+- lib/preq_release_info/preq_release_posted.rb
+- lib/preq_release_info/preq_release_prerequisites.rb
+- lib/read_table/table_column.rb
+- lib/return.rb
 - lib/rnsap.rb
+- lib/rnsap_spec.rb
 homepage: https://github.com/rnasc/rnsap
 licenses:
 - MIT