forcast 0.0.110

data/lib/forcast/utils/measure.rb

@@ -0,0 +1,44 @@
+require 'benchmark'
+
+module Forcast
+  module Utils
+    module Measure
+      #
+      # Measure execution of block and display result
+      #
+      # Time is measured by Benchmark module, displayed time is total
+      # (user cpu time + system cpu time + user and system cpu time of children)
+      # This is not wallclock time.
+      def self.bench(title)
+        puts "#{title}... "
+        result = Benchmark.bm do |x|
+          yield(x)
+        end
+        puts "Salida Bench"
+      end
+      def self.measure(title)
+        puts "#{title}... "
+        result = Benchmark.measure do 
+          yield
+        end
+        $stderr.printf "%.03fs\n", result.total
+      end
+
+      # n = 50000
+      # FORCAST::Benchmark.bench("pagar_servicio") do |x|
+
+      # x.report { for i in 1..n; a = "1"; end }
+      # x.report { n.times do   ; a = "1"; end }
+      # x.report { 1.upto(n) do ; a = "1"; end }
+
+      # end
+
+      # FORCAST::Benchmark.measure("pagar_servicio") do
+
+      #   "a"*1_000_000
+
+      # end
+
+    end
+  end
+end

data/lib/forcast/utils/qvo.rb

@@ -0,0 +1,141 @@
+module FORCAST
+  module Qvo
+    class Pago
+      attr_accessor :headers
+      attr_accessor :url
+      attr_accessor :json_send
+      attr_accessor :metodo
+
+      def initialize
+        self.headers = {}
+      end
+
+      #Mostrar usuarios
+      def allUsers()
+        json_recived = constructor do
+            self.metodo = :get
+            self.url = "/customers"
+            self.json_send = {}
+        end
+        #userId = parser(servidor.conexion(:get, {},'/customers')[1], "id")
+        #puts userId[0].to_s #Ultimo usuario creado
+      end
+
+      def oneUser(userId)
+        json_recived = constructor do
+            self.metodo = :get
+            self.url = "/customers/"+userId
+            self.json_send = {}
+        end
+        #userId = parser(servidor.conexion(:get, {},'/customers')[1], "id")
+        #puts userId[0].to_s #Ultimo usuario creado
+      end
+      #Crear usuarios
+      def createUser(email, nombre, address, phone)
+        json_recived = constructor do
+            self.metodo = :post
+            self.url = "/customers"
+            self.json_send = {email: email, name: nombre, address: address, phone: phone}
+        end
+      end
+
+      #Update usuario
+      def updateUser(userId,variable,dato)
+        json_recived = constructor do
+            self.metodo = :put
+            self.url = "/customers/"+userId
+            self.json_send = {"#{variable}" =>  dato}
+        end
+      end
+
+      #Eliminar usuario
+      def deleteUser(userId)
+        json_recived = constructor do
+            self.metodo = :delete
+            self.url = "/customers/"+userId
+            self.json_send = {}
+        end
+      end
+      #Mostrar Tarjetas de los usuarios
+      def cardsUser(userId)
+        json_recived = constructor do
+            self.metodo = :get
+            self.url = "/customers/"+userId+"/cards"
+            self.json_send = {}
+        end
+      end
+
+      #Cobrar a la tarjeta de un usuario
+      def cobroUser(userId, cardId, amount, description)
+        json_recived = constructor do
+            self.metodo = :post
+            self.url = "/customers/"+userId+"/cards/"+cardId+"/charge"
+            self.json_send = {amount: amount, description: description}
+        end
+      end
+
+      #Inscribir/Ingresar tarjeta
+      def cardInscription(userId, return_url)
+        ruta = '/customers/'+userId+'/cards/inscriptions'
+        #return_url redirije al usuario post inscripcion de tarjeta
+        puts parser(servidor.conexion(:post, {},ruta,{return_url: return_url})[1])
+      end
+
+      #Eliminar tarjeta
+      def deleteCard(userId, cardId)
+        ruta = "/customers/"+userId+"/cards/"+cardId
+        puts parser(servidor.conexion(:delete, {},ruta)[1])
+      end
+
+      # Todas las transacciones realizadas
+      def allTransactions()
+        user = parser(servidor.conexion(:get, {},'/transactions')[1], "customer")
+        puts user[0]#ultimo usuario
+      end
+
+      #Reembolso de pago efectuado(transaccion)
+      def refundCard(transactionId)
+        ruta = "/transactions/"+transactionId+"/refund"
+        puts parser(servidor.conexion(:post, {},ruta)[1])
+      end
+
+      def constructor 
+          yield
+          resp = SERVIDORPAGOS.conexion(self.metodo, self.headers, self.url, self.json_send)
+          return true if resp[1].blank?
+          json_recived = {}
+          puts resp
+          if resp[0] && self.valid_json?(resp[1]) 
+            json_recived = JSON.parse(resp[1])
+            unless json_recived.is_a?(Array)
+              unless json_recived["error"].nil?
+                logger.info "[QVO] "+json_recived["error"].to_s
+                return false
+              end
+            end
+            return  json_recived
+          else
+            return false
+          end
+      end
+
+      def valid_json?(json)
+        begin
+          JSON.parse(json)
+          return true
+        rescue JSON::ParserError => e
+          puts e
+          return false
+        end
+      end
+
+      def parser(varible, key1 = '')
+        if key1 == ''
+          return JSON.pretty_generate(FORCAST::Server.response_to_json(varible))
+        else
+          return FORCAST::Server.response_to_json(varible).map {|i| i[key1]}
+        end
+      end
+    end
+  end
+end

