blackstack-core 1.2.28 → 1.2.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf281a3482c533e39b0f6d9a97372b826f18c08ed4ba391c78905bb49ed627ac
-  data.tar.gz: 83f6252605460480b216ecfe80a9b314ee33a943f163f10bf4efa6797595464f
+  metadata.gz: 6319585aa6afd55c363b5b7e59acc4afe407a741d22306831b3c5cef48724c76
+  data.tar.gz: 2d7e134595693737c9beb9cfabaf05ac502a7631a79bafbbb5b60ae03cd90512
 SHA512:
-  metadata.gz: f1338a61f396612dcd83e5d88446c6818051e4231a22b2d10f14d39fedba49386d21ceba4b1779bd728f0c09376ec6b3e73a0e3db8e6c03740348d5922befbe6
-  data.tar.gz: 28e3bed3a23f02fba73e91cb0fdd6aa607b43e340027c4e649010e06066e66fdfa50f3e50e9e2404b4be014d4f10f7bb6dbc70c21e48f341fb32a42c565b4f59
+  metadata.gz: f6d4de6e017a5871b60a1d1f3a987e9233ac2df83700ba3d794ddf843f5ffd3ec30de9efd4544eb4415e4f9381898826dd80647d8250c89d6d0f3001c38355ed
+  data.tar.gz: 3e8c922cb98658ef9677b4e5badb5e4592f112b71d6a76d79ac59361f19cfbb0ad94558bbaea5a6ad99493a876eda33f224ccdde11e0cebc4d4e09716a70c0a7

data/lib/functions.rb

@@ -20,7 +20,7 @@ module BlackStack
 
         def self.api_url
             @@api_url
-        end 
+        end
 
         def self.api_port
             @@api_port
@@ -37,7 +37,7 @@ module BlackStack
         def self.classes
             @@classes
         end # def self.classes
-        
+
         def self.set_client(
             api_key: ,
             api_url: ,
@@ -60,7 +60,7 @@ module BlackStack
         end # def self.set_server
 
         def self.post(
-            endpoint: , 
+            endpoint: ,
             params: {}
         )
             begin
@@ -84,7 +84,7 @@ module BlackStack
 
     # Base class.
     # List of methods you have to overload if you develop a profile type.
-    # 
+    #
     class Base
         # object json descriptor
         attr_accessor :desc
@@ -120,10 +120,10 @@ module BlackStack
 
 
         # Get array of hash descriptor of profile.
-        # 
-        # Parameters: 
+        #
+        # Parameters:
         # - id_account: guid. Id of the account to bring the profiles. Sysowner must provide the id_account for getting an account value. For non sysowner it is assigned to his account.
-        # - promiscuous: boolean. It works only for Sysowner. If true, it will bring all non-deleted rows. If false, it will bring only rows matching id_profile. Default: false.
+        # - promiscuous: boolean. It works only for Sysowner. If true, it will bring all non-deleted rows, including the ones that are not owned by Sysowner. If false, it will bring only rows matching id_profile. Default: false.
         # - page: integer. Page number.
         # - limit: integer. Number of profiles per page.
         # - params: hash. Additional filter parameters used by the specific child class.
@@ -147,8 +147,8 @@ module BlackStack
         end # def self.base
 
         # Get array of hash descriptors of profiles.
-        # 
-        # Parameters: 
+        #
+        # Parameters:
         # - id: guid. Id of the profile to bring.
         #
         def self.count
@@ -163,8 +163,8 @@ module BlackStack
         end # def self.count
 
         # Get array of hash descriptors of profiles.
-        # 
-        # Parameters: 
+        #
+        # Parameters:
         # - id: guid. Id of the profile to bring.
         #
         def self.get(id)
@@ -179,6 +179,23 @@ module BlackStack
             return self.new(ret['result']).child_class_instance
         end # def self.get
 
+        # Delete object.
+        #
+        # Parameters:
+        # - id: guid. Id of the profile to bring.
+        #
+        def self.delete(id)
+            params = {}
+            params['id'] = id
+            params['backtrace'] = BlackStack::API.backtrace
+            ret = BlackStack::API.post(
+                endpoint: "#{self.object_name}/delete",
+                params: params
+            )
+            raise "Error calling get endpoint: #{ret['status']}" if ret['status'] != 'success'
+            return self.new(ret['result']).child_class_instance
+        end # def self.get
+
         # Submit a hash descriptor to the server for an update
         #
         def self.update(desc)
@@ -248,6 +265,20 @@ module BlackStack
             return ret['result'] == {} ? nil : self.new(ret['result']).child_class_instance
         end # def self.upsert
 
+        # Submit a hash descriptor to the server for an upsert
+        #
+        def self.upsert2(desc)
+          params = {}
+          params['desc'] = desc
+          params['backtrace'] = BlackStack::API.backtrace
+          ret = BlackStack::API.post(
+              endpoint: "#{self.object_name}/upsert2",
+              params: params
+          )
+          raise "Error calling upsert endpoint: #{ret['status']}" if ret['status'] != 'success'
+          return ret['result'] == {} ? nil : self.new(ret['result']).child_class_instance
+        end # def self.upsert
+
         # Submit a hash descriptor to the server for an upsert
         #
         def upsert
@@ -266,7 +297,7 @@ module BlackStack
             ret = nil
             # getting the HTML
             zyte = ZyteClient.new(key: api_key)
-            html = zyte.extract(url: url, options: options, data_filename: data_filename) 
+            html = zyte.extract(url: url, options: options, data_filename: data_filename)
             # return the URL of the file in the cloud
             return html
         end # def zyte_html
@@ -284,7 +315,7 @@ module BlackStack
         def zyte_snapshot(url, api_key:, options:, data_filename:, dropbox_folder:nil, retry_times: 3)
             # "The garbage character must be due to the 520 error code which was caused on the second request."
             garbage = "\x9E\xE9e"
-            
+
             ret = nil
             raise "Either dropbox_folder parameter or self.desc['id_account'] are required." if dropbox_folder.nil? && self.desc['id_account'].nil?
             dropbox_folder = self.desc['id_account'] if dropbox_folder.nil?
@@ -302,7 +333,7 @@ module BlackStack
             try = 0
             html = garbage
             while try < retry_times && html == garbage
-                html = zyte.extract(url: url, options: options, data_filename: data_filename) 
+                html = zyte.extract(url: url, options: options, data_filename: data_filename)
                 try += 1
             end
             # save the HTML in the local file in /tmp
@@ -318,9 +349,9 @@ module BlackStack
 
     end # class Base
 
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   # PRY Supporting Functions
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   module Debugging
     @@allow_breakpoints = false
     @@verbose = false
@@ -341,7 +372,7 @@ module BlackStack
           print "Breakpoint are not allowed" if @@verbose
         end
 
-        Binding.class_eval do 
+        Binding.class_eval do
           alias_method :old_pry, :pry
           define_method :pry, new_pry
         end
@@ -349,21 +380,21 @@ module BlackStack
     end
   end
 
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   # OCRA Supporting Functions
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   module OCRA
 		# OCRA files run into a temp folder, where the script is unpacked.
-		# 
+		#
 		# This function is useful to require a configuration file when the
 		# script is running inside an OCRA temp folder, since the local folder
 		# of the running command is not the filder where the exe file is hosted.
-		# 
-		# More information: 
+		#
+		# More information:
 		#	* https://stackoverflow.com/questions/1937743/how-to-get-the-current-working-directorys-absolute-path-from-irb
 		# * https://stackoverflow.com/questions/8577223/ruby-get-the-file-being-executed
 		# * https://stackoverflow.com/questions/7399882/ruby-getting-path-from-pathfilename/7400057
-		# 
+		#
 		def self.require_in_working_path(filename, path, show_path_info=false)
 			puts '' if show_path_info
 			path = File.expand_path File.dirname(path)
@@ -375,13 +406,13 @@ module BlackStack
 		end
 	end # module OCRA
 
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   # DateTime Functions
-  # ----------------------------------------------------------------------------------------- 
-  module DateTime    
-    # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
+  module DateTime
+    # -----------------------------------------------------------------------------------------
     # Encoding
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Encoding
       # Convierte un objeto date-time a un string con formato sql-datetime (yyyy-mm-dd hh:mm:ss).
       def self.datetime_to_sql(o)
@@ -389,50 +420,50 @@ module BlackStack
       end
     end # module Encode
 
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     # Miscelaneous
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Misc
       def self.datetime_values_check(year,month,day,hour,minute,second)
         if (year.to_i<1900 || year.to_i>=2100)
           return false
         end
-      
+
         if (month.to_i<1 || month.to_i>12)
           return false
         end
-      
+
         # TODO: Considerar la cantidad de dias de cada mes, y los anios biciestos. Buscar alguna funcion existente.
         if (day.to_i<1 || day.to_i>31)
           return false
         end
-      
+
         if (hour.to_i<0 || hour.to_i>23)
           return false
         end
-      
+
         if (minute.to_i<0 || minute.to_i>59)
           return false
         end
-      
+
         if (second.to_i<0 || second.to_i>59)
           return false
         end
-      
+
         return true
       end # datetime_values_check
     end # module Misc
   end # module DateTime
 
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   # Numeric Functions
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   module Number
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     # Encoding
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Encoding
-      # Converts number to a string with a format like xx,xxx,xxx.xxxx 
+      # Converts number to a string with a format like xx,xxx,xxx.xxxx
       # number: it may be int or float
       def self.format_with_separator(number)
         whole_part, decimal_part = number.to_s.split('.')
@@ -444,7 +475,7 @@ module BlackStack
       # Ejemplo: "4 hours, 30 minutes"
       # Ejemplo: "3 days, 4 hour"
       def self.encode_minutes(n)
-        # TODO: validar que n sea un entero mayor a 0      
+        # TODO: validar que n sea un entero mayor a 0
         if (n<0)
           return "?"
         end
@@ -459,13 +490,13 @@ module BlackStack
     end # module Encode
   end # module Number
 
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   # String Functions
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   module Strings
 
     GUID_SIZE                     = 36
-    MATCH_PASSWORD                = /(?=.*[a-zA-Z])(?=.*[0-9]).{6,}/ 
+    MATCH_PASSWORD                = /(?=.*[a-zA-Z])(?=.*[0-9]).{6,}/
     MATCH_GUID                    = /{?[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]}?/
     MATCH_FILENAME                = /[\w\-\_\.]+/
     MATCH_EMAIL                   = /[A-Z0-9._%a-z\-]+@(?:[A-Z0-9a-z\-]+\.)+[A-Za-z]{1,25}/
@@ -474,7 +505,7 @@ module BlackStack
     MATCH_PHONE                   = /(?:\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}/
 
     # Note: MATCH_URL gets the URL up to '?', but it doesn't retrieves the parameters.
-    # Exmaple: 
+    # Exmaple:
     #   https://foo.com/bar?param1=value1&param2=value2 --> https://foo.com/bar?
     #   https://foo.com/bar/?param1=value1&param2=value2 --> https://foo.com/bar/?
     MATCH_URL                     = /(https?:\/\/)?([\da-z\.-]+)([\.\:])([\da-z]{2,6})([\/[\da-z\.\-]+]*[\da-z])(\/)?(\?)?/i
@@ -484,32 +515,32 @@ module BlackStack
     MATCH_CONTENT_SPINNING        = /{[^}]+}/
     MATCH_SPINNED_TEXT            = /code me/ # TODO: define this regex for the issue #1226
 
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     # Fuzzy String Comparsion Functions: How similar are 2 strings that are not exactly equal.
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module SQL
       def self.string_to_sql_string(s)
         #return s.force_encoding("UTF-8").gsub("'", "''").to_s
         return s.gsub("'", "''").to_s
       end
     end