data/lib/forcast/utils/server.rb

@@ -0,0 +1,296 @@
+require 'openssl'
+require 'base64'
+require 'securerandom'
+require 'http'
+require 'uri'
+require 'net/http'
+require 'net/http/digest_auth'
+
+module Forcast
+	module Utils
+		module Server
+				class Server
+
+					attr_accessor :username
+					attr_accessor :password
+					attr_accessor :ip 
+					attr_accessor :port
+					attr_accessor :ssl 
+					attr_accessor :dns 
+					attr_accessor :url
+					attr_accessor :before_ping
+					attr_accessor :data
+					attr_accessor :read
+					attr_accessor :write
+					attr_accessor :connect
+					attr_accessor :headers 
+
+					def initialize
+
+						self.read = 200
+						self.write = 200
+						self.connect = 10
+						self.headers = Hash.new
+						http = ''
+						yield(self)
+						self.ssl == true ? http = 'https://' : http = 'http://'
+						if self.dns.nil?
+							self.url = http + self.ip.to_s + ':' + self.port.to_s
+						else
+							self.port.nil? ? self.url = self.dns : self.url = self.dns.to_s + ':' + self.port.to_s
+						end
+						# self.freeze
+					end
+						
+					def set_uri_req(uri_req = '')
+						self.url += uri_req.to_s
+					end
+
+					def add_params_to_url(json = {})
+						return if json.empty?
+						keys = json.keys
+						str = '?'
+						keys.each do |key|
+							str += key.to_s + '=' + json[key].to_s + '&'
+						end
+						str = str[0...-1]
+						self.url += str
+					end
+
+					#Ver lo que se le envia al servidor
+					def request (metodo = :get, headers = {}, ruta = '', json_send = '')
+
+						url = self.url + ruta.to_s
+						http = HTTP.build_request(metodo, 
+												   url,
+												   {:json => json_send,
+												    :headers => self.headers.merge!(headers)})
+					end
+
+					def request_raw (metodo = :get, ruta = '', raw = {})
+
+						url = self.url + ruta.to_s
+						http = HTTP.build_request(metodo, 
+												   url,
+												   raw)
+					end
+
+
+					#Comprueba conexion con el servidor, devuelve True or False
+
+					def ping (ruta='')
+
+						url = self.url + ruta.to_s
+						begin
+							peticion = HTTP.timeout(:write => self.write, :connect => self.connect, :read => self.read)
+								           .headers(self.headers)
+								       	   .send(:get, url)
+						return [true,peticion]
+
+							rescue HTTP::TimeoutError => e
+
+						return [false,e]
+
+							rescue Exception => e
+
+						return [false,e]
+
+						ensure
+
+							#p "Ensure Ping"
+
+						end
+
+					end
+					#Intenta conectarse con el servidor un número x de veces en intervalos t. devuelve True or False
+					def iterate (metodo = :get, headers = '', ruta = '', json_send = '', iterate = 1, interval = 1)
+						arr = []
+						iterate.times do
+							arr.push(conexion(metodo,headers,ruta,json_send))
+							sleep interval
+						end
+						return arr
+					end
+
+					def abstract_connection
+
+						pp = ping if self.before_ping == true
+						return pp unless pp[0] if self.before_ping == true
+
+						begin
+							
+							peticion = yield       	   
+						
+							return [true,peticion]
+
+						rescue HTTP::TimeoutError => e
+
+							return [false,e]
+
+						rescue Exception => e
+
+							return [false,e]
+
+						ensure
+
+							#p "Ensure Conexion"
+
+						end
+
+					end
+
+					def conexion (metodo = :get, headers = '', ruta = '', json_send = '')
+
+						abstract_connection do 
+
+						url = self.url + ruta.to_s
+						HTTP.timeout(:write => self.write.to_i, :connect => self.connect.to_i, :read => self.read.to_i)
+								           .headers(self.headers.merge!(headers))
+								       	   .send(metodo, url, :json => json_send)
+						end
+
+					end
+
+
+					def conexion_basic_auth (metodo = :get, 
+											 headers = '', 
+											 ruta = '', 
+											 json_send = '',
+											 user= '',
+											 pass='')
+
+						abstract_connection do 
+
+						url = self.url + ruta.to_s
+						HTTP.timeout(:write => self.write.to_i, :connect => self.connect.to_i, :read => self.read.to_i)
+								           .headers(self.headers.merge!(headers))
+								       	   .send(:basic_auth, :user => user, :pass => pass)
+								       	   .send(metodo, url)
+						end
+
+					end
+
+					def conexion_auth (metodo = :get, 
+									   headers = '', 
+									   ruta = '', 
+									   json_send = '',
+									   auth = '')
+
+						abstract_connection do 
+
+						url = self.url + ruta.to_s
+						HTTP.timeout(:write => self.write.to_i, :connect => self.connect.to_i, :read => self.read.to_i)
+								           .headers(self.headers.merge!(headers))
+								       	   .send(:auth, auth)
+								       	   .send(metodo, url, :json => json_send)
+						end
+
+					end
+					
+					def conexion_raw (metodo = :get, 
+									   headers = '', 
+									   ruta = '', 
+									   raw = ''
+									   )
+
+						abstract_connection do 
+
+						url = self.url + ruta.to_s
+						HTTP.timeout(:write => self.write.to_i, :connect => self.connect.to_i, :read => self.read.to_i)
+								           .headers(headers)
+								       	   .send(metodo, url, raw)
+						end
+
+					end
+
+					def conexion_digest(metodo = :get, 
+											 headers = '', 
+											 ruta = '', 
+											 json_send = '',
+											 user= '',
+											 pass='')
+						abstract_connection do
+							digest_auth = Net::HTTP::DigestAuth.new
+							uri = URI.parse(self.url + ruta.to_s)
+							uri.user = user
+							uri.password = pass
+							h = Net::HTTP.new(uri.host, uri.port)
+							req = Net::HTTP::Get.new(uri.request_uri)
+							res = h.request(req)
+							# res is a 401 response with a WWW-Authenticate header
+							auth = digest_auth.auth_header(uri, res['www-authenticate'], 'GET')
+							# create a new request with the Authorization header
+							req = Net::HTTP::Get.new(uri.request_uri)
+							req.add_field('Authorization', auth)
+							# re-issue request with Authorization
+							res = h.request(req)
+							res
+						end
+					end
+				
+				end
+
+				def self.response_to_json (response)
+
+					begin
+				    	JSON.parse(response.body.readpartial)
+			        rescue Exception => e
+			        	return e
+			        rescue JSON::ParserError => e
+			        	return e
+			    	end
+
+				end
+		end
+	end
+end
+
+
+
+
+#    def build_header_auth(uri, version, httpmethod) 
+#     	response = get_auth_response(uri)
+#         @cnonce = Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
+#         @@nonce_count += 1 response['www-authenticate'] =~ /^(\w+) (.*)/
+#         challenge = $2
+#         params = {}
+#         challenge.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+ 
+#         a_1 = "#{@username}:#{params['realm']}:#{@password}" #username, realm and password
+#         a_2 = "#{httpmethod}:#{uri}" #method and path
+#         request_digest = '' request_digest << Digest::MD5.hexdigest(a_1)
+#         request_digest << ':' << params['nonce']
+#         request_digest << ':' << ('%08x' % @@nonce_count)
+#         request_digest << ':' << @cnonce
+#         request_digest << ':' << params['qop']
+#         request_digest << ':' << Digest::MD5.hexdigest(a_2)
+ 
+#         header = []
+#         header << "Digest username=\"#{@username}\""
+#         header << "realm=\"#{params['realm']}\""
+#         header << "qop=#{params['qop']}"
+#         header << "algorithm=MD5"
+#         header << "uri=\"#{uri}\""
+#         header << "nonce=\"#{params['nonce']}\""
+#         header << "nc=#{'%08x' % @@nonce_count}"
+#         header << "cnonce=\"#{@cnonce}\""
+#         header << "response=\"#{Digest::MD5.hexdigest(request_digest)}\""
+#         header << "opaque=\"#{params['opaque']}\""
+#         header_auth_str = header.join(', ')
+ 
+# # Build request (allows reuse)
+#     def build_request()
+#         @http = Net::HTTP.new(@uri.host, @uri.port)
+#         @http.use_ssl = true
+#         @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+#     end
+ 
+# # We need to get a response with a WWW-Authenticate request header
+#     def get_auth_response(uri)
+#         url = BASE_URL + uri
+#         @uri = URI.parse(url)
+#         build_request()
+#         req = Net::HTTP::Get.new(@uri.request_uri)
+#         response = @http.request(req)
+#         return response
+#     end