-    
-    # ----------------------------------------------------------------------------------------- 
+
+    # -----------------------------------------------------------------------------------------
     # Fuzzy String Comparsion Functions: How similar are 2 strings that are not exactly equal.
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Comparing
       # retorna 0 si los strings son iguales
       # https://stackoverflow.com/questions/16323571/measure-the-distance-between-two-strings-with-ruby
-      def self.levenshtein_distance(s, t)  
+      def self.levenshtein_distance(s, t)
         s.downcase!
         t.downcase!
-      
+
         m = s.length
         n = t.length
         return m if n == 0
         return n if m == 0
         d = Array.new(m+1) {Array.new(n+1)}
-      
+
         (0..m).each {|i| d[i][0] = i}
         (0..n).each {|j| d[0][j] = j}
         (1..n).each do |j|
@@ -526,7 +557,7 @@ module BlackStack
         end
         d[m][n]
       end
-      
+
       # retorna la cantidad de palabras con mas de 3 caracteres que se encuentran en el parametro s
       def self.max_sardi_distance(s)
         s.downcase!
@@ -541,14 +572,14 @@ module BlackStack
         }
         n
       end
-      
+
       # retorna la cantidad de palabras con mas de 3 caracteres del parametro s que se encuentran en el parametro t
       def self.sardi_distance(s, t)
         s.downcase!
         t.downcase!
         s.gsub!(/-/,' ')
         t.gsub!(/-/,' ')
-        max_distance = max_sardi_distance(s)  
+        max_distance = max_sardi_distance(s)
         ss = s.scan(/\b([a-z]+)\b/)
         tt = t.scan(/\b([a-z]+)\b/)
         n = 0
@@ -563,20 +594,20 @@ module BlackStack
         return max_distance - n
       end
     end # module Comparing
-    
-    # ----------------------------------------------------------------------------------------- 
+
+    # -----------------------------------------------------------------------------------------
     # Encoding: Make a string nice to be shown into an HTML string.
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Encoding
       # Then it makes it compatible with UTF-8.
-      # More details here: https://bitbucket.org/leandro_sardi/blackstack/issues/961  
+      # More details here: https://bitbucket.org/leandro_sardi/blackstack/issues/961
       def self.encode_string(s)
         s.encode("UTF-8")
       end
-  
+
       # Escape the string to be shown into an HTML screen.
       # Then it makes it compatible with UTF-8.
-      # More details here: https://bitbucket.org/leandro_sardi/blackstack/issues/961  
+      # More details here: https://bitbucket.org/leandro_sardi/blackstack/issues/961
       def self.encode_html(s)
         encode_string(CGI.escapeHTML(s.to_s))
       end
@@ -584,9 +615,9 @@ module BlackStack
       # Generates a description string from an exception object.
       # Eescapes the string to be shown into an HTML screen.
       # Makes it compatible with UTF-8.
-      # More details here: https://bitbucket.org/leandro_sardi/blackstack/issues/961  
+      # More details here: https://bitbucket.org/leandro_sardi/blackstack/issues/961
       def self.encode_exception(e, include_backtrace=true)
-        ret = encode_html(e.to_s) 
+        ret = encode_html(e.to_s)
         if (include_backtrace == true)
           e.backtrace.each { |s|
             ret += "<br/>" + encode_html(s)
@@ -596,8 +627,8 @@ module BlackStack
       end
 
       # Returns a string with a description of a period of time, to be shown in the screen.
-      # period: it may be 'H', 'D', 'W', 'M', 'Y'  
-      # units: it is a positive integer  
+      # period: it may be 'H', 'D', 'W', 'M', 'Y'
+      # units: it is a positive integer
       def self.encode_period(period, units)
         s = "Last "
         s += units.to_i.to_s + " " if units.to_i > 1
@@ -626,87 +657,87 @@ module BlackStack
 
     end # module Encoding
 
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     # DateTime
-    # ----------------------------------------------------------------------------------------- 
-    module DateTime     
+    # -----------------------------------------------------------------------------------------
+    module DateTime
       # Check the string has the format yyyymmddhhmmss.
       # => Return true if success. Otherwise, return false.
       # => Year cannot be lower than 1900.
-      # => Year cannot be higher or equal than 2100. 
+      # => Year cannot be higher or equal than 2100.
       def self.datetime_api_check(s)
-        return false if (s.size!=14)      
+        return false if (s.size!=14)
         year = s[0..3]
         month = s[4..5]
-        day = s[6..7] 
-        hour = s[8..9] 
-        minute = s[10..11] 
-        second = s[12..13]       
+        day = s[6..7]
+        hour = s[8..9]
+        minute = s[10..11]
+        second = s[12..13]
         BlackStack::DateTime::Misc::datetime_values_check(year,month,day,hour,minute,second)
       end # def datetime_api_check
 
       # Check the string has the format yyyy-mm-dd hh:mm:ss.
       # => Return true if success. Otherwise, return false.
       # => Year cannot be lower than 1900.
-      # => Year cannot be higher or equal than 2100. 
+      # => Year cannot be higher or equal than 2100.
       def self.datetime_sql_check(s)
         return false if (s.size!=19)
         year = s[0..3]
         month = s[5..6]
-        day = s[8..9] 
-        hour = s[11..12] 
-        minute = s[14..15] 
-        second = s[17..18] 
+        day = s[8..9]
+        hour = s[11..12]
+        minute = s[14..15]
+        second = s[17..18]
         BlackStack::DateTime::Misc::datetime_values_check(year,month,day,hour,minute,second)
       end # def datetime_sql_check
-      
+
       # Convierte un string con formato api-datatime (yyyymmddhhmmss) a un string con formato sql-datetime (yyyy-mm-dd hh:mm:ss).
       def self.datetime_api_to_sql(s)
         raise "Wrong Api DataTime Format." if (datetime_api_check(s)==false)
         year = s[0..3]
         month = s[4..5]
-        day = s[6..7] 
-        hour = s[8..9] 
-        minute = s[10..11] 
-        second = s[12..13] 
-        ret = "#{year}-#{month}-#{day} #{hour}:#{minute}:#{second}" 
+        day = s[6..7]
+        hour = s[8..9]
+        minute = s[10..11]
+        second = s[12..13]
+        ret = "#{year}-#{month}-#{day} #{hour}:#{minute}:#{second}"
         return ret
-      end # def datetime_api_to_sql 
-      
+      end # def datetime_api_to_sql
+
       # Convierte un string con formato sql-datatime a un string con formato sql-datetime.
       def self.datetime_sql_to_api(s)
         raise "Wrong SQL DataTime Format." if (datetime_sql_check(s)==false)
         year = s[0..3]
         month = s[5..6]
-        day = s[8..9] 
-        hour = s[11..12] 
-        minute = s[14..15] 
-        second = s[17..18] 
-        ret = "#{year}#{month}#{day}#{hour}#{minute}#{second}" 
+        day = s[8..9]
+        hour = s[11..12]
+        minute = s[14..15]
+        second = s[17..18]
+        ret = "#{year}#{month}#{day}#{hour}#{minute}#{second}"
         return ret
       end # def datetime_sql_to_api
     end # module DateTime
 
 
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     # Spinning
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Spinning
       # Esta funcion retorna una variacion al azar del texto que se pasa.
       # Esta funcion se ocupa de dividir el texto en partes, para eviar el error "too big to product" que arroja la libraría.
       def self.random_spinning_variation(text)
         ret = text
-        
+
         text.scan(MATCH_CONTENT_SPINNING).each { |s|
           a = ContentSpinning.new(s).spin
           rep = a[rand(a.size)]
           ret = ret.gsub(s, rep)
           a = nil
         }
-      
+
         return ret
       end
-      
+
       # retorna true si la sintaxis del texto spineado es correcta
       # caso contrario retorna false
       # no soporta spinnings anidados. ejemplo: {my|our|{a car of mine}}
@@ -714,16 +745,16 @@ module BlackStack
         # valido que exste
         n = 0
         s.split('').each { |c|
-          n+=1 if c=='{'  
+          n+=1 if c=='{'
           n-=1 if c=='}'
           if n!=0 && n!=1
             #raise "Closing spining char '}' with not previous opening spining char '{'." if n<0
             #raise "Opening spining char '{' inside another spining block." if n>1
             return false if n<0 # Closing spining char '}' with not previous opening spining char '{'.
             return false if n>1 # Opening spining char '{' inside another spining block.
-          end  
+          end
         }
-              
+
         return false if n!=0
 =begin
         # obtengo cada uno de los spinnings
@@ -731,21 +762,21 @@ module BlackStack
           a = x.split('|')
           raise "No variations delimited by '|' inside spinning block." if a.size <= 1
         }
-=end        
+=end
         true
       end
-      
+
       # returns true if the text is spinned.
       # otherwise, returns false.
       def self.spintax?(s)
         s.scan(MATCH_CONTENT_SPINNING).size > 0
       end
     end # module Spinning
-    
-    
-    # ----------------------------------------------------------------------------------------- 
+
+
+    # -----------------------------------------------------------------------------------------
     # Miscelaneus
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Misc
       # make a Ruby string safe for a filesystem.
       # References:
@@ -756,7 +787,7 @@ module BlackStack
           # NOTE: File.basename doesn't work right with Windows paths on Unix
           # get only the filename, not the whole path
           name.gsub!(/^.*(\\|\/)/, '')
-      
+
           # Strip out the non-ascii character
           name.gsub!(/[^0-9A-Za-z.\-]/, '_')
         end
@@ -765,9 +796,9 @@ module BlackStack
     end # module Misc
 
 
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     # Email Appending Functions
-    # ----------------------------------------------------------------------------------------- 
+    # -----------------------------------------------------------------------------------------
     module Appending
       APPEND_PATTERN_FNAME_DOT_LNAME = 0
       APPEND_PATTERN_FNAME = 1
@@ -775,7 +806,7 @@ module BlackStack
       APPEND_PATTERN_F_LNAME = 3
       APPEND_PATTERN_F_DOT_LNAME = 4
 
-      # 
+      #
       def self.name_pattern(pattern, fname, lname)
         if (pattern==APPEND_PATTERN_FNAME_DOT_LNAME)
           return "#{fname}.#{lname}"
@@ -792,13 +823,13 @@ module BlackStack
         end
       end
 
-      # 
+      #
       def self.get_email_variations(first_name, last_name, domain, is_a_big_company)
         variations = Array.new
         variations << first_name + "." + last_name + "@" + domain
         variations << first_name[0] + last_name + "@" + domain
         variations << first_name + "_" + last_name + "@" + domain
-        variations << first_name[0] + "." + last_name + "@" + domain      
+        variations << first_name[0] + "." + last_name + "@" + domain
         if (is_a_big_company == false)
           variations << last_name + "@" + domain
           variations << first_name + "@" + domain
@@ -821,20 +852,24 @@ module BlackStack
       end
     end # module Appending
   end # module String
-  
-  # ----------------------------------------------------------------------------------------- 
+
+  # -----------------------------------------------------------------------------------------
   # Network
-  # ----------------------------------------------------------------------------------------- 
+  # -----------------------------------------------------------------------------------------
   module Netting
     CALL_METHOD_GET = 'get'
     CALL_METHOD_POST = 'post'
     DEFAULT_SSL_VERIFY_MODE = OpenSSL::SSL::VERIFY_NONE
     SUCCESS = 'success'
-    
-    @@lockfiles = []   
+
+    DEFAULT_OPEN_TIMEOUT  = 10    # seconds to wait for the initial connection
+    DEFAULT_READ_TIMEOUT  = 30    # seconds to wait for each response
+    DEFAULT_RETRY_ATTEMPTS = 3
+
+    @@lockfiles = []
 
     @@max_api_call_channels = 0 # 0 means infinite
-    
+
     def self.max_api_call_channels()
       @@max_api_call_channels
     end
@@ -846,7 +881,7 @@ module BlackStack
     def self.set(h)
       @@max_api_call_channels = h[:max_api_call_channels]
       @@lockfiles = []
-      
+
       i = 0
       while i<@@max_api_call_channels
         @@lockfiles << File.open("./apicall.channel_#{i.to_s}.lock", "w")
@@ -857,18 +892,18 @@ module BlackStack
 
     class ApiCallException < StandardError
       attr_accessor :description
-      
+
       def initialize(s)
         self.description = s
       end
-      
+
       def to_s
         self.description
       end
     end
-    
+
     # New call_get
-    def self.call_get(url, params = {}, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections=true) 
+    def self.call_get(url, params = {}, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections=true)
       uri = URI(url)
       uri.query = URI.encode_www_form(params)
       Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https', :verify_mode => ssl_verify_mode) do |http|
@@ -883,7 +918,7 @@ module BlackStack
         end
       end
     end
-    
+
     # Call the API and return th result.
     #
     # Unlike `Net::HTTP::Post`, this method support complex json descriptors in order to submit complex data strucutres to access points.
@@ -891,37 +926,88 @@ module BlackStack
     #
     # url: valid internet address
     # body: hash of body to attach in the call
-    # ssl_verify_mode: you can disabele SSL verification here. 
+    # ssl_verify_mode: you can disabele SSL verification here.
     # max_channels: this method use lockfiles to prevent an excesive number of API calls from each datacenter. There is not allowed more simultaneous calls than max_channels.
-    # 
+    #
     # TODO: parameter support_redirections has been deprecated.
     #
-    def self.call_post(url, body = {}, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections=true)
-      # issue: https://github.com/leandrosardi/mysaas/issues/59  
-      #
-      # when ruby pushes hash of hashes (or hash of arrays), all values are converted into strings.
-      # and arrays are mapped to the last element only.
-      #
-      # the solution is to convert each element of the hash into a string using `.to_json` method.
-      # 
-      # references: 
-      # - https://stackoverflow.com/questions/1667630/how-do-i-convert-a-string-object-into-a-hash-object
-      # - https://stackoverflow.com/questions/67572866/how-to-build-complex-json-to-post-to-a-web-service-with-rails-5-2-and-faraday-ge
-      # 
-      # iterate the keys of the hash
-      # 
-      params = {} # not needed for post calls to access points
-      path = URI::parse(url).path
-      domain = url.gsub(/#{Regexp.escape(path)}/, '')
-
-      conn = Faraday.new(domain, :ssl=>{:verify=>ssl_verify_mode!=OpenSSL::SSL::VERIFY_NONE})
-      ret = conn.post(path, params) do |req|
-        req.body = body.to_json
-        req.headers['Content-Type'] = 'application/json'
-        req.headers['Accept'] =  'application/json'
+    def self.call_post(url,
+      body = {},
+      ssl_verify_mode = BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE,
+      support_redirections = true)
+
+      max_redirects = 5
+      attempts      = 0
+
+      while attempts < DEFAULT_RETRY_ATTEMPTS
+        begin
+          uri = URI.parse(url)
+
+          # Create a basic Faraday connection
+          conn = Faraday.new(
+            url: "#{uri.scheme}://#{uri.host}", 
+            ssl: { verify: ssl_verify_mode != OpenSSL::SSL::VERIFY_NONE },
+            request: {
+              open_timeout: DEFAULT_OPEN_TIMEOUT,
+              timeout:      DEFAULT_READ_TIMEOUT
+            }
+          ) do |f|
+            f.adapter Faraday.default_adapter
+          end
+
+          # Perform the initial POST request
+          response = conn.post(uri.path) do |req|
+            req.body = JSON.generate(body) # Manually serialize to JSON
+            req.headers['Content-Type'] = 'application/json'
+            req.headers['Accept']       = 'application/json'
+          end
+
+          # Manually handle HTTP redirects if requested
+          redirect_count = 0
+          while support_redirections &&
+            response.status.between?(300, 399) &&
+            response.headers['location'] &&
+            redirect_count < max_redirects
+
+            redirect_count += 1
+            new_url = URI.join(url, response.headers['location']).to_s
+
+            # Update `url` for the next iteration
+            url = new_url
+            uri = URI.parse(new_url)
+
+            response = conn.post(uri.path) do |req|
+              req.body = JSON.generate(body)
+              req.headers['Content-Type'] = 'application/json'
+              req.headers['Accept']       = 'application/json'
+            end
+          end
+
+          # Raise an error if the final response is not 2xx
+          unless response.success?
+            raise "HTTP #{response.status}: #{response.body}"
+          end
+
+          # If all is good, return the Faraday response object
+          return response
+
+        rescue Errno::ETIMEDOUT, Timeout::Error, Faraday::ConnectionFailed => e
+          # Basic retry logic for transient network errors
+          attempts += 1
+          if attempts < DEFAULT_RETRY_ATTEMPTS
+            sleep_time = 2**attempts
+            sleep(sleep_time)  # Exponential backoff
+            retry
+          else
+            # Too many failures, re-raise
+            raise e
+          end
+        rescue => e
+          # For any other error, just re-raise
+          raise e
+        end
       end
-      ret
-    end
+    end # def self.call_post
 
     # TODO: deprecated
     def self.api_call(url, params={}, method=BlackStack::Netting::CALL_METHOD_POST, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, max_retries=5)
@@ -939,7 +1025,7 @@ module BlackStack
           if (parsed['status']==BlackStack::Netting::SUCCESS)
             bSuccess = true
           else
-            sError = "Status: #{parsed['status'].to_s}. Description: #{parsed['value'].to_s}." 
+            sError = "Status: #{parsed['status'].to_s}. Description: #{parsed['value'].to_s}."
           end
         rescue Errno::ECONNREFUSED => e
           sError = "Errno::ECONNREFUSED:" + e.to_console
@@ -947,7 +1033,7 @@ module BlackStack
           sError = "Exception:" + e2.to_console
         end
       end # while
-    
+
       if (bSuccess==false)
         raise "#{sError}"
       end
@@ -958,7 +1044,7 @@ module BlackStack
     # to: must be a valid path to a folder.
     def self.download(url, to)
       uri = URI(url)
-      domain = uri.host.start_with?('www.') ? uri.host[4..-1] : uri.host    
+      domain = uri.host.start_with?('www.') ? uri.host[4..-1] : uri.host
       path = uri.path
       filename = path.split("/").last
       Net::HTTP.start(domain) do |http|
@@ -970,7 +1056,7 @@ module BlackStack
     end
 
     # Return the extension of the last path into an URL.
-    # Example: get_url_extension("http://connect.data.com/sitemap_index.xml?foo_param=foo_value") => ".xml"  
+    # Example: get_url_extension("http://connect.data.com/sitemap_index.xml?foo_param=foo_value") => ".xml"
     def self.get_url_extension(url)
       return File.extname(URI.parse(url).path.to_s)
     end
@@ -1011,12 +1097,12 @@ module BlackStack
         httpc = HTTPClient.new
         resp = httpc.get(url)
         res = resp.header['Location']
-        
+
         if res.size == 0
           uri = URI.parse(url)
           uri_params = CGI.parse(uri.query)
-          redirected_url = uri_params['url'][0]            
-          
+          redirected_url = uri_params['url'][0]
+
           if ( redirected_url != nil )
             res = redirected_url
           else
@@ -1040,25 +1126,25 @@ module BlackStack
       # => p = CGI::parse(URI.parse(url).query)
       # => La linea de abajo hace un gsbub que hace que esta url siga funcionando como busqueda de google, y ademas se posible parsearla.
       url = url.gsub("webhp#q=", "webhp?q=")
-    
+
       return CGI::parse(URI.parse(url).query)
     end
-    
+
     # Add a parameter to the url. It doesn't validate if the param already exists.
     def self.add_param(url, param_name, param_value)
       uri = URI(url)
       params = URI.decode_www_form(uri.query || '')
-      
+
       if (params.size==0)
         params << [param_name, param_value]
         uri.query = URI.encode_www_form(params)
         return uri.to_s
       else
         uri.query = URI.encode_www_form(params)
-        return uri.to_s + "&" + param_name + "=" + param_value    
+        return uri.to_s + "&" + param_name + "=" + param_value
       end
     end
-    
+
     # Changes the value of a parameter in the url. It doesn't validate if the param already exists.
     def self.change_param(url, param_name, param_value)
       uri = URI(url)
@@ -1068,10 +1154,10 @@ module BlackStack
       uri.query = URI.encode_www_form(params)
       uri.to_s
     end
-    
+
     # Change or add the value of a parameter in the url, depending if the parameter already exists or not.
     def self.set_param(url, param_name, param_value)
-      params = BlackStack::Netting::params(url) 
+      params = BlackStack::Netting::params(url)
       if ( params.has_key?(param_name) == true )
         newurl = BlackStack::Netting::change_param(url, param_name, param_value)
       else
@@ -1079,24 +1165,24 @@ module BlackStack
       end
       return newurl
     end
-    
+
     # get the domain from any url
     def self.getDomainFromUrl(url)
-      if (url !~ /^http:\/\//i && url !~ /^https:\/\//i) 
+      if (url !~ /^http:\/\//i && url !~ /^https:\/\//i)
         url = "http://#{url}"
       end
-      
+
       if (URI.parse(url).host == nil)
-        raise "Cannot get domain for #{url}" 
+        raise "Cannot get domain for #{url}"
       end
-    
+
       if (url.to_s.length>0)
         return URI.parse(url).host.sub(/^www\./, '')
       else
         return nil
       end
     end
-  
+
     def self.getDomainFromEmail(email)
       if email.email?
         return email.split("@").last
@@ -1104,35 +1190,35 @@ module BlackStack
         raise "getDomainFromEmail: Wrong email format."
       end
     end
-  
+
     def self.getWhoisDomains(domain, allow_heuristic_to_avoid_hosting_companies=false)
       a = Array.new
       c = Whois::Client.new
       r = c.lookup(domain)
-    
+
       res = r.to_s.scan(/Registrant Email: (#{BlackStack::Strings::MATCH_EMAIL})/).first
       if (res!=nil)
         a << BlackStack::Netting::getDomainFromEmail(res[0].downcase)
       end
-    
+
       res = r.to_s.scan(/Admin Email: (#{BlackStack::Strings::MATCH_EMAIL})/).first
       if (res!=nil)
         a << BlackStack::Netting::getDomainFromEmail(res[0].downcase)
       end
-    
+
       res = r.to_s.scan(/Tech Email: (#{BlackStack::Strings::MATCH_EMAIL})/).first
       if (res!=nil)
         a << BlackStack::Netting::getDomainFromEmail(res[0].downcase)
       end
-    
+
       # remover duplicados
       a = a.uniq
-    
-      # 
+
+      #
       if (allow_heuristic_to_avoid_hosting_companies==true)
         # TODO: develop this feature
       end
-    
+
       return a
     end
 
@@ -1160,11 +1246,11 @@ module BlackStack
       raise "Email #{value} is not valid" if !value.email?
       # extract the domain from the email
       domain = value.split('@').last
-      # 
+      #
       return domain=~/gmail\.com/ || domain=~/hotmail\.com/ || domain=~/outlook\.com/ || domain=~/yahoo\.com/ || domain=~/comcast\.com/ || domain=~/aol\.com/ || domain=~/msn\.com/ || domain=~/sbcglobal\.net/ ? true : false
     end
 
 
   end # module Netting
-  
+
 end # module BlackStack

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: blackstack-core
 version: !ruby/object:Gem::Version
-  version: 1.2.28
+  version: 1.2.30
 platform: ruby
 authors:
 - Leandro Daniel Sardi
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-06 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: content_spinning
@@ -86,7 +85,6 @@ homepage: https://rubygems.org/gems/blackstack-core
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -101,8 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Core modules, functions and constants for the BlackStack framework.
 test_files: